Question about referencing a class from a different source file in C++

Question

I was recently having some "undefined reference" errors that I managed to resolve but I don't understand why the solution works. I have the following main source file:

Main.cpp:

 #include <iostream>
#include "Log.h"

    int main()
    {
        std::cout << "Hello World!" << std::endl;

        Log log;
        log.SetLevel(Log::LevelWarning);
        log.Error("Hello!");
        log.Warning("Hello!");
        log.Info("Hello!");

        std::cin.get();
    }

which references a class declared in a separate source file:

Log.cpp:

#include <iostream>

class Log
{
public:
    enum Level
    {
       LevelError, LevelWarning, LevelInfo 
    };

private:
    Level m_LogLevel = LevelInfo;

public:
    void SetLevel (Level level)
    {
        m_LogLevel = level;
    }

    void Error (const char* message)
    {
        if (m_LogLevel >= LevelError)
            std::cout << "[ERROR]: " << message << std::endl;
    }

    void Warning (const char* message)
    {
        if (m_LogLevel >= LevelWarning)
            std::cout << "[WARNING]: " << message << std::endl;
    }

    void Info (const char* message)
    {
        if (m_LogLevel >= LevelInfo)
            std::cout << "[INFO]: " << message << std::endl;
    }
};

Log.h:

#pragma once

class Log
{
public:
    enum Level { LevelError, LevelWarning, LevelInfo };

private:
    Level m_LogLevel;

public:
    void SetLevel (Level);
    void Error (const char*);
    void Warning (const char*);
    void Info (const char*);
};

The code above gives me the linker errors "undefined reference to Log::..." for all members of the class Log being called in Main.cpp. Searching around I eventually found comment saying something along the lines of "static members and functions should be initialized", which gave me the idea of adding the following:

void Init()
{
    Log log;
    log.SetLevel(Log::LevelInfo);
    log.Error("NULL");
    log.Warning("NULL");
    log.Info("NULL");
}

To my Log.cpp file. This amazingly solves the issue and the project builds successfully, but these members are not declared as static and so I don't understand why this works, or even if this is the correct solution.

I'm using gcc in linux and compiling with "g++ Main.cpp Log.cpp -o main". Source files are in the same folder.

Answer 1

c++ is not java or c#. This construct won't generate any code at all:

class X
{
public:
     void foo()
     {
         std::cout << "Hello, world"<< std::endl;
     }
};

Yes, in java after compiling that you will get X.class which you can use. However in c++ this does not produce anything.

proof:

#include <stdio.h>

class X
{
    void foo()
    {
        printf("X");
    }
};

$ gcc -S main.cpp
$ cat main.s
    .file   "main.cpp"
    .ident  "GCC: (GNU) 4.9.3"
    .section        .note.GNU-stack,"",@progbits

In c++ you need something other than "definitions" for anything to be compiled.

If you want to emulate java-like compiler behaviour do this:

class X
{
public:
    void foo();
};

void X::foo()
{
    std::cout << "Hello, world"<< std::endl;
}

this will generate object file containing void X::foo().

proof:

$ gcc -c test.cpp
$ nm --demangle test.o
0000000000000000 T X::foo()

Another option is of course use inline method as you do but in this case you would need to #include whole "Log.cpp" into your "Main.cpp".

In c++ compilation is done by "translation units" instead of classes. One unit (say .cpp) produces one object file (.o). Such object file contains machine instructions and data.

Compiler does not see anything outside of a translation unit being compiled now.

Thereofre, unlike Java when main.cpp is compiled compiler only sees what is #included into main.cpp and main.cpp itself. Hence the compiler do not see the contents of Log.cpp at this time.

It's only at link time object files generated from translation units are merged together. But at this time it's too late to compile anything.

A class with inline function (like the first example) does not define any machine instructions or data.

For inline members of class machine instructions will be generated only when you use them.

Since you use your class members in main.cpp which is outside of translation unit Log.cpp during compilation of Log.cpp compiler does not generate any machine instructions for them.

Problem of One Definition Rule is a different one.

Answer 2

Your code is not correctly organized. You should not have two different class Log { ... }; contents for the same class.

Main.cpp needs to know the contents of class Log, so the (single) definition of class Log will need to be in your header file. That leaves the question of the definitions of the class member functions. There are three ways to define a class member function:

1. Inside the class definition (which is in a header).

This is what you attempted in your Log.cpp file. If you define all the members in the class definition in Log.h, then you don't need a Log.cpp file at all.

2. Outside the class definition, with the inline keyword, in the header file.

This would look like:

// Log.h
class Log
{
    // ...
public:
    void SetLevel(Level level);
    // ...
};

inline void Log::SetLevel(Level level)
{
    m_LogLevel = level;
}

3. Outside the class definition, with no inline keyword, in the source file.

This would look like:

// Log.h
class Log
{
    // ...
public:
    void SetLevel(Level level);
    // ...
};

// Log.cpp
#include "Log.h"

void Log::SetLevel(Level level)
{
    m_LogLevel = level;
}

Note Log.cpp includes Log.h, so that the compiler sees the class definition before you start trying to define its members.

You are allowed to mix and match these. Although there are no strict rules on what is best, a general guideline is that small and simple functions can go in the header file, and large and complex functions might do better in the source file. Some programmers recommend not putting any function definitions inside the class definition at all, or limiting this option to cases where the definition is very short and helps make clear what the purpose of the function is, since then the (public part of the) class definition is a summary of what the class does, not details about how it does it.

In some cases, it might be appropriate to define a class inside a source *.cpp file - but this means it can only be used from that file.