Function declaration inside or outside the class

Question

I am a JAVA developer who is trying to learn C++, but I don't really know what the best practice is for standard function declarations.

In the class:

class Clazz
{
 public:
    void Fun1()
    {
        //do something
    }
}

Or outside:

class Clazz
{
public:
    void Fun1();
}

Clazz::Fun1(){
    // Do something
}

I have a feeling that the second one can be less readable...

Solution 1

C++ is object oriented, in the sense that it supports the object oriented paradigm for software development.

However, differently from Java, C++ doesn't force you to group function definitions in classes: the standard C++ way for declaring a function is to just declare a function, without any class.

If instead you are talking about method declaration/definition then the standard way is to put just the declaration in an include file (normally named .h or .hpp) and the definition in a separate implementation file (normally named .cpp or .cxx). I agree this is indeed somewhat annoying and requires some duplication but it's how the language was designed (the main concept is that C++ compilation is done one unit at a time: you need the .cpp of the unit being compiled and just the .h of all the units being used by the compiled code; in other words the include file for a class must contain all the information needed to be able to generate code that uses the class). There are a LOT of details about this, with different implications about compile speed, execution speed, binary size and binary compatibility.

For quick experiments anything works... but for bigger projects the separation is something that is practically required (even if it may make sense to keep some implementation details in the public .h).

Note: Even if you know Java, C++ is a completely different language... and it's a language that cannot be learned by experimenting. The reason is that it's a rather complex language with a lot of asymmetries and apparently illogical choices, and most importantly, when you make a mistake there are no "runtime error angels" to save you like in Java... but there are instead "undefined behavior daemons".

The only reasonable way to learn C++ is by reading... no matter how smart you are there is no way you can guess what the committee decided (actually being smart is sometimes even a problem because the correct answer is illogical and a consequence of historical heritage.)

Just pick a good book or two and read them cover to cover.

Solution 2

The first defines your member function as an inline function, while the second doesn't. The definition of the function in this case resides in the header itself.

The second implementation would place the definition of the function in the cpp file.

Both are semantically different and it is not just a matter of style.

Solution 3

Function definition is better outside the class. That way your code can remain safe if required. The header file should just give declarations.

Suppose someone wants to use your code, you can just give him the .h file and the .obj file (obtained after compilation) of your class. He does not need the .cpp file to use your code.

That way your implementation is not visible to anyone else.

Solution 4

The "Inside the class" (I) method does the same as the "outside the class" (O) method.

However, (I) can be used when a class is only used in one file (inside a .cpp file). (O) is used when it is in a header file. cpp files are always compiled. Header files are compiled when you use #include "header.h".

If you use (I) in a header file, the function (Fun1) will be declared every time you include #include "header.h". This can lead to declaring the same function multiple times. This is harder to compile, and can even lead to errors.

Example for correct usage:

File1: "Clazz.h"

//This file sets up the class with a prototype body. 

class Clazz
{
public:
    void Fun1();//This is a Fun1 Prototype. 
};

File2: "Clazz.cpp"

#include "Clazz.h" 
//this file gives Fun1() (prototyped in the header) a body once.

void Clazz::Fun1()
{
    //Do stuff...
}

File3: "UseClazz.cpp"

#include "Clazz.h" 
//This file uses Fun1() but does not care where Fun1 was given a body. 

class MyClazz;
MyClazz.Fun1();//This does Fun1, as prototyped in the header.

File4: "AlsoUseClazz.cpp"

#include "Clazz.h" 
//This file uses Fun1() but does not care where Fun1 was given a body. 

class MyClazz2;
MyClazz2.Fun1();//This does Fun1, as prototyped in the header. 

File5: "DoNotUseClazzHeader.cpp"

//here we do not include Clazz.h. So this is another scope. 
class Clazz
{
public:
    void Fun1()
    {
         //Do something else...
    }
};

