È possibile definire una variabile che può essere impostata solo una volta?

Question

Conosco const, che non può essere modificato dopo la creazione. Ma mi stavo chiedendo se esiste un modo per dichiarare una variabile che si imposta solo una volta e, successivamente, non può sovrascrivere. Nel mio codice, vorrei evitare la variabile bool avendo uno nFirst che, una volta impostato su nIdx, non può essere impostato sul nuovo valore di nIdx.

Il mio codice:

int nFirst = 0; 
    int nIdx = 0; 
    bool bFound = false; 
    BOOST_FOREACH(Foo* pFoo, aArray) 
    { 
     if (pFoo!= NULL) 
     { 
      pFoo->DoSmth(); 
      if (!bFound) 
      { 
       nFirst= nIdx; 
       bFound = true; 
      } 
     } 
     nIdx++; 
    } 

Answer 1

Vorrei evitare la variabile bool

È possibile controllare nFirst stessa, sulla base del fatto che non sarà impostato un numero negativo . Ad esempio:

int nFirst = -1; 
int nIdx = 0; 
BOOST_FOREACH(Foo* pFoo, aArray) 
{ 
    if (pFoo != NULL) 
    { 
     pFoo->DoSmth(); 
     if (nFirst == -1) 
     { 
      nFirst = nIdx; 
     } 
    } 
    nIdx++; 
} 

Answer 2

Abbastanza facile da rotolare.

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; 
}; 

Quindi utilizzare solo la classe wrapper per la variabile.

SetOnce<int> nFirst(0); 
nFirst= 1; 
nFirst= 2; 
nFirst= 3; 

std::cout << nFirst.get() << std::endl; 

Uscite:

Answer 3

la tua domanda è su come evitare il bool, ma implica anche la necessità di const-ness.

Per evitare il bool, userei un boost :: optional come questo:

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

Quindi, è possibile far rispettare logica (piuttosto che letterale) const-ness come questo:

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 

Utilizzando const_cast non è la pratica più sicura, ma nel tuo caso particolare e finché si fa solo una volta che sarebbe stato OK. Semplifica sia il tuo codice che le tue intenzioni: vuoi un const, è solo che vuoi rimandare l'inizializzazione per un po '.

Ora, come songyuanyao suggerito, è possibile utilizzare direttamente un int invece di un boost :: facoltativa, ma quest'ultimo rende la vostra esplicita intenzione quindi penso che sia meglio così. Alla fine del giorno questo è C++ mentre la soluzione di songyuanyao è davvero in stile C.

Answer 4

Simile a cocarin's, ma genera un'eccezione invece di assegnazione in silenzio ignorare:

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