Uninitialized global variable in the map inside class metod - c++

Question

I have the following problem, I have a class that I want to be constructed from two different kinds of complex objects. There is a map inside a class method, that constructs from extern variables that I defined in the outer of the class. If I want to declare a class object inside the main function everything goes fine. But if I declare it outside the main, constructor of the class is called before the initialization of the extern objects from which I constructed the inner map in the class method. The error repeats itself on Clang and MSVC. If I use simple objects to construct the map (like int or double), everything works fine in both ways.
main.cpp
#include "TestClass.h"
TestClass test1 = TestClass(g_Spec1); // 1
int main()
{
TestClass test2 = TestClass(g_Spec1); // 2
}
If you comment 1 everything works fine, however, as is, 2 didn't see extern variables.
TestClass.h
#pragma once
#include <iostream>
#include <map>
#include "Token.h"
extern const Spec_t g_Spec1;
extern const Spec_t g_Spec2;
extern const Spec_t g_Spec3;
extern const Name_t g_Name1;
extern const Name_t g_Name2;
extern const Name_t g_Name3;
class TestClass {
private:
Name_t name;
Spec_t spec;
static const Name_t& foo(const Spec_t& j);
public:
TestClass() = default;
TestClass(const Spec_t& j);
virtual ~TestClass() = default;
};
TestClass.cpp
#include "TestClass.h"
const Spec_t g_Spec1{ {Token::Type1, 2} };
const Spec_t g_Spec2{ {Token::Type1, 3} };
const Spec_t g_Spec3{ {Token::Type1, 4} };
const Name_t g_Name1{ "Name1" };
const Name_t g_Name2{ "Name2"};
const Name_t g_Name3{ "Name3" };
const Name_t& TestClass::foo(const Spec_t& spec_)
{
static const std::map<Spec_t, Name_t > glmap1 =
{
{g_Spec1, g_Name1},
{g_Spec2, g_Name2}
};
std::cout << "Foo: Map size must be 2, but it is " << glmap1.size() << std::endl;
std::cout << "In FOO Name1 is " << g_Name1 << std::endl;
auto constIterator = glmap1.find(spec_);
if (constIterator == glmap1.cend())
{
std::cout << "Not found " << std::endl; // 3
return g_Name3;
}
else
{
std::cout << "Found " << constIterator->second << std::endl; // 4
return constIterator->second;
}
}
TestClass::TestClass(const Spec_t& j)
{
name = foo(j);
spec = j;
std::cout << "In CONSTRUCTOR name as global variable from map " << name << std::endl;
}
Another interesting thing is that 1 call 4(Found) and 2 calls 3(Not found) but the map is empty in both ways. Maybe it is because g_Spec1 didn't initialize at this time?
And I didn't get why the map inside is debugger is empty, but have size = 1
Token.h
#pragma once
#include <cinttypes>
#include <string>
#include <vector>
enum class Token
{
Type1,
Type2
};
struct TokenId
{
Token tok;
std::uint64_t val;
bool operator==(const TokenId& p_Other) const noexcept
{
return (tok == p_Other.tok && val == p_Other.val);
}
bool operator<(const TokenId& p_Other) const noexcept
{
if (tok < p_Other.tok) return true;
else if (tok == p_Other.tok)
{
return val < p_Other.val;
}
else return false;
}
};
using Name_t = std::string;
using Spec_t = std::vector<TokenId>;

Answer 1

This is not entirely surprising. Initialization of global objects is partially ordered. Definitions from a single file are ordered by their appearance within that file, but there is no order across files.
You might see unexpected results in a debugger, because using uninitialized variables is undefined behavior.
This is just one of the reasons why global variables are best avoided. In your case, just put that variable inside main().