Tableau statique vs tableau dynamic en C ++

Quelle est la différence entre un tableau statique et un tableau dynamic en C ++?

Je dois faire une affectation pour ma classe et il est dit de ne pas utiliser de tableaux statiques, uniquement des tableaux dynamics. J’ai regardé dans le livre et en ligne, mais je ne semble pas comprendre.

Je pensais que la statique a été créée au moment de la compilation et dynamic à l’exécution, mais je peux me tromper avec l’allocation de mémoire.

Pouvez-vous expliquer la différence entre un tableau statique et un tableau dynamic en C ++?

Les tableaux locaux sont créés sur la stack 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 est terminée. Ils ont nécessairement une taille fixe:

int foo[10]; 

Les tableaux créés avec l’ operator new[] ont une durée de stockage dynamic et sont stockés sur le tas (techniquement le “free store”). 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 stack:

 int* foo = new int[10]; delete[] foo; 

static est un mot-clé en C et C ++, donc 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 dynamic.

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 ou supprimée avec le destructeur. Cela signifie que le membre doit être initialisé et maintenu d’une autre manière. Un membre statique peut être des pointeurs initialisés à null puis alloués la première fois qu’un constructeur est appelé. (Oui, ce serait statique et dynamic)

Deux sont hérités de C:

  • au sein d’une fonction, une variable statique est une variable dont l’emplacement mémoire est conservé 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 fonctions (l’utilisation de statics 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 à partir du même module (fichier de code source avec tout autre # include)

La question (je pense) que vous vouliez poser est la différence entre les tableaux dynamics et les tableaux fixes ou à la compilation. C’est une question plus facile, les tableaux à la compilation sont déterminés à l’avance (lorsque le programme est compilé) et font partie d’un cadre de stack de fonctions. Ils sont alloués avant l’exécution de la fonction principale. les tableaux dynamics sont alloués à l’exécution avec le mot clé “new” (ou la famille malloc de C) et leur taille n’est pas connue à l’avance. les allocations dynamics ne sont pas automatiquement nettoyées tant que le programme n’est plus exécuté.

Je pense que la sémantique utilisée dans votre classe est déroutante. Ce que l’on entend probablement par “statique” est simplement “taille constante”, et ce que l’on entend probablement par “dynamic” est “taille variable”. Dans ce cas, un tableau de taille constante pourrait ressembler à ceci:

 int x[10]; 

et un système “dynamic” serait tout type de structure permettant d’augmenter ou de réduire le stockage sous-jacent au moment de l’exécution. La plupart du temps, la classe std::vector de la bibliothèque standard C ++ suffira. Utilisez-le comme ceci:

 std::vector x(10); // this starts with 10 elements, but the vector can be resized. 

std::vector a l’ operator[] défini, vous pouvez donc l’utiliser avec la même sémantique qu’un tableau.

Des tableaux statiques sont alloués à la compilation et la mémoire est allouée sur la stack. Les mémoires dynamics sont allouées à l’exécution et la mémoire est allouée depuis le tas.

 int arr[] = { 1, 3, 4 }; // static integer array. int* arr = new int[3]; // dynamic integer array. 

Il est important d’avoir des définitions claires de ce que signifient les termes. Malheureusement, il semble y avoir plusieurs définitions de ce que signifient les tableaux statiques et dynamics.

Les variables statiques sont des variables définies à l’ aide de l’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 scope globale, 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 en utilisant une allocation de mémoire par stack . Un tableau automatique peut être créé en C / C ++ comme ceci:

 foo() { int w[10]; //automatic array 

Ce que ces tableaux x, y, z et w ont en commun, c’est que la taille de chacun d’eux est fixe et définie au moment de la compilation.

L’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 de données (ou section BSS ) d’un fichier object et que le compilateur peut utiliser des adresses absolues pour accéder aux tableaux ce qui est impossible avec le stockage sur stack.

Ce que l’on entend généralement par un tableau dynamic n’est pas redimensionnable, mais implémenté par l’allocation dynamic de mémoire avec une taille fixe déterminée au moment de l’exécution. En C ++, cela se fait avec 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 en utilisant alloca :

 foo() { int *s = (int*)alloca(n*sizeof(int)) 

Pour un tableau dynamic vrai, il faut utiliser quelque chose comme std::vector en C ++ (ou un tableau de longueur variable en C ).

Qu’est-ce qui était prévu pour l’affectation dans la question du PO? Je pense qu’il est clair que ce qui était souhaité n’était pas un tableau statique ou automatique, mais un tableau qui utilisait l’allocation de mémoire dynamic en utilisant le new opérateur ou un tableau de taille non fixe utilisant par exemple std::vector .

Je pense que dans ce contexte, cela signifie qu’il est statique en ce sens que la taille est fixe. Utilisez std :: vector. Il a une fonction resize ().

Oui, le tableau statique est créé au moment de la compilation où le tableau dynamic est créé au moment de l’exécution. Dans la mesure où la différence concerne leurs emplacements de mémoire, les éléments statiques sont situés sur la stack et la dynamic est créée sur le tas. Tout ce qui se trouve sur heap a besoin de la gestion de la mémoire jusqu’à et à moins que le ramasse-miettes comme dans le cas du framework .net soit présent, sinon il y a un risque de fuite de mémoire.

Tableau statique: Efficacité. Aucune allocation ou désallocation dynamic n’est requirejse.

Les tableaux déclarés dans C, C ++ dans la fonction, y compris le modificateur statique, sont statiques. Exemple: static int foo [5];

Vous pourriez avoir un tableau pseudo-dynamic où la taille est définie par l’utilisateur lors de l’exécution, mais est ensuite corrigée par la suite.

 int size; cin >> size; int dynamicArray[size]; 

arret statique meens donnant sur des éléments dans le tableau

Arrondissement dynamic meens sans donner sur les éléments dans le tableau

Exemple:

  char a[10]; //static array char a[]; //dynamic array