如何在C ++中的命名空间之间共享变量？

Question

I come from a C# background so I kindly ask the answers could compare to C#.

I have a namespace with functions and variables to parse input for my program. The namespace is defined in a header and a source file. I also have defined a struct which have one property for each input param in my program to facilitate communication across classes. Like the minimum working example below:

mytypes.h

#ifndef _MYTYPES_H_
#define _MYTYPES_H_
namespace MyTypes
{
    enum class Par1Opt
    {
        opt1,opt2
    };
    struct InputParam_t
    {
        Par1Opt par1;
        int test;
    };
}
#endif // _MYTYPES_H_

myinput.h

#ifndef _MYINPUT_H_
#define _MYINPUT_H_
#include <unordered_map>
#include <string>
#include "mytypes.h"
namespace MyInput
{
    static const std::string par1 = "par1";
    static int testVar;
    static MyTypes::InputParam_t inputParam;
    static std::unordered_map<MyTypes::Par1Opt, std::string> Par1OptToStr;
    void InitVariables(void);
}
#endif // _MYINPUT_H_

myinput.cpp

#include <unordered_map>
#include <string>
#include "mytypes.h"
#include "myinput.h"
namespace MyInput
{
    void InitVariables(void) // set some default values
    {
        inputParam.par1 = MyTypes::Par1Opt::opt1; // default value
        inputParam.test = 10;
        Par1OptToStr = std::unordered_map<MyTypes::Par1Opt, std::string>({
            { MyTypes::Par1Opt::opt1, "opt1" },
            { MyTypes::Par1Opt::opt2, "opt2" }
        });
        testVar = 20;
    }
}

main.cpp

#include <iostream>
#include "myinput.h"
int main(int argCount, char* args[])
{
    MyInput::InitVariables(); // expect to set MyInput:: variables here
    std::cout << MyInput::par1 << " = "
        << MyInput::Par1OptToStr[MyInput::inputParam.par1]
        << std::endl; // par1 = 
    std::cout << "inputParam.test = " << MyInput::inputParam.test
        << std::endl; // inputParam.test = 0
    std::cout << "testVar = " << MyInput::testVar
        << std::endl; // testVar = 0
    std::cin.get(); // pause
    // none of the values set for the MyInput:: variables inside InitVariables() method
    // are available in main
}

The questions are:

1. Why are the values set inside InitVariable() not available in main() ? Since the variables are static, I would expect (with mainly C# background) that the values would be available anywhere I use #include "myinput.h" . How can I solve it?

2. If I remove static keyword from variable declarations in myinput.h , then I get the Multiply defined symbols error. Why?

Thanks in advance!

Answer 1

When you declare a global variable in .h file with static specifier, you create a separate variable in each translation unit in which the .h file is included, so the variables referenced in myinput.cpp are not the same as variables referenced from main.cpp despite they have the same names.

When you create it with no specifier, you violate One Definition Rule .

What you should do is to declare variables with extern specifier in .h file and define them in one of .cpp files:

myinput.h

namespace MyInput
{
    extern const std::string par1;
    extern int testVar;
}

myinput.cpp

namespace MyInput
{
    const std::string par1 = "par1";
    int testVar;
}

Answer 2

In C# every module automatically sees any symbol from any other module or source file it references, provided the symbol is accessible, public or internal.

In C++, however, that is not the case. Even if the variable you want to access is public and global, you still need an external declaration to be able to use it. For example:

file1.cpp

int global = 0;

file2.cpp

int main()
{
    global = 1; //error: undefined symbol `global`.

    extern int global; //a declaration, not a definition
    global = 2; //ok!
}

Now, writing an extern declaration inside a function, as I just did is considered bad practice. It is better to write them globally.

extern int global;

int main()
{
    global = 3; //ok;
}

Then, writing the extern declaration this way is also considered bad practice, because you have to copy it in every module that needs to use the variable. It is better to write that in a file and #include it:

file1.h

extern int global;

file2.cpp

#include "file1.h"
int main()
{
    global = 4; //ok;
}

Then, it is also good practice to #include this .h file in the definition of the variable, so that the compiler can check that the definition and the declaration are consistent:

file1.cpp

#include "file1.h"
int global = 0; //ok: definition and initialization

float global; //error: type mismatch

If the declaration in the h file were not marked as external it would actually be a definition, and you could end up with multiple definitions of the same symbol, and a compiler or linker error.

Remember that #include does not do any magic under the hood, it is just a textual inclusion of the referred file. The magic is actually in the linker, but that's another story...