[C++] Inizializzare array con lista di inizializzazione

[ing82]

In prova.h definisco

class Prova
{
  public:
    Prova();
    //altro...
  private:
    double valore;
    //altro...
}

Se col costruttore di default voglio inizializzare valore a zero faccio, in prova .cpp

Prova::Prova():valore(0.0)
{
  //altre cose...
}

Se al posto di valore avessi un array, è possibile inizializzare a 0.0 l'array con la lista di inizializzazione?
Fino ad ora ho sempre fatto in questo modo
In prova.h definisco

class Prova
{
  public:
    Prova();
    //altro...
  private:
    double valore[5];
    //altro...
}

In prova .cpp

Prova::Prova()
{
  for(unsigned int i=0;i<5;i++)
  {
    valore[i]=0.0;
  }
  //altre cose...
}

è possibile invece (per quello che ho letto non mi pare, ma chiedo conferma) fare un qualcosa del genere? (è pseudocodice diciamo, perchè non funziona, ma serve solo a chiarire quello che ho in mente)

Prova::Prova():valore[]({0,0,0,0,0})
{
  //altre cose...
}

Grazie

[shodan]

Si, a patto di avere un compilatore C++11 (praticamente tutti ormai) puoi scegliere di fare:

class Prova
{
  public:
    Prova();
    //altro...
  private:
    double valore[5] = {0.0};
    //altro...
}

o

Prova::Prova(): valore {0}
{
  //altre cose...
}

a scelta.

[ing82]

Ho fatto una prova qui, col codice seguente ottengo tutti zero

// Example program
#include <iostream>
#include <string>

class Prova
{
  public:
    Prova():valore {0.0}{};
    void getValore()
    {
      for(unsigned int i=0;i<5;i++)
      {
        std::cout<<"\n"<<valore[i];
      }
    };
    //altro...
  private:
    double valore[5];
    //altro...
};

int main()
{
  Prova prova;
  prova.getValore();

}

E anche con questo

// Example program
#include <iostream>
#include <string>

class Prova
{
  public:
    Prova(){};
    void getValore()
    {
      for(unsigned int i=0;i<5;i++)
      {
        std::cout<<"\n"<<valore[i];
      }
    };
    //altro...
  private:
    double valore[5]={0.0};
    //altro...
};

int main()
{
  Prova prova;
  prova.getValore();

}

Con questo codice, e anche il successivo, ottengo 33 solo al primo elemento, gli altri sono zero. In basso, il compilatore è settato a C++14.

// Example program
#include <iostream>
#include <string>

class Prova
{
  public:
    Prova():valore {33}{};
    void getValore()
    {
      for(unsigned int i=0;i<5;i++)
      {
        std::cout<<"\n"<<valore[i];
      }
    };
    //altro...
  private:
    double valore[5];
    //altro...
};

int main()
{
  Prova prova;
  prova.getValore();

}

// Example program
#include <iostream>
#include <string>

class Prova
{
  public:
    Prova(){};
    void getValore()
    {
      for(unsigned int i=0;i<5;i++)
      {
        std::cout<<"\n"<<valore[i];
      }
    };
    //altro...
  private:
    double valore[5]={33};
    //altro...
};

int main()
{
  Prova prova;
  prova.getValore();

}

Se faccio

// Example program
#include <iostream>
#include <string>

class Prova
{
  public:
    Prova():valore {33,2,5,6,7}{};
    void getValore()
    {
      for(unsigned int i=0;i<5;i++)
      {
        std::cout<<"\n"<<valore[i];
      }
    };
    //altro...
  private:
    double valore[5];
    //altro...
};

int main()
{
  Prova prova;
  prova.getValore();

}

oppure

// Example program
#include <iostream>
#include <string>

class Prova
{
  public:
    Prova(){};
    void getValore()
    {
      for(unsigned int i=0;i<5;i++)
      {
        std::cout<<"\n"<<valore[i];
      }
    };
    //altro...
  private:
    double valore[5]={33,2,5,6,7};
    //altro...
};

int main()
{
  Prova prova;
  prova.getValore();

}

Il tutto funziona correttamente.


Dove stà l'inghippo?
Uno dei dati membro è un array in quanto conosco il suo numero di elementi tramite un tipo enumerato (al posto di 5 c'è AltraClasse::NumeroElementiArray), che potrebbe cambiare valore: col ciclo for il tutto era gestito in automatico, se invece devo passargli la lista di tutti gli zero, la cosa non è più automatica...

A casa uso Code::Blocks e compilatore gcc se non ricordo male, può dipendere da questo?

Grazie ancora

[shodan]

Dove stà l'inghippo?

Nessun inghippo. Semplicemente se metti {0} in automatico il compilatore mette a zero tutte le locazioni dell'array, con {33} il compilatore mette la prima locazione a 33 e il resto a zero. Se vuoi valori diversi li devi esplicitare locazione per locazione come faresti con un array normale.

Uno dei dati membro è un array in quanto conosco il suo numero di elementi tramite un tipo enumerato (al posto di 5 c'è AltraClasse::NumeroElementiArray), che potrebbe cambiare valore: col ciclo for il tutto era gestito in automatico, se invece devo passargli la lista di tutti gli zero, la cosa non è più automatica...

Come detto non serve passargli una lista di tutti zero: ne basta uno anche se l'array ha 2^n locazioni.