const void * object initialization issue C++ - c++

Question

I have a classcalled Tracer in C++. In my Tracer.h file I have:
class Tracer{
public:
// not useful to the question.
private:
Logger *m_logger;
const char *m_who;
const char *m_fileName;
const void * m_theObject;
int m_lineNum;
int m_log_level;
}
And in Tracer.cpp I have:
Tracer::Tracer(
Logger *logger,
const void *theObject,
const char *who,
const char *file,
int line,
int log_level
) :
m_logger(logger),
m_who(who),
m_fileName(file),
m_lineNum(line),
m_theObject(theObject),
m_log_level(log_level)
{
// more implementation which is not useful to the problem.
The problem is, when I initialize m_theObject(theObject), I get the following warning:
/home/pribeiro/workspace/Tracer.h:80: warning: 'const void* Tracer::m_theObject'
/home/pribeiro/workspace/Tracer.cpp:27: warning: when initialized here
Tracer.h:80 is the declaration of m_theObject in the Tracer.h and Tracer.cpp:27 is the m_theObject(theObject line.
In my compilation level, warnings are treated like errors. Why is the compiler complaining about the initiliazation of a const void * pointer?

Answer 1

That's not the whole warning. It's actually warning that m_lineNum and m_theObject are being initialised in the wrong order (see Member fields, order of construction):
Tracer.h:80: warning: 'const void* Tracer::m_theObject' is initialized before 'int Tracer::m_lineNum'
Tracer.cpp:27: warning: when initialized here
The fix is to swap the order of initialisation, or the order of definition:
Tracer::Tracer(
Logger *logger,
const void *theObject,
const char *who,
const char *file,
int line,
int log_level
) :
m_logger(logger),
m_who(who),
m_fileName(file),
m_theObject(theObject), // here
m_lineNum(line), // and here
m_log_level(log_level)
{
// more implementation which is not useful to the problem.

Answer 2

Sometimes compilers give a warning when members are initialised in the member initialisation list in a different order than they are declared in the header. I have seen g++ do this before. If you reorder your initialisation list so that it is in the same order as the members appear in your header file you should see this warning disappear.

Answer 3

The issue here is that, as per the C++ Standard, member variables are always (ALWAYS) initialized in the order of declaration, regardless of the order you give in the constructor.
The compiler nicely warns you about your misfit, because possibly you introduce unintended dependency chains.
Example:
struct Foo {
int _1, _2, _3;
Foo() : _3(_2+_1), // Third initialization
_2(_1+_1), // Second initialization
_1(1) // First initialization
{}
};
#include <iostream>
int main () {
Foo f;
std::cout << f._1 << f._2 << f._3 << '\n';
}
Output:
123
But the order of member initializers may let the maintainer think he could do better:
struct Foo {
int _1, _2, _3;
Foo() : _3(3),
_2(_3-1),
_1(_2-1)
{}
};
#include <iostream>
int main () {
Foo f;
std::cout << f._1 << f._2 << f._3 << '\n';
}
One might again expect the output of 123 as it looks like _3 is initiliazed first in that constructor. But that's not true:
./teh_program
13451434436167553
./teh_program
134514344118742913
./teh_program
13451434495068033
The results are totally unpredictable, multiple runs give different results without even recompiling. And the compiler is to prevent accidents like this.