Créer un tableau de structure à l'aide de nouvelles

J'ai une certaine situation difficile, là, qui, je l'espère, certains corps va m'aider.

J'ai le texte suivant,

struct CandyBar{ 
  std::string name; 
  double weight; 
  int calories; 
} ;

Maintenant, pour la création d'un tableau de structure pour contenir beaucoup de barres chocolatées est beaucoup plus simple que j'ai fait comme;

int main(){
   CandyBar bars[] = {{"Mango tart", 2.3, 100}, {"Yo Yo", 3.2, 130}, {"Orange Ball", 1.7, 98}};
  return 0;
}

Mais, maintenant, je veux créer la même structure à l'aide de nouveau. Il est assez simple, quand je pense à cela, mais se bloque et ne fonctionne pas.

CandyBar *bars = new CandyBar;
  (*bars).name = "Mango tart";
   bars->weight =  2.3;
   bars->calories =  100;
   bars += 1;

  (*bars).name = "Yo Yo";
  bars->weight =  3.2;
  bars->calories =  130;

  bars += 1;
  (*bars).name =  "Orange Ball";
  bars->weight =  1.7;
  bars->calories =  98;

Mais, cela ne fonctionne pas. Comme je pense que le premier pointeur est un emplacement de mémoire pointant vers la première structure puis-je créer la structure, puis d'augmenter l'adresse à l'aide de la barre += 1, et aller sur la création d'un pointeur, mais ai-je raté quelque chose de vraiment grave.

J'apprécierais vraiment votre aide.

Vous n'êtes allocation d'espace pour les 1 CandyBar.
Je n'ai pas beaucoup d'expérience en C++, mais un vector ou sharedptr sonne comme la voie à suivre.
Vous voudrez probablement une std::vector<CandyBar>.
Les réponses ci-dessus. Mais puis-je vous demander pourquoi vous alternez entre (*bars). et bars->? Il semble idiot. Aussi, comment pouvez-vous supprimer le tableau plus tard, lorsque vous avez modifié le pointeur qui contient son adresse?
non, shared_ptr serait d'utiliser delete dans le destructeur sur quelque chose alloué avec new[].

OriginalL'auteur | 2013-01-01

  1. 14

    Dans votre deuxième exemple, vous n'allouant qu'un seul CandyBar de la structure, mais vous traiter comme si c'était un tableau. Qui ne va pas bien finir, et c'est une recette pour un dépassement de la mémoire tampon.

    Afin d'allouer un tableau de CandyBars, vous devez dire à nouveau que vous voulez un tableau, comme ceci:

    CandyBar* bars = new CandyBar[3];

    Assurez-vous que lorsque vous supprimez votre tableau de CandyBars, vous êtes à l'aide de suppression de tableau comme ceci:

    delete[] bars;

    Tout ce que dit, en C++, le code de production, vous devriez normalement utiliser un std::vector ou un std::arrray pour gérer cette situation que vous n'avez pas à traiter avec autant de la gestion des ressources, vous devez dans ce cas particulier.

    Si vous avez d'allouer dynamiquement un tableau sur le tas, et continuer à utiliser RAII, je voudrais aussi regarder boost::shared_array et boost::scoped_array.

    Merci. Vous avez mentionné le delete []. J'ai pensé qu'il est difficile, maintenant je sais comment facile comme bonjour, il est 😉

    OriginalL'auteur Timo Geusch

  2. 6

    Espace est alloué à un CandyBar, de sorte que vous écrivez non alloué de la mémoire du tas. C'est un grand no-no. Vous sont effectivement de la chance que c'est un échec parce qu'elle a la capacité de produire de très difficile de déboguer des problèmes.

    Vous pouvez allouer plus de place pour les CandyBars comme suit:

    CandyBar *bars = new CandyBar[3]; //3 CandyBars.

    ...et n'oubliez pas d'utiliser un tableau deletor comme suit:

    delete[] bars;

    Mais encore, il ya la capacité de dépassement du nombre de CandyBars que vous avez alloué. La préfère de beaucoup la méthode de le faire en C++ est d'utiliser un std::vector.

    Dans cet exemple, je donne CandyBar un constructeur de sténographie et de les placer dans un std::vector.

    #include <string>
