Tableaux vs vecteurs: similitudes et différences introductives [fermé]

Quelles sont les différences entre un tableau et un vecteur en C ++? Un exemple des différences pourrait être inclus les bibliothèques, le symbolisme, les capacités, etc.

Tableau

Les tableaux contiennent un nombre spécifique d'éléments d'un type particulier. Pour que le compilateur puisse réserver la quantité d'espace requise lorsque le programme est compilé, vous devez spécifier le type et le nombre d'éléments que le tableau contiendra lors de sa définition. Le compilateur doit être en mesure de déterminer cette valeur lorsque le programme est compilé. Une fois qu'un tableau a été défini, vous utilisez l'identificateur du tableau avec un index pour accéder à des éléments spécifiques du tableau. [...] les tableaux sont indexés à zéro; autrement dit, le premier élément est à l'index 0. Ce schéma d'indexation est indicatif de la relation étroite en C ++ entre les pointeurs et les tableaux et les règles que le langage définit pour l'arithmétique des pointeurs.

- Référence de poche C ++

Vecteur

Un vecteur est une séquence d'objets de taille dynamique qui fournit operator[]un accès aléatoire de style tableau . La fonction membre push_backcopie ses arguments via le constructeur de copie, ajoute cette copie comme dernier élément du vecteur et incrémente sa taille de un.pop_backfait exactement le contraire, en supprimant le dernier élément. L'insertion ou la suppression d'éléments à partir de la fin d'un vecteur prend un temps constant amorti, et l'insertion ou la suppression de tout autre emplacement prend un temps linéaire. Ce sont les bases des vecteurs. Il y a beaucoup plus à eux. Dans la plupart des cas, un vecteur devrait être votre premier choix sur un tableau de style C. Tout d'abord, ils sont dimensionnés de manière dynamique, ce qui signifie qu'ils peuvent grandir selon les besoins. Vous n'avez pas à faire toutes sortes de recherches pour trouver une taille statique optimale, comme dans le cas des tableaux C; un vecteur s'agrandit selon les besoins et il peut être redimensionné plus ou moins manuellement si vous en avez besoin. Deuxièmement, les vecteurs offrent une vérification des limites avec la atfonction membre (mais pas avecoperator[]), de sorte que vous puissiez faire quelque chose si vous référencez un index inexistant au lieu de simplement regarder votre programme planter ou pire, continuer l'exécution avec des données corrompues.

- Livre de recettes C ++

tableaux:

• sont une construction de langage intégrée;
• viennent presque sans modification de C89;
• fournir juste une séquence contiguë et indexable d'éléments ; pas de cloches et de sifflets;
• sont de taille fixe; vous ne pouvez pas redimensionner un tableau en C ++ (sauf s'il s'agit d'un tableau de POD et qu'il est alloué avecmalloc );
• leur taille doit être une constante de compilation à moins qu'elles ne soient allouées dynamiquement;
• ils prennent leur espace de stockage en fonction de la portée où vous les déclarez;
• s'ils sont alloués dynamiquement, vous devez les désallouer explicitement;
• s'ils sont alloués dynamiquement, vous obtenez juste un pointeur et vous ne pouvez pas déterminer leur taille; sinon, vous pouvez utiliser sizeof(d'où l'idiome communsizeof(arr)/sizeof(*arr) , qui échoue cependant silencieusement lorsqu'il est utilisé par inadvertance sur un pointeur);
• se désintègre automatiquement en pointeurs dans la plupart des situations; en particulier, cela se produit lors de leur passage à une fonction, ce qui nécessite généralement de passer un paramètre séparé pour leur taille;
• ne peut pas être retourné à partir d'une fonction;
• ne peut pas être copié / attribué directement;
• les tableaux dynamiques d'objets nécessitent un constructeur par défaut, puisque tous leurs éléments doivent être construits en premier;

std::vector:

• est une classe de modèle;
• est une construction C ++ uniquement;
• est implémenté comme un tableau dynamique ;
• grandit et rétrécit dynamiquement;
• gérer automatiquement leur mémoire, qui est libérée lors de la destruction;
• peut être passé / retourné à des fonctions (par valeur);
• peut être copié / attribué (ceci effectue une copie complète de tous les éléments stockés);
• ne se désintègre pas en pointeurs, mais vous pouvez explicitement obtenir un pointeur vers leurs données (il &vec[0]est garanti qu'il fonctionne comme prévu);
• apporte toujours avec le tableau dynamique interne sa taille (combien d'éléments sont actuellement stockés) et sa capacité (combien d'éléments peuvent être stockés dans le bloc actuellement alloué);
• le tableau dynamique interne n'est pas alloué à l'intérieur de l'objet lui-même (qui ne contient que quelques champs de "comptabilité"), mais est alloué dynamiquement par l'allocateur spécifié dans le paramètre de modèle approprié; celui par défaut obtient la mémoire du freestore (le soi-disant tas), indépendamment de la façon dont l'objet réel est alloué;
• pour cette raison, ils peuvent être moins efficaces que les tableaux «réguliers» pour les petits tableaux locaux de courte durée;
• lors de la réallocation, les objets sont copiés (déplacés, en C ++ 11);
• ne nécessite pas de constructeur par défaut pour les objets stockés;
• est mieux intégré avec le reste du soi-disant STL (il fournit les méthodes begin()/ end(), les STL habituelles typedef, ...)

Considérez également «l'alternative moderne» aux tableaux - std::array; J'ai déjà décrit dans une autre réponse la différence entre std::vectoret std::array, vous voudrez peut-être y jeter un coup d'œil.

J'ajouterai que les tableaux sont des constructions de très bas niveau en C ++ et que vous devriez essayer de vous en éloigner autant que possible lorsque vous "apprenez les cordes" - même Bjarne Stroustrup le recommande (il est le concepteur de C ++).

Les vecteurs sont très proches des mêmes performances que les baies, mais avec de nombreuses commodités et fonctionnalités de sécurité. Vous commencerez probablement à utiliser des tableaux lors de l'interfaçage avec des API qui traitent des tableaux bruts, ou lors de la création de vos propres collections.

Ces références répondent à peu près à votre question. En termes simples, les longueurs des vecteurs sont dynamiques tandis que les tableaux ont une taille fixe. lors de l'utilisation d'un tableau, vous spécifiez sa taille lors de la déclaration:

int myArray[100];
myArray[0]=1;
myArray[1]=2;
myArray[2]=3;

pour les vecteurs, il suffit de le déclarer et d'ajouter des éléments

vector<int> myVector;
myVector.push_back(1);
myVector.push_back(2);
myVector.push_back(3);
...

Parfois, vous ne saurez pas le nombre d'éléments nécessaires, un vecteur serait donc idéal pour une telle situation.