Declare variable in namespace, define it in main, make it visible to all other files

Question

Using C++14, I'm trying to define a variable in a namespace where commonly used variables are stored (App::Common). The main function should be the one that sets it, since it gets set to argv[0]. Meanwhile I need the variable to be visible by all other classes/files. But I get the linker error shown below. Also, ideally I would like the variable to be const where only the main function would set it once.

common.hpp

#pragma once
#include <string>
namespace App{
    namespace Common{
        extern std::string appPath;
    }
}

main.cpp

#include "common.hpp"
#include "client.hpp"
#include <string>
int main() {
    App::Common::appPath = argv[0];
}

client.hpp

#include "common.hpp"
class Client {
    public:
    void printAppPath();
};

client.cpp

#include <iostream>
#include <string>
#include "common.hpp"
#include "client.hpp"
void Client::printAppPath() {
    std::cout << App::Common::appPath << std::endl;
}

I get the following error by the linker:

ld: main.o: in function `main':
main.cpp:(.text.startup.main+0x25): undefined reference to `App::Common::appPath[abi:cxx11]'
ld: Client.o: in function `Client::printAppPath()':
Client.cpp:(.text...): undefined reference to `App::Common::appPath[abi:cxx11]'

Answer 1

This

#pragma once
#include <string>
namespace App{
    namespace Common{
        extern std::string appPath;
    }
}

contains only declaration of the variable appPath without its definition.

Here

#include "common.hpp"
#include "client.hpp"
#include <string>
int main() {
    App::Common::appPath = argv[0];
}

there is used the assignment operator to assign a value tp the variable appPath as if it were already defined. However actually its definition does not yet exist.

You can define the variable in any module in any enclosing namespace of the namespace Common or inside the namespace. For example you could define it in client.cpp like

std::string App::Common::appPth;

Answer 2

You are mixing definition and assignment, which are two different things for a variable:

• a declaration for a variable x tells your compiler that there exists somewhere a variable named x;
• a definition for a variable x tells your compiler that it needs to reserve some space for this variable x, and that the variable x will live at this location;
• an assignment assigns a value to a variable.

For a variable, a declaration is usually a definition:

void foo() {
    int a; // Declaration AND Definition!
}

...except when the variable is marked as extern, since extern explicitly tells the compiler that this variable is defined elsewhere. In your case, this:

namespace App::Common {  // C++17 style
    extern std::string appPath;
}

...is a declaration, but this:

namespace App::Common {  // C++17 style
    std::string appPath;
}

...would be a definition (and also a declaration), and this:

int main(int argc, char *argv[]) {
    App::Common::appPath = std::string(argv[0]);
}

...is an assignment.

You should not define appPath in a header such as common.hpp, otherwize, you will have multiple definitions of the same variable (one for each .cpp file that includes your common.hpp) and the program will fail to compile.

What you want is a single definition for your program, and the only way to obtain it is to define App::Common::appPath once-and-for-all in a .cpp file. You can define it in main.cpp if you want:

#include <string>

#include "common.hpp"
#include "client.hpp"

// Definition:
std::string App::Common::appPath;

int main() {
    // Assignment:
    App::Common::appPath = argv[0];
}

Answer 3

You need definition:

in Common.cpp:

namespace App{
    namespace Common{
        std::string appPath;
    }
}