#include <vector>

struct CandyBar{ 
  std::string name;
  double weight;
  int calories;
  CandyBar(std::string name, double weight, int calories)
  {
      this->name = name;
      this->weight = weight;
      this->calories = calories;
  }
};

int main()
{
    std::vector<CandyBar> bars;
    bars.push_back(CandyBar("Mango tart", 2.3, 100));
    bars.push_back(CandyBar("Yo Yo", 3.2, 130));
    bars.push_back(CandyBar("Orange Ball", 1.7, 98));

    return 0;
}

    Pas new's, pas de delete's, pas de fuites, pas de corruption.

    Je voudrais également ajouter que si vous utilisez un compilateur C++11 et ne veulent pas l'allocation dynamique qui std::vector vous donne, vous pouvez envisager d'utiliser std::array à la place.

    Wow, c'est génial. Je ne savais pas à propos de vecteurs. Il semble qu'il est beaucoup plus facile avec les vecteurs.
    Assez bonne idée...

    OriginalL'auteur Sean Cline

  3. 1

    Foo * a = new Foo alloue de l'espace pour exactement une instance de Foo. Si vous voulez allouer un tableau de Foo, vous devez utiliser Foo * a = new Foo[ARRAY_LEN].

    Fondamentalement, ce que vous voulez vraiment, c'est d'allouer dynamiquement de la mémoire pour contenir un tableau d'objets, dans votre cas CandyBar objets. Le problème est, vous êtes à l'aide de la new de l'opérateur, qui n'alloue de la mémoire pour l'un de ces objets. Vous êtes alors en essayant d'utiliser le retour de l'adresse de la mémoire comme si elle pointe vers un tableau. Vous aurez inévitablement essayez d'accéder à la mémoire, vous n'avez pas alloué, ce qui va conduire à une segmentation des défauts (au mieux).

    L'opérateur vous êtes à la recherche de la new[] opérateur (invoquée comme new CandyBar[ARRAY_LEN]), qui alloue suffisamment de mémoire pour un tableau du nombre spécifié d'objets. Vous pouvez ensuite prendre le retour de l'adresse de mémoire et de le traiter exactement comme un tableau de la taille que vous fournissez sans peur d'oubli de votre allocation de la mémoire.

    En général, si vous faites affaire avec une collection de CandyBars qui pourraient augmenter ou diminuer tout au long de la durée de vie de votre programme, l'allocation d'un tableau de taille fixe n'est pas la voie à suivre. Jetez un oeil à la std::vector modèle de classe en C++ STL - un std::vector<CandyBar> peut augmenter ou diminuer de façon dynamique en fonction du nombre de CandyBars que vous souhaitez stocker, et peuvent être librement utilisés, comme si c'était un tableau (par exemple, comme foo[42]).

    Vous avez mentionné quelque chose sur [nouveau]. Puis-je aussi utiliser de nouvelles[] à la place de la nouvelle CandyBar[20].
    Même si nous l'appelons le new[] opérateur, nous invoquons l'opérateur à l'aide du formulaire new CandyBar[20]; c'est juste la façon dont la syntaxe fonctionne.

    OriginalL'auteur atomicinf

  4. 0

    Vous devez allouer un tableau de CandyBar avec :

    CandyBar *bars = new CandyBar[20];

    Puis vous utilisez bars[0], bars[1] ... bars[19], etc, pour accéder à la personne barres chocolatées.

    Noter que votre code bars + 1 ajoute un sizeof CandyBar pour le pointeur, mais cela souligne une non alloué région (parce que vous avez juste alloué un seul CandyBar). Ainsi, votre code se bloque.

    Non, vous ne devriez pas. Il n'est jamais vraiment tout les cas, vous devez utiliser la matrice de new.
    Bien sûr, il ya STL solutions qui sont mieux et il est bon que d'autres réponses, des conseils. Je veux seulement montrer comment utiliser new pour les tableaux.
    Mais il y a aucun cas où vous n'auriez jamais utiliser new pour un tableau. Jamais.
    Génial, merci pour le soutien.

    OriginalL'auteur Ben Ruijl