C'è un modo per rendere un valore struct C++-inizializzare tutte le variabili dei membri POD?

Question

Supponiamo che io sono un ++ struct C che ha sia POD e non-POD variabili membro:

struct Struct { 
    std::string String; 
    int Int; 
}; 

e in ordine per il mio programma per la produzione di un comportamento riproducibile voglio avere tutte le variabili membro inizializzate in costruzione. Posso usare una lista di inizializzazione per questo:

Struct::Struct() : Int() {} 

il problema è, non appena ho bisogno di cambiare il mio struct e aggiungere una nuova variabile membro POD (diciamo bool Bool) rischierei dimenticare di aggiungere alla lista di inizializzazione. Quindi la nuova variabile membro non verrà inizializzata in base al valore durante la costruzione della struct.

Inoltre non posso usare il memset() trucco:

Struct::Struct() 
{ 
    memset(this, 0, sizeof(*this)); //can break non-POD member variables 
} 

perché chiamando memset() per sovrascrivere le variabili membro già costruiti non-POD può rompere quelli.

C'è un modo per applicare l'inizializzazione del valore di tutte le variabili membro POD senza aggiungere esplicitamente la loro inizializzazione in questo caso?

Answer 1

Il modo più pulito sarebbe quella di scrivere l'auto-initialzed classe template initialized<T>:

EDIT: Mi rendo conto ora può essere reso ancora più flessibile, consentendo di dichiarare initialized<Struct>. Ciò significa che è possibile dichiarare l'inizializzazione senza modificare l'originale Struct. L'inizializzazione predefinita 'T()' è stata ispirata dalla risposta di Prasoons.

template<class T> 
struct initialized 
{ 
public: 

    initialized() 
     { value = T(); } 

    initialized(T t) 
     { value = t; } 

    initialized(const initialized<T>& x) 
     { value = x.value; } 

    T* operator &() { return &value; } 

    operator T&() { return value; }  

private: 
    T value; 
}; 


struct PodStruct 
{    
    std::string String;  
    int Int; 
}; 


struct GlorifiedPodStruct 
{    
    std::string String;  
    initialized<int> Int; 
}; 

void Test() 
{ 
    GlorifiedPodStruct s; 
    s.Int = 1; 
    int b = s.Int; 
    int * pointer = &s.Int; 

    initialized<PodStruct> s2; 
} 

Questo compila, ma potrebbe essere necessario più operatori di conversione, la gestione delle parole chiave come volatile, ecc, ma si ottiene l'idea.

Answer 2

Linked Domanda here

C'è un modo per far rispettare valore di inizializzazione di tutte le variabili membro POD senza aggiungere in modo esplicito la loro inizializzazione in questo caso?

io non sono sicuro se sia possibile [direttamente] o meno qualcosa di simile, ma funziona il seguente

prasoon@prasoon-desktop ~ $ cat check.cpp && clang++ check.cpp && ./a.out 
#include <iostream> 
struct Struct { 
    std::string String; 
    int Int; 
    bool k; 
    // add add add 
}; 

struct InStruct:Struct 
{ 
    InStruct():Struct(){} 
}; 

int main() 
{ 
    InStruct i; 
    std::cout<< i.k << " " << i.Int << std::endl; 
} 
0 0 
prasoon@prasoon-desktop ~ $ 

Answer 3

È possibile aggiungere una struttura di base:

struct PODStruct 
{ 
    PODStruct(unsinged int count) { memset(this, 0, count);} 
}; 

E poi il tuo struct derivato da questo struct base, il primo posto se si dispone di più di una le strutture di base,

struct Struct : PODStruct 
{ 
    Struct(); 
    std::string Str; 
    int Int; 
} 

Struc::Struct() : PODStruct(sizeof(Struct)) 
{ 
}