Question

Possible Duplicate:
Inline functions in C++

What does the compiler do if I completely implement a class in its header file? A typical example follows:

class MyException
{    
public:
    explicit MyException(const char* file, int line) file(file), line(line) {};
    const char* getFile() const { return file };
    int getLine() const { return line };
private:
    const char* const file;
    const int line;
};

My intention is to use the class like this: throw MyException(__FILE__, __LINE__).

I include this header file into each .cpp file. I suppose the compiler will compile the class as many times as it is defined and include the (identical) machine code into every object file it produces. Now, what will the linker do? I tried a simpler example (without all those pesky const‘s) and it compiled fine.

What would happen, if instead of a simple class, I implemented a three-screenful-long C function in a header file? And the final question, should I split my example into .h and .cpp files?

Answer 1

A class definition itself doesn’t produce any code. It just shows users of the class how it is layed out, so they can generate appropriate code to manipulate it.

It’s the member functions of the class that generate code. When you define a member function inside the class definition it gives the function an implicit inline declaration.

A function call can be compiled and linked in one of two ways:

(1) A single copy of the function code with a RETURN assembly instruction at the end can be placed in the image, and a CALL assembly instruction can be placed (along with param passing and return value transfer) at the call site to transfer control to this code.

or

(2) An entire copy of the function implementation can replace the entire function call at the call site.

A function declared inline is a recommendation to the compiler to do it the second way. Further an inline declaration allows the function to be defined in several translation units (so it can be placed in a shared header file). In order for the compiler have the option of implementing the second method, it needs a copy of the function implementation at compile-time. This isn’t available if the function implementation is in a foreign translation unit.

It should also be noted that modern compilers do complicated things with functions declared inline. See:

http://gcc.gnu.org/onlinedocs/gcc/Inline.html