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, seulement des tableaux dynamiques. J'ai regardé dans le livre et en ligne, mais je ne semble pas comprendre.

Je pensais que la statique avait été créée au moment de la compilation et dynamique au moment de l'exécution, mais je me trompe peut-être avec l'allocation de mémoire.

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

Les baies locales sont créées sur la pile et ont une durée de stockage automatique - vous n'avez pas besoin de gérer manuellement la mémoire, mais elles sont détruites lorsque la fonction dans laquelle elles se trouvent se termine. Ils ont forcément 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 gratuit»). 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 ++, 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. Pour cette raison, un tableau statique peut être fixe ou dynamique.

Laissez-moi expliquer:

Le premier est spécifique au 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. Les membres statiques peuvent être des pointeurs initialisés à null, puis alloués la première fois qu'un constructeur est appelé. (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 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 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 qui ne sont accessibles qu'à partir du même module (fichier de code source avec tout autre # include)

La question (je pense) que vous vouliez poser est de savoir quelle est la différence entre les tableaux dynamiques et les tableaux fixes ou à la compilation. C'est une question plus simple, 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 à 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 dynamiques ne sont pas automatiquement nettoyées jusqu'à ce que le programme cesse de s'exécuter.

Je pense que la sémantique utilisée dans votre classe prête à confusion. Ce que l'on entend probablement par «statique» est simplement «taille constante», et ce que l'on entend probablement par «dynamique» est «taille variable». Dans ce cas, un tableau de taille constante pourrait ressembler à ceci:

int x[10];

et un "dynamique" serait simplement n'importe quel type de structure qui permet d'augmenter ou de diminuer le stockage sous-jacent au moment de l'exécution. La plupart du temps, la std::vectorclasse 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::vectora operator[]défini, vous pouvez donc l'utiliser avec la même sémantique qu'un tableau.

Les tableaux statiques reçoivent de la mémoire au moment de la compilation et la mémoire est allouée sur la pile. Alors que les tableaux dynamiques se voient allouer de la mémoire au moment de l'exécution et que 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.

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 dynamiques.

Les variables statiques sont des variables définies à l' aide de l'allocation de mémoire statique . Il s'agit d'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, 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 d' une allocation de mémoire basée sur la pile . Un tableau automatique peut être créé en C / C ++ comme ceci:

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

Ce que ces tableaux, x, y, zet wont 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 objet et le compilateur peut utiliser des adresses absolues pour accéder aux tableaux. ce qui est impossible avec le stockage basé sur la pile.

Ce que l'on entend généralement par tableau dynamique n'est pas un tableau redimensionnable, mais implémenté à l'aide d' une 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' newopérateur .

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 correctifs définie au moment de l'exécution en utilisant alloca:

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

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

Que signifiait 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 tableau qui utilisait l'allocation de mémoire dynamique à l'aide de l' newopé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 dans le sens où la taille est fixe. Utilisez std :: vector. Il a une fonction resize ().

Vous pouvez avoir un pseudo tableau dynamique dont 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];

Tableau statique :

1. Les tableaux statiques reçoivent de la mémoire au moment de la compilation.
2. La taille est fixe.
3. Situé dans l'espace mémoire de la pile.
4. Par exemple. : tableau int [10]; // tableau de taille 10

Tableau dynamique:

1. La mémoire est allouée au moment de l'exécution.
2. La taille n'est pas fixe.
3. Situé dans l'espace mémoire du tas.
4. Par exemple. : int * array = new int [10];

Oui, le tableau statique est créé au moment de la compilation, alors que le tableau dynamique est créé au moment de l'exécution. Là où la différence concerne leurs emplacements de mémoire, les statiques sont situées sur la pile et les dynamiques sont créées sur le tas. Tout ce qui se trouve sur le tas a besoin de la gestion de la mémoire jusqu'à ce que et à moins qu'un garbage collector 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 dynamique ou désallocation n'est requise.

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

arrary statique meens avec donner des éléments à côté du tableau

arrary dynamique meens sans donner sur les éléments à côté du tableau

exemple:

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