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...
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 (and it's not clear cut... it may make sense to keep SOME implementation details in the public .h).
If you're looking for a logical explanation of why this split is necessary you won't find one. Because there's none. The compiler could still use the one-compilation-unit-at-a-time model with just one file (by considering only the interface details, even if the implementation is in the same file). But this is C++, so you're forced to do the split and repeat things twice without making mistakes (otherwise it's YOUR fault if the code doesn't work: compilers are not required to detect all incompatibilities between what is in the .h and what is in .cpp; some are detected and some are not and just will (possibly) destroy all data on your computer if you make that kind of mistake).
The reason is mostly "because" (my own rationalization is may be keeping the compiler simpler and that back then it was considered an important "feature" being able to publish .h files and keep implementations secret).
Note: Even if you know Java, C++ is a completely different language... and it's a language that cannot be learned just 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 in addition to experimenting. Experimenting alone will take you nowhere near a decent level of C++ proficiency.
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.
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.
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.
Clazz MyClazz and Clazz MyClazz2? –
Electrolyte 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.
The first one must be put in the header file (where the declaration of the class resides). The second can be anywhere, either the header or, usually, a source file. In practice you can put small functions in the class declaration (which declares them implicitly inline, though it's the compiler that ultimately decides whether they will be inlined or not). However, most functions have a declaration in the header and the implementation in a cpp file, like in your second example. And no, I don't see any reason why this would be less readable. Not to mention you could actually split the implementation for a type across several cpp files.
A function that is defined inside a class is by default treated as an inline function. A simple reason why you should define your function outside:
A constructor of the class checks for virtual functions and initializes a virtual pointer to point to the proper VTABLE or the virtual method table, calls the base class constructor, and initializes variables of the current class, so it actually does some work.
The inline functions are used when functions are not so complicated and avoids the overhead of the function call. (The overhead includes a jump and branch on the hardware level.) And as described above, the constructor is not as simple to be considered as inline.
Inline functions(functions when you declare them in the class ) every time when call them they are pasted in your main memeory code. While when you declare the function outside the class, the when you call the fuction it comes from the same memory. Thats why it is much better.
© 2022 - 2024 — McMap. All rights reserved.
.cppfile. – Kinlawinline. – Naucratisinlineonly relaxes the one definition rule, which is necessary if another translation unit usesClazz– Rubidium