class MyClazz; //this is a totally different thing. 
MyClazz.Fun1(); //this does something else. 

Solution 5

Member functions can be defined within the class definition or separately using scope resolution operator, ::. Defining a member function within the class definition declares the function inline, even if you do not use the inline specifier. So either you can define Volume() function as below:

class Box
{
  public:

     double length;
     double breadth;    
     double height;     

     double getVolume(void)
     {
        return length * breadth * height;
     }
};

If you like you can define same function outside the class using scope resolution operator, :: as follows

double Box::getVolume(void)
{
   return length * breadth * height;
}

Here, only important point is that you would have to use class name just before :: operator. A member function will be called using a dot operator (.) on a object where it will manipulate data related to that object only as follows:

Box myBox;           

myBox.getVolume();  

(from: http://www.tutorialspoint.com/cplusplus/cpp_class_member_functions.htm) , both ways are legal.

I'm not an expert, but I think, if you put only one class definition in one file, then it does not really matter.

but if you apply something like inner class, or you have multiple class definition, the second one would be hard to read and maintained.

View more solutions

Comments

[Cody Gray]

There are actually 3 options here. Your second example could have the function definition in the header file (but still not inlined), or in a separate .cpp file.

[Björn Pollex]

This question might help you understand.

[Evgeni Sergeev]

Just a note: declaration is always inside the class, but definition is either inside or outside. The question title and body should be subjected to s/declaration/definition/ Don't believe me? stackoverflow.com/q/1410563/1143274

[John Strood]

Function definitions inside class must be avoided. They are deemed implicitly inline.

[Caleth]

@JohnStrood so? inline only relaxes the one definition rule, which is necessary if another translation unit uses Clazz

[Buttons840]

cplusplus.com/doc/tutorial/classes gives the same answer: "The only difference between defining a class member function completely within its class or to include only the prototype and later its definition, is that in the first case the function will automatically be considered an inline member function by the compiler, while in the second it will be a normal (not-inline) class member function, which in fact supposes no difference in behavior."

[JustinJDavies]

Can you bring the relevant content from that link into the body of your post, and thus future-proofing against dead links? Thanks

[Daniel S.]

If someone comes from Java and asks for help on C++, then what does it tell him if you say "the language you know is obsessed with something"? He doesn't have a comparison to other languages, so this tells him pretty much nothing. Better than using a stronly emotionally connotated word like obsessed, which doesn't tell the OP much, you might consider just leaving this part out. Moreover, what is the context of "use a class for everyting"? In Java, you do not use a class for a method. You do not use a class for a variable. You do not use a class for a file..So what's "everything" here? Ranting?

[6502]

@DanielS: Removed that part because apparently offended you (no idea why). For sure I'm not ranting about Java because I don't actually use Java at all, I simply thought at the time that OOP as Object Obsessed Programming was a funny joke, while apparently it is not. I've been a Java 1.1 certified programmer but decided back then that, unless forced for some reason, I will not use that "programming language" and so far I succeeded in avoiding it.

[Daniel S.]

Thanks, I think it reads much better now. Sorry if I sound offended. I will try to be more positive next time.

[Petr Peller]

Does not answer the question

[6502]

@PetrPeller: what is the part of the third paragraph that is not clear to you?

[SimonC]

"undefined behaviour deamons" - I guess I prefer nasal deamons

[Chupo_cro]

You mean Clazz MyClazz and Clazz MyClazz2?

[Big Temp]

"inline" has practically nothing to do with inlining. The fact that member functions defined in-line are implicitly declared inline is there to avoid ODR violations.

[HotelCalifornia]

"what is the part of the third paragraph that is not clear to you?" well I know this answer is nearly 10 years old now but a) it's far and away the highest rated answer here and b) you talk a lot about standard ways of doing things and mention that separation into declaration and definition is "practically required" without talking at all about what the practical differences between the two methods are, which is what the question originally asked.