Initialize a variable in a namespace in a function - c++

Question

I've had trouble with setting up variables in namespaces multiple times already, but usually now solve it by having the setup be as follows:
.h
namespace MyNS {
extern Variable var;
}
.cpp
#include "MyNS.h"
Variable MyNS::var;
Now, this works fine with primitives, but becomes a problem when the Variable object is somewhat of a more complex object.
Namely, my problem this time is that I would like to leave some variables uninitialized until I call a certain function. Something as follows:
.h
namespace MyNS {
extern Variable var;
void init();
}
.cpp
#include "MyNS.h"
Variable MyNS::var;
void MyNS::init() { var = Variable(a, b, c); }
This gives a compile time error, because Variable does not have a default constructor (And I don't want it to have one). But when I remove the 2nd line in the .cpp, I get linker error unresolved external symbol.
How can I solve this problem? How do I initialize a variable of a namespace "later"?
The "hacky" solution I have so far is to have my namespace hold a Variable*, initialize it to nullptr, and then assign it the actual object in my init function. But that seems incredibly hacky for something so simple, since I have no actual reason for using pointers in this case.

Answer 1

Variable does not have a default constructor (And I don't want it to have one)
Then you simply can't create an instances of Variable without passing values into its constructor, eg:
namespace MyNS {
extern Variable var;
void init();
}
#include "MyNS.h"
Variable MyNS::var(0, 0, 0);
void MyNS::init() { var = Variable(a, b, c); }
Another solution is to make var be a Variable* pointer instead, and then init() can new it, eg:
namespace MyNS {
extern Variable* var;
void init();
void cleanup();
}
#include "MyNS.h"
Variable* MyNS::var = nullptr;
void MyNS::init() { var = new Variable(a, b, c); }
void MyNS::cleanup() { delete var; }
Alternatively:
#include <memory>
namespace MyNS {
extern std::unique_ptr<Variable> var;
void init();
}
#include "MyNS.h"
std::unique_ptr<Variable> MyNS::var;
void MyNS::init() { var = std::make_unique<Variable>(a, b, c); }
Another solution would be to make var be a std::optional<Variable> instead, eg:
#include <optional>
namespace MyNS {
extern std::optional<Variable> var;
void init();
}
#include "MyNS.h"
std::optional<Variable> MyNS::var;
void MyNS::init() { var = Variable(a, b, c); }
Another solution is to wrap var inside of a singleton, eg:
namespace MyNS {
struct VariableAccess {
static Variable& Var();
};
}
#include "MyNS.h"
Variable& MyNS::VariableAccess::Var() {
static Variable var(a, b, c);
return var;
};