C++ Design Question

You'll have 15,000 copies of the members of the class, but only one copy of the code. The compiler is smart enough to know to only make one copy, regardless of inlining.

If you want a member (variable) of a class to be shared between ALL instances of that class, prefix it with the "static" keyword, i.e.

class A {
pubilc:
int m_a;
static int m_b;
};

if you create 15,000 A classes, you'll have 15,000 m_a's, but only one m_b.

Note that you have to explicitly define static variables in your source as if they were globals - "int A::m_b = 0;", or you'll get link errors.

Probably more than you ever wanted to know.

Mason McCuskey
Spin Studios
www.spin-studios.com

Probably the fastest response that I have ever received. Thanks you cleared up a pile of questions I had.

Kressilac

------------------
Derek Licciardi

Also, IMO, don't waste your time with get/set functions for every variable. You only really want to use them if something unintuitive happens when you get/set variables. (i.e. when you change a database field it needs to validate the data, set a recordChanged flag etc.)

A better way to encapulate that kind of thing is just to typedef something like ATTRIBUTE as an int.

Note that an inlined function is not a function at all. It works similarly to how a #define macro works, except the compiler does type-checking and you're allowed a function syntax.

In other words, an inlined function isn't a function, it's a macro. The code to execute the function is inserted everywhere in your source code where the inline function is called.

So, here's a longer answer to the question, "what's created when I instantiate N copies of a class?":
- N instances of each member variable
- 1 instance of each member function
- M copies of the code in your inline function, where M is the number of times that function call appears in the source code.

HTH.

Stoffel: The compiler is supposed to be able to pick and choose which functions it will treat as inline (meaning the actual code is placed wherever you called the function). You just specify which functions you would like to be inline.

Kind of like the old register variable type...

- null_pointer

First, about stoffel's post and inline functions. An inline function is EITHER a function OR a macro OR BOTH...depending on the compiler's analysis of the situation. The COMPILER looks at HOW much memory is taken up by expanding the code (MACRO), and how much by making it a function and calling it, and it chooses the best option (ideally). It's really simple, and here's some examples of when and where it will choose each.

Ex 1 - When an inline function consists on nothing but a single function call itself, it will ALWAYS be expanded (cause the space for calling a FUNCTION version is equal to the space of EXPANDING it, and expanding it saves the overhead of having the function anywhere in the code.

Ex 2 - When a fairly small function is called only a few times (compiler dependent, but usually around 8) it is expanded.

Ex 3 - When a fairly small function is called MANY times (compiler dependant) it is made into a function and called like all other functions.

Ex 4 - When a LARGE function is called only a few times. This one is compiler dependant. Some analize the situation and choose whichever is more effiecent, some just perform the test for number of uses and if it is below the threashhold they expand it as a macro (never mind the inefficiency of this particualar case).

Hope that helps.

BTW jharler is 100% correct in his post.

about the number of things instantiated - stoffels post is correct except the inline issue (which i addressed above). But I wanted to explain WHY so you would understand it better. A FUNCTION (any function) is STATIC by default, a variable is not. This is why when you want to use a function in another module you don't have to use static on the body, or extern on the prototype, but you do for shared variables. But be VERY carefull...since static behavior is assumed for functions, they made using the static keyword on MEMBER FUNCTION do something else. A STATIC MEMBER FUNCTION is one that can be accessed without an instance of the class (it doesn't pass a 'this' pointer, and it can be called directly).
Example:
class Useless
{
public:
static GetClassName(void) {return "Useless";}
};
in main you can say:
cout << Useless::GetClassName();
and it calls that function directly. There are very few uses for such functions, but there is ONE VERY IMPORTANT ONE...for implementing FACTORIES...a very importan OO design pattern. This allows you to have a class member function that controls creation of instances of the class...pretty neat;