I have always thought of header files as a sort of 'public interface' describing a class, in which case it would be better to keep private fields and functions in the cpp file.
I understand that private fields need to be in the header so that other classes can tell how much memory an instance of a class will consume, but it occurred to me as I was about to write a private helper function, that this function could be made static, in which case there was no need for it to be 'part of the class' at all, it could just as easily be a regular function in the class definition's .cpp file.
It then occurred to me that all private functions could potentially be re-written to be static by accepting pointers/references to class fields instead of expecting to be defined in the class.
This would eliminate the need to declare any private functions in the header file.
I do like to follow conventions so now I want to ask, is it considered an established convention in C++, that non-static private functions should be in the header file? What about static functions or static constants?
EDIT: I'm going to put in some code to explain what I'm getting at:
.h file:
#ifndef SOME_CLASS_H #define SOME_CLASS_H class SomeClass { private: int x; public: void combineWithX(int y); }; #endif
.cpp file
#include "SomeClass.h" void someHelper(int* x) { *x = (*x) + 1; } void SomeClass::combineWithX(int y) { someHelper(&x); x += y; }
Note that someHelper(int* x)
in the cpp file references the private member x in spirit, but not directly, and therefore does not need to appear in the header. I'm wondering if this sort of thing is considered 'bad style'
No. If you import the same header from two files, you get redefinition of function. However, it's usual if the function is inline. Every file needs it's definition to generate code, so people usually put the definition in header.
using declaration (the most common being using namespace std; ) should not appear in a header file because they pollute the namespace of the source file in which it is included.
The header file contains only declarations, and is included by the . c file for the module. Put only structure type declarations, function prototypes, and global variable extern declarations, in the . h file; put the function definitions and global variable definitions and initializations in the .
In C program should necessarily contain the header file which stands for standard input and output used to take input with the help of scanf() and printf() function respectively.
Private helper functions can be hidden from public header file by moving them to an inner class. This works because inner class is considered part of the class and can access the surrounding class's private members.
Unlike PImpl idiom, this does not have any dynamic allocation or indirection penalty. Compile times should be faster when editing/refactoring private functions, as there is no need to recompile all the files including the public header.
Example:
public .h file
#ifndef SOME_CLASS_H #define SOME_CLASS_H class SomeClass { private: // Just forward declaring in public header. struct Private; int x; public: void combineWithX(int y); }; #endif
in .cpp file
#include "SomeClass.h" // Declare all private member functions of SomeClass here struct SomeClass::Private { static void someHelper(SomeClass& self) { self.x = self.x + 1; } }; void SomeClass::combineWithX(int y) { Private::someHelper(*this); x += y; }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With