L'initialisation d'un tableau d'objets

Je suis actuellement en train de travailler sur un jeu de carte, et je vais avoir des problèmes avec un code d'initialisation:

//in my class...
Card cards[20];
//in method...
for(int i = 0; i <= 20;i++)
    cards++ = new Card(i, /*i as char +*/ "_Card.bmp");

Le problème, c'est que mon compilateur me dit que cards++ n'est pas une l-value. J'ai lu sur l'ensemble du pointeur de tableau d'équivalence chose, et j'ai pensé que je l'ai compris, mais hélas, je ne peux pas le faire fonctionner. Ma compréhension est que, depuis cards se dégrade à un pointeur, et le new opérateur me donne un pointeur vers l'emplacement de ma nouvelle instance de la Carte, puis le code ci-dessus devrait compiler. Droit?

J'ai essayé à l'aide d'un indice, mais n'est pas cards+i, cards++, et cards[i] seulement 3 façons de dire la même chose? J'ai pensé que chacun de ceux qui étaient l-valeurs et sont traités comme des pointeurs.

cartes+je retourne cartes+i; cartes++ incrémentation de cartes; cartes[i] renvoie une référence à la i-ième élément de cartes. Ils sont tous différents.

OriginalL'auteur Stephen Collins | 2011-09-26

arrays c++

17
```
Card cards[20];
```
cards est déjà un tableau d'objets. Ils sont construits avec le constructeur par défaut(constructeur sans arguments). Il n'est pas nécessaire de new de nouveau. Probablement vous avez besoin d'un membre de la fonction équivalente à des arguments du constructeur et de l'assigner à travers elle.
```
for ( int i=0; i<20; ++i ) //array index shouldn't include 20
   cards[i].memberFunction(/*....*/);
```
Même plus simple est d'utiliser std::vector
```
std::vector<Card> cards;
for( int i=0; i<20; ++i )
    cards.push_back(Card(i, /*i as char +*/ "_Card.bmp"); )
```
J'ai pensé un vecteur serait une meilleure idée. Alors, j'ai essayé à l'aide d'un vecteur, mais maintenant j'ai quelque chose que j'ai été en cours d'exécution dans une de beaucoup de choses: une Fois que j'ai inclus <vector>, j'obtiens une liste de fou "externes non résolus" erreurs de libcpmtd.lib. Cela me dit il n'y a rien de mal avec MON code, mais je ne compile pas... Pouah.
Je vous souhaite utiliser std::vector et maintenant le numéro de l'élément à ajouter, N'UTILISEZ PAS push_back: La charge est petite, mais évitables. Vous devez les initialiser le vecteur à la bonne taille 'std::vector<Carte - > les cartes(20);" et puis initialiser les membres de la même manière que pour le Tableau.

OriginalL'auteur Mahesh
4

Le code Card cards[20]; déjà crée un tableau de 20 Card objets et crée avec le constructeur par défaut. Cela peut ne pas être ce que vous voulez, compte tenu de votre code.

Je conseille vector à la place.
```
std::vector<Card> cards;

for(int i = 0; i < 20;i++)
{
    cards.push_back(Card(i, /*i as char +*/ "_Card.bmp"));
}
```
Noter que votre for boucle va de 0 à 20 et donc on a passé la fin du tableau.

OriginalL'auteur Mark B
1

Si vous voulez éviter le constructeur appelle et inutile de redimensionnement, puis c'est plus compliqué, parce que le C++ normalement initialise chaque objet un par un, comme il est alloué. Une solution de contournement consiste à faire la Java -- utiliser une boucle et un tableau de pointeurs, comme suit:
```
Card *cards[20];
for (int i=0; i<20; i++) {
  cards[i] = new Card(i);
}
```
Une autre option est d'utiliser malloc pour obtenir explicitement à la mémoire non initialisée:
```
Card *cards = malloc(20 * sizeof(Card));
for (int i=0; i<20; i++) {
  new (&(cards[i])) Card(i);
}
```
OriginalL'auteur

Un nom de tableau, cards dans votre code, contient le adresse du premier élément du tableau. Ces adresses sont attribuées au moment de l'exécution et vous ne pouvez pas les modifier. Donc le compilateur se plaindre cards n'étant pas une l-value.

Mais vous pouvez certainement préciser que ces adresses peuvent tenir à l'aide d'un pointeur comme ci-dessous:

//in my class...
Card cards[20];

Card *cardsPointer = cards;//Pointer contains the address of the
//1st element of 'cards' array.

//in method...
for(int i = 0; i < 20; i++)
*(cardsPointer++) = Card(i, /*i as char +*/ "_Card.bmp");//Note that 
//there is no 'new' operator as 'cardsPointer' has type 'Card *' and 
//not 'Card **'. And 'cardsPointer' has type 'Card *' as the array is
//of type 'Card'.

OriginalL'auteur Vaishak Nair

0

Bien, il y a une autre possibilité, si vous êtes ok avec votre constructeur appelé automatiquement lors de l'initialisation:
```
//in my class...
Card cards[20] = { Card(0, "0_Card.bmp"), Card(1, "1_Card.bmp"), /* ... */ };
```
L'énorme inconvénient est que vous ne pouvez pas utiliser une boucle dans ce cas.

OriginalL'auteur Iziminza

Vous devez vous connecter pour publier un commentaire.