Tableau statique vs tableau dynamique en C++
Quelle est la différence entre un tableau statique et un tableau dynamique en C++?
Je dois faire un devoir pour ma classe et il est dit de ne pas utiliser de tableaux statiques, mais uniquement des tableaux dynamiques. J'ai regardé dans le livre et en ligne, mais je ne semble pas comprendre.
Je pensais que statique était créé à la compilation et dynamique à l'exécution, mais je peux peut-être confondre cela avec l'allocation de mémoire.
Pouvez-vous expliquer la différence entre un tableau statique et un tableau dynamique en C++?
Les tableaux locaux sont créés sur la pile et ont une durée de stockage automatique. Vous n'avez pas besoin de gérer manuellement la mémoire, mais ils sont détruits lorsque la fonction dans laquelle ils se terminent. Ils ont nécessairement une taille fixe:
int foo[10];
Les tableaux créés avec operator new[] ont une durée de stockage dynamique et sont stockés sur le tas (techniquement, le "magasin libre"). Ils peuvent avoir n'importe quelle taille, mais vous devez les allouer et les libérer vous-même car ils ne font pas partie du cadre de la pile:
int* foo = new int[10];
delete[] foo;
static est un mot clé en C et C++. Par conséquent, plutôt qu'un terme descriptif général, static a une signification très spécifique lorsqu'il est appliqué à une variable ou à un tableau. Pour aggraver la confusion, il a trois significations distinctes dans des contextes distincts. De ce fait, un tableau statique peut être fixe ou dynamique.
Laisse-moi expliquer:
Le premier est spécifique à C++:
- Un membre de classe statique est une valeur qui n'est pas instanciée avec le constructeur ni supprimée avec le destructeur. Cela signifie que le membre doit être initialisé et maintenu d'une autre manière. Les membres statiques peuvent être des pointeurs initialisés à null, puis alloués lors du premier appel d'un constructeur. (Oui, ce serait statique et dynamique)
Deux sont hérités de C:
dans une fonction, une variable statique est une variable dont l'emplacement mémoire est préservé entre les appels de fonction. Il est statique en ce sens qu’il n’est initialisé qu’une seule fois et conserve sa valeur entre les appels de fonction (l’utilisation de la statique rend une fonction non réentrante, c’est-à-dire non threadsafe)
les variables statiques déclarées en dehors des fonctions sont des variables globales accessibles uniquement depuis le même module (fichier de code source avec tout autre # include).
La question (je pense) que vous vouliez poser est quelle est la différence entre des tableaux dynamiques et des tableaux fixes ou à compilation. C'est une question plus facile, les tableaux au moment de la compilation sont déterminés à l'avance (lorsque le programme est compilé) et font partie d'un cadre de pile de fonctions. Ils sont alloués avant l'exécution de la fonction principale. Les tableaux dynamiques sont alloués au moment de l'exécution avec le mot-clé "nouveau" (ou la famille malloc de C) et leur taille n'est pas connue à l'avance. les allocations dynamiques ne sont pas automatiquement nettoyées jusqu'à ce que le programme cesse de fonctionner.
Je pense que la sémantique utilisée dans votre classe est source de confusion. Ce que l'on entend probablement par "statique" est simplement "taille constante", et par "dynamique", on entend "taille variable". Dans ce cas, un tableau de taille constante pourrait ressembler à ceci:
int x[10];
et une structure "dynamique" serait simplement n'importe quel type de structure permettant d'augmenter ou de diminuer le stockage sous-jacent au moment de l'exécution. La plupart du temps, la classe std::vector de la bibliothèque standard C++ suffit. Utilisez-le comme ceci:
std::vector<int> x(10); // this starts with 10 elements, but the vector can be resized.
std::vector a operator[] défini, vous pouvez donc l'utiliser avec la même sémantique qu'un tableau.
Il est important de définir clairement les termes. Malheureusement, il semble y avoir plusieurs définitions de ce que signifient les tableaux statiques et dynamiques.
Les variables statiques sont des variables définies à l'aide de allocation de mémoire statique . C'est un concept général indépendant de C/C++. En C/C++, nous pouvons créer des variables statiques avec une portée globale, de fichier ou locale comme ceci:
int x[10]; //static array with global scope
static int y[10]; //static array with file scope
foo() {
static int z[10]; //static array with local scope
Les variables automatiques sont généralement implémentées à l'aide de allocation de mémoire basée sur pile . Un tableau automatique peut être créé en C/C++ comme ceci:
foo() {
int w[10]; //automatic array
Le point commun entre ces tableaux, x, y, z et w, est que la taille de chacun d'eux est fixe et définie lors de la compilation.
Une des raisons pour lesquelles il est important de comprendre la distinction entre un tableau automatique et un tableau statique est que le stockage statique est généralement implémenté dans la section data (ou /section BSS ) d'un fichier objet et le compilateur. pouvez utiliser absolute address pour accéder aux tableaux, ce qui est impossible avec un stockage basé sur une pile.
Ce que l'on entend habituellement par tableau dynamique n'est pas redimensionnable, mais implémenté à l'aide de allocation de mémoire dynamique avec une taille fixe déterminée au moment de l'exécution. En C++, cela se fait à l'aide de l'opérateur new .
foo() {
int *d = new int[n]; //dynamically allocated array with size n
Mais il est possible de créer un tableau automatique avec une taille de correctif définie à l'exécution à l'aide de alloca:
foo() {
int *s = (int*)alloca(n*sizeof(int))
Pour un vrai tableau dynamique, on devrait utiliser quelque chose comme std::vector en C++ (ou un tableau de longueur variable en C ).
Qu'est-ce qui était destiné à la mission dans la question du PO? Je pense qu'il est clair que ce qui était recherché n'était pas un tableau statique ou automatique, mais un système utilisant soit une allocation de mémoire dynamique utilisant l'opérateur new, soit un tableau de taille non fixe utilisant, par exemple. std::vector.
Les matrices statiques se voient allouer de la mémoire au moment de la compilation et sont allouées à la pile. En revanche, la mémoire des tableaux dynamiques est allouée au moment de l'exécution et la mémoire est allouée à partir du tas.
int arr[] = { 1, 3, 4 }; // static integer array.
int* arr = new int[3]; // dynamic integer array.
Je pense que dans ce contexte, cela signifie qu'il est statique dans le sens où la taille est fixe . Utilisez std :: vector. Il a une fonction resize ().
Vous pouvez avoir un tableau pseudo dynamique dont la taille est définie par l'utilisateur au moment de l'exécution, mais est ensuite corrigée.
int size;
cin >> size;
int dynamicArray[size];
Oui, le tableau statique est créé à la compilation, alors que le tableau dynamique est créé au moment de l’exécution. Où la différence concerne les emplacements de mémoire, les statiques sont situés sur la pile et la dynamique sont créés sur le tas. Tout ce qui se trouve sur le tas nécessite la gestion de la mémoire jusqu'à ce qu'il y ait un ramasse-miettes comme dans le cas du framework .net, sinon il y a un risque de fuite de mémoire.
Tableau statique: efficacité. Aucune allocation dynamique ou désallocation n'est requise.
Les tableaux déclarés en C, C++ dans une fonction incluant un modificateur statique sont statiques. Exemple: static int foo [5];