Dois-je déclarer un tableau après en avoir lu la taille?

Question

J'ai récemment découvert que ce genre de déclaration fonctionne avec mon compilateur C++

int h, w; 
cin>>h>>w; 

int a[h + 1][w + 1], f[h + 1][w + 1]; 

Dois-je utiliser ce type de déclaration pour atténuer la complexité de l'espace plutôt que de déclarer le tableau avant d'acquérir la taille réelle, demandée?

Answer 1

Ce sont des extensions non standard prises en charge par certains compilateurs. Ne comptez pas sur eux. Il vaudra mieux utiliser std::vector.

int h, w; 
cin >> h >> w; 

std::vector<std::vector<int>> a{h + 1, std::vector<int>{w + 1}}; 
std::vector<std::vector<int>> f{h + 1, std::vector<int>{w + 1}}; 

Answer 2

Variable-length automatic arrays sont autorisés dans c99 mais pas dans c++. En tant que GCC extension les accepte, mais si vous construisez l'exemple suivant avec -std=c++14 et -pedantic, vous obtiendrez avertissement:

void foo(int n) { 
    int bar[n]; 
} 

Avertissement: ISO C++ interdit le tableau de longueur variable 'bar' [-Wvla]

Je ne recommande pas de l'utiliser, c++ a son propre type de tableau dynamique, appelé std::vector.

L'autre answer montre un bel exemple de construction un std::vector avec h + 1 copies d'éléments ayant une valeur std::vector<int>(w + 1) qui est un autre std::vector avec w + 1default-inserted cas de int.

Answer 3

Le C++ moderne ne permet pas de déterminer la taille d'un tableau dans le temps d'exécution. Comme les autres réponses spécifiées c99 le permet. La meilleure approche consiste à utiliser des vecteurs. Par exemple, essayez de compiler ce code dans Microsoft Visual Studio et voyez ce qui se passe.

#include <iostream> 
using namespace std; 

int main() 
{ 
    int size; 
    cin >> size; 
    int arr[size]; // 8th line 
} 

erreur (s):

source_file.cpp(8): error C2131: expression did not evaluate to a constant 
source_file.cpp(8): note: failure was caused by non-constant arguments or reference to a non-constant symbol 
source_file.cpp(8): note: see usage of 'num' 
Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x64 

Ce que vous devez utiliser est des vecteurs. Quel est le vecteur, il détermine la taille à l'exécution. Vous pouvez mettre plus d'éléments à l'intérieur et la taille sera plus grande. Vous pouvez supprimer plus d'éléments en déplacement, puis la taille sera réduite.

Mais attention, ne mélangez pas la capacité avec la taille. Voici un exemple de code pour vous permettre de voir comment fonctionne la capacité.

#include <iostream> 
#include <vector> 
using namespace std; 

int main() 
{ 
    vector<int> v; 
    cout << "Adding elements!" << endl; 
    for(int i = 0; i < 10; i++) 
    { 
     v.push_back(6); 
     cout << "Capacity: " << v.capacity() << endl; 
    } 

    cout << "Removing elements!" << endl; 
    for(int i = 0; i < 10; i++) 
    { 
     v.pop_back(); 
     cout << "Capacity: " << v.capacity() << endl; 
    } 
} 

Linux Sortie 64 bits:

Adding elements! 
Capacity: 1 
Capacity: 2 
Capacity: 4 
Capacity: 4 
Capacity: 8 
Capacity: 8 
Capacity: 8 
Capacity: 8 
Capacity: 16 
Capacity: 16 
Removing elements! 
Capacity: 16 
Capacity: 16 
Capacity: 16 
Capacity: 16 
Capacity: 16 
Capacity: 16 
Capacity: 16 
Capacity: 16 
Capacity: 16 
Capacity: 16 

Même si je retire les éléments plus tard, la capacité restera à sa dernière valeur. La capacité renvoie la taille de l'espace de stockage actuellement alloué au vecteur, exprimée en termes d'éléments.

La taille renvoie le nombre d'éléments dans le vecteur.

Amusez-vous, et bonne chance!

Modifier: La capacité passe également de OS à OS.

Microsoft sortie 64 bits:

Adding elements! 
Capacity: 1 
Capacity: 2 
Capacity: 3 
Capacity: 4 
Capacity: 6 
Capacity: 6 
Capacity: 9 
Capacity: 9 
Capacity: 9 
Capacity: 13 
Removing elements! 
Capacity: 13 
Capacity: 13 
Capacity: 13 
Capacity: 13 
Capacity: 13 
Capacity: 13 
Capacity: 13 
Capacity: 13 
Capacity: 13 
Capacity: 13