errore C2280: tentativo di fare riferimento a una funzione cancellata (atomico <int>)

Question

Ho un class A con una variabile membro _atomicVar di tipo std::atomic<int>.

#include <atomic> 

class A 
{ 
public: 
    A(); 
    ~A(); 

private: 
    std::atomic<int> _atomicVar; 
}; 

Se io costruisco il progetto ottengo il seguente errore:

error C2280: 'std::atomic<int>::atomic(const std::atomic<int> &)' : attempting to reference a deleted function 

Sono principalmente uno sviluppatore C# in modo da non so ogni dettaglio del C++ (ancora). Non so dove io uso la copia c'tor di atomic<int>.
Ho anche tentato di inizializzare _atomicVar:

std::atomic<int> _atomicVar { 0 }; 

... ma che non ha funzionato.
Mi aspetto che _atomicVar (senza inizializzazione esplicita) venga inizializzato con il valore predefinito per int.
Puoi dirmi perché si verifica questo errore?

Answer 1

Ecco perché il costruttore di copie di std::atomic è eliminato.

Vedere this documentation page.

Poiché non si definisce il costruttore di copie esplicito per A, il compilatore genera quello predefinito, che chiama semplicemente i costruttori di copia per tutti i membri (che non è consentito per std::atomic).

Soluzione:

class A 
{ 
public: 
    A(); 
    A(const A& origin); // add this line 
    ~A(); 
private: 
    std::atomic<int> _atomicVar; 
}; 

A::A(const A& origin) 
: _atomicVar(0) //zero-initialize _atomicVar 
{ 
} 

EDIT

Se vi chiedete, perché atomic tipi non sono copiabile, si consiglia di leggere this question, in particolare risposta accettata. Se si vuole il valore di std::atomic copia, si può fare:

A::A(const A& origin) 
: _atomicVar(origin._atomicVar.load()) 
{ 
} 

Ma tenere a mente, che questa operazione in sé non sarà un uno atomica (e, per la maggior parte le logiche, privo di significato).

Inoltre, è anche possibile definire un operatore di assegnazione esplicito (ricordare circa Rule of Three).

L'opzione migliore per il corretto comportamento del programma sarebbe l'eliminazione di questi due metodi:

class A 
{ 
public: 
    A(); 
    A(const A&) = delete; 
    ~A(); 

    A& operator=(const A&) = delete; 

private: 
    std::atomic<int> _atomicVar; 
}; 

Se il compilatore non supporta questo (ad esempio ogni VC prima VC12), li dichiarano come privato e non fornire un corpo:

class A 
{ 
public: 
    A(); 
    ~A(); 

private: 
    //do not define these two 
    A(const A&); 
    A& operator=(const A&); 

private: 
    std::atomic<int> _atomicVar; 
};