Is it possible to define a variable that can be set only once?

Pretty easy to roll your own.

template<typename T> class SetOnce { public: SetOnce(T init) : m_Val(init) {} SetOnce<T>& operator=(const T& other) { std::call_once(m_OnceFlag, [&]() { m_Val = other; }); return *this; } const T& get() { return m_Val; } private: T m_Val; std::once_flag m_OnceFlag; }; 

Then just use the wrapper class for your variable.

SetOnce<int> nFirst(0); nFirst= 1; nFirst= 2; nFirst= 3; std::cout << nFirst.get() << std::endl; 

Outputs:

1

Similar to cocarin's, but throws exception instead of silently ignoring assignment:

template <typename T, typename Counter = unsigned char> class SetOnce { public: SetOnce(const T& initval = T(), const Counter& initcount = 1): val(initval), counter(initcount) {} SetOnce(const SetOnce&) = default; SetOnce<T, Counter>& operator=(const T& newval) { if (counter) { --counter; val = newval; return *this; } else throw "Some error"; } operator const T&() const { return val; } // "getter" protected: T val; Counter counter; }; 

Usage:

SetOnce<int> x = 42; std::cout << x << '\n'; // => 42 x = 4; // x = 5; // fails std::cout << x << '\n'; // => 4 

Online demo

Your question is about avoiding the bool but also implies the need for const-ness.

To avoid the bool, I'd use a boost::optional like this:

boost::optional<int> nFirst; // .. if (!nFirst) nFirst = nIdx; // and now you can use *nFirst to get its value 

Then, you can enforce logical (rather than literal) const-ness like this:

const boost::optional<int> nFirst; // .. if (!nFirst) const_cast<boost::optional<int>&>(nFirst) = nIdx; // you can use *nFirst to get the value, any attempt to change it would cause a compile-time error 

Using const_cast is not the safest practice, but in your particular case and as long as you only do it once it'd be OK. It simplifies both your code and your intentions: you do want a const, it's just that you want to defer it's initialisation for a bit.

Now, as songyuanyao suggested, you could directly use an int instead of a boost::optional, but the latter makes your intention explicit so I think it's better this way. In the end of day this is C++ while songyuanyao's solution is really a C-style one.

This is set once template. You can use this class as assurance that the value will be set and saved only once. Every next try will be canceled.

#include <iostream> using namespace std; template <class T> class SetOnce; template<class T> std::ostream& operator<<( ostream& os, const SetOnce<T>& Obj ); template <class T> class SetOnce { public: SetOnce() {set = false; } ~SetOnce() {} void SetValue(T newValue) { value = !set ? newValue : value; set = true; } private: T value; bool set; friend std::ostream& operator<< <>( ostream& os, const SetOnce& Obj ); public: SetOnce<T>& operator=( const T& newValue ) { this->SetValue(newValue); return *this; } }; template<class T> std::ostream& operator<<( ostream& os, const SetOnce<T>& Obj ) { os << Obj.value; return os; } 

Use case:

int main() { SetOnce<bool> bvar; SetOnce<int> ivar; SetOnce<std::string> strvar; std::cout<<"initial values: \n"<<bvar<<" " <<ivar<<" "<<strvar<<" \n\n"; bvar = false; //bvar.SetValue(false); ivar = 45; //ivar.SetValue(45); strvar = "Darth Vader"; //strvar.SetValue("Darth Vader"); std::cout<<"set values: \n"<<bvar<<" " <<ivar<<" "<<strvar<<" \n\n"; bvar = true; //bvar.SetValue(true); ivar = 0; //ivar.SetValue(0); strvar = "Anakin"; //strvar.SetValue("Anakin"); std::cout<<"set again values: \n"<<bvar<<" " <<ivar<<" "<<strvar<<" \n\n"; return 0; }