Comment puis-je créer un tableau d'objets de la classe dont le constructeur ne requièrent que peu d'arguments?

J'ai lu à propos de la solution const A a[3] = { {0,0}, {1,1}, {2,2} }, mais dans mon programme const ne peut pas être utilisé:

class Paper: public PaperQueue{  
  ...
  protected:
    typedef int (Utils::*funcPtr) (int, int); //I use external function there
    funcPtr p;                               
    Utils* fptr; 
  public:
    int pricefunc(){     
      addprice = (fptr->*p) (t,price);
    }

    Paper(int n, unsigned int pr):PaperQueue(n){         
       ...
       p=&Utils::commonpricefunc;    
    }
    void Put(int a){ 
       ...
    }
  ...
}    

class Bank{ 
  ...
  void Buy(Paper &p){
   (/*this function modifies many parameters in 'p'*/)
  ...
  }
  ...
}

int main(){
Bank B;    
int pn=5;
/* ? */ const Paper p[pn] = {{5,15},{5,15},{5,15},{5,15},{5,15}}; /* ? */
int paperloop=0;
...
p[paperloop].Put(p[paperloop].addprice);
B.Buy(p[paperloop]);
...

Qui me donne BEAUCOUP d'erreurs(avec pricefunc (), (), Acheter(),...), ou tout simplement "variable objet de la taille de ‘p’ ne peut pas être initialisé". Est-il possible de faire cette matrice de travail? (Tout fonctionne bien si pas de passer des paramètres au constructeur!)

**const Paper p[pn] ?
J'ai besoin de créer un tableau, quelque chose comme Paper (p[pn])(5,25) ou quelque chose... Tous les constructeurs devraient recevoir ces paramètres et p[i] ne devrait pas être en lecture seule de l'objet.
C'était juste audacieuse balise à l'intérieur d'un code.

OriginalL'auteur Slowpoke | 2012-11-23

  1. 3

    Vous ne pouvez pas utiliser d'initialiseur de listes pour les classes (non Gousses) parce que ce serait ignorer l'appel au constructeur. Vous devrez le changer pour un POD ou utiliser std::vector de la manière suivante:

    Si la classe est copiable, comme il semble l'être, vous pouvez créer un std::vector et de le remplir avec les valeurs que vous voulez:

    const vector<Paper> papers(5, Paper(5, 15));

    Si vous voulez initialiser avec des valeurs différentes, vous pouvez utiliser une liste d'initialiseur, mais c'est uniquement pris en charge en C++11:

    const vector<Paper> papers = {Paper(1, 1), Paper(2, 2)};

    Sans C++11, vous aurez à ajouter les éléments un par un, mais vous ne pouvez pas faire le vecteur const:

    vector<Paper> papers;
papers.push_back(Paper(1, 1));
papers.push_back(Paper(2, 2));
    Merci!!!! int pn=5; vector<Paper> p(pn, Paper(5, 15)); fait. Au moins quelque chose.

    OriginalL'auteur user1610015

  2. 0

    Veuillez vérifier le code ci-dessous, il peut être compilé:

    class Paper {
public:
    int x, y;
}; 

int main() {
    Paper p[5] = {{5,15}, {5,15}, {5,15}, {5,15}, {5,15}};
}

    Veuillez vous référer ce post pour plus de détails, je pense qu'il explique très bien

    Le Code est conforme amende g++ 4.6.3, mais dans mon programme {5,15} sont les paramètres que j'essaie de transmettre au constructeur.
    Ok, merci!!!! Quand j'ai écrit p[5]. il semble fonctionner avec des avertissements avertissement: étendue de l'initialiseur listes uniquement disponible avec -std=c++0x ou -std=gnu++0x"
    Est-il possible, pour le rendre plus joli? J'ai voulu avoir quelque chose comme p[n]...

    OriginalL'auteur Matt