Inizializzazione di una matrice membro nel costruttore inizializzatore

Question

class C 
{
public:
 C() : arr({1,2,3}) //doesn't compile
{}
    /*
    C() : arr{1,2,3} //doesn't compile either
{}
    */
private:
 int arr[3];
};

Credo che il motivo è che gli array possono essere inizializzati solo con la sintassi =, che è il seguente:

int arr[3] = {1,3,4};

Domande

1. Come posso fare quello che voglio fare (che è, inizializzazione un array in un costruttore (non assegnare elementi nel corpo)). E 'anche possibile?
2. fa il 03 standard di dire qualcosa di speciale inizializzazione aggregati (compresi gli array) in inizializzatori ctor C ++? O l'invalidness del codice di cui sopra è un corollario di alcune altre regole?
3. Do C ++ 0x initializer liste risolvere il problema?

P.S. Si prega di non parlare di vettori, boost :: array e la loro superiorità in array, che sono ben consapevoli.

Answer 1

  

  
1. Come posso fare quello che voglio fare (che è, inizializzare un array in un costruttore (non assegnare elementi del corpo)). E 'anche possibile?
  

Sì. E 'utilizzando una struttura che contiene una matrice. Tu dici che già si conosce, ma poi io non capisco la domanda. In questo modo, non inizializzare un array nel costruttore, senza incarichi nel corpo. Questo è ciò che boost::array fa.

  

fa il 03 standard di dire qualcosa di speciale inizializzazione aggregati (compresi gli array) in inizializzatori ctor C ++? O l'invalidness del codice di cui sopra è un corollario di alcune altre regole?

Un mem-inizializzatore usi inizializzazione diretta. E le regole della clausola 8 vietano questo genere di cose. Non sono esattamente sicuro circa il caso seguente, ma alcuni compilatori non lo consentono.

struct A {
  char foo[6];
  A():foo("hello") { } /* valid? */
};

questo GCC PR per ulteriori dettagli.

  

Do C ++ 0x initializer liste risolvere il problema?

Sì, lo fanno. Tuttavia la sintassi non è valida, penso. Devi usare le parentesi direttamente a fuoco fuori dalla lista di inizializzazione

struct A {
  int foo[3];
  A():foo{1, 2, 3} { }
  A():foo({1, 2, 3}) { } /* invalid */
};

Answer 2

C ++ 98 non fornisce una sintassi diretta per tutto tranne azzeramento (o per elementi non POD, valore-inizializzazione) di matrice. Per questo è C(): arr() {} solo scrivere.

I cosa Roger Pate è sbagliata circa i presunti limiti del C ++ 0x aggregato di inizializzazione, ma sono troppo pigro per guardare in su o il check-out, e non importa, vero? Modifica : Roger stava parlando di "C ++ 03", ho letto male come "C ++ 0x". Siamo spiacenti, Roger. ☺

A C ++ 98 soluzione per il codice corrente è avvolgere la matrice in un struct e inizializzarlo da una costante statica di quel tipo. I dati deve risiedere da qualche parte in ogni caso. A braccio che può assomigliare a questo:

class C 
{
public:
    C() : arr( arrData ) {}

private:
     struct Arr{ int elem[3]; };
     Arr arr;
     static Arr const arrData;
};

C::Arr const C::arrData = {{1, 2, 3}};

Answer 3

Soluzione:

template<class T, size_t N>
struct simple_array { // like std::array in C++0x
   T arr[N];
};


class C : private simple_array<int, 3> 
{
      static simple_array<int, 3> myarr() {
           simple_array<int, 3> arr = {1,2,3};
           return arr;
      }
public:
      C() : simple_array<int, 3>(myarr()) {}
};

Answer 4

1. No, purtroppo.
2. Devi solo non può nel modo desiderato, come non è consentito dalla grammatica (più sotto). È possibile utilizzare solo ctor-come l'inizializzazione, e, come sapete, che non è disponibile per l'inizializzazione ogni elemento di array.
3. Credo di sì, come si generalizzano l'inizializzazione su tutta la linea in molti modi utili. Ma io non sono sicuro sui dettagli.

In C ++ 03, inizializzazione aggregato applica solo con sintassi simile come sotto, che deve essere una dichiarazione separata e non rientra in un inizializzatore ctor.

T var = {...};

Answer 5

Come su

...
  C() : arr{ {1,2,3} }
{}
...

compila bene su g ++ 4.8

Answer 6

Si vuole init una matrice di int nel costruttore? Puntare ad una matrice statica.

class C 
{
public:
    int *cArray;

};

C::C {
    static int c_init[]{1,2,3};
    cArray = c_init;
}