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.

You should never directly access member variables in a class unless you are absolutely sure that the way that variable is used will never change, which in most cases, you aren't.

If you access a particular member variable of a class directly throughout a program, and then you decide that you need to do something when that variable is accessed (such as keeping a reference count or something), you will have to change each and every place in your program where you access that variable. However, if you use an access routine, then you just add the additional code to the class function.

If you're worried about speed, then make the access routine inline. Then it is essentially identical to directly accessing the variable itself, but allows for unforseen future changes.

Josh

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;