Discussion :

[ypcman]

Bonjour.
Je souhaite pouvoir choisir la taille d'un array d'entiers en fonction du choix de l'utilisateur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#include <iostream>
#include <array>
 
int main() {
	int taille;
	std::cout << "taille ?";
	std::cin >> taille;
	std::array<int, taille> mon_tableau;
	return 0;
}

ne fonctionne pas car "taille" n'est pas une constante. Comment faire ?

[foetus]

Comment faire ?

std::vector

[ypcman]

Certes, mais je veux rester sur des tableaux statiques et donc ne pas employer vector.
Il s'agit juste de pouvoir choisir la taille à l'initialisation et non en dur dans le code

[foetus]

Certes, mais je veux rester sur des tableaux statiques et donc ne pas employer vector.

Les tableaux statiques ont toujours 1 taille codée en dur (à la compilation)
1 technique est de surdimensionner son tableau pour éviter l'allocation dynamique.

Le C a les VLA, variable-length array (<- lien wikipedia en anglais) ... qui sont dépréciés depuis le C11.
Quid du C++ ?

[ypcman]

Bien pris. Donc même avec std::array, on en reste à la bonne vieille méthode d'une allocation maxSize constante et de l'emploi d'une partie de ce gros tableau en fonction du besoin.

[foetus]

Bien pris. Donc même avec std::array, on en reste à la bonne vieille méthode d'une allocation maxSize constante et de l'emploi d'une partie de ce gros tableau en fonction du besoin.

std::array est juste 1 classe qui englobe 1 tableau statique

1. sa documentation en anglais
2. 1 implémentation, celle de libstdc++

Et c'est son but il me semble : avoir des tableaux statiques en C++ via 1 classe container

Internally, an array does not keep any data other than the elements it contains (not even its size, which is a template parameter, fixed on compile time). It is as efficient in terms of storage size as an ordinary array declared with the language's bracket syntax ([]). This class merely adds a layer of member and global functions to it, so that arrays can be used as standard containers.

Unlike the other standard containers, arrays have a fixed size and do not manage the allocation of its elements through an allocator: they are an aggregate type encapsulating a fixed-size array of elements. Therefore, they cannot be expanded or contracted dynamically (see vector for a similar container that can be expanded).

[kaitlyn]

Salut,

Le C a les VLA, variable-length array (<- lien wikipedia en anglais) ... qui sont dépréciés depuis le C11.
Quid du C++ ?

La réponse est simple, ça n'existe pas.

[kaitlyn]

Salut,

Bien pris. Donc même avec std::array, on en reste à la bonne vieille méthode d'une allocation maxSize constante et de l'emploi d'une partie de ce gros tableau en fonction du besoin.

Pourquoi pas std::vector<>::reserve ?

[ypcman]

Kaitlyn, c'est juste pour ma compréhension personnelle de ce qui est faisable ou non avec les tableaux statiques.

Pourtant, si on n'utilise pas std::array on peut définir dynamiquement la taille d'un tableau ie créer un tableau d'une taille choisie après la compilation. Ce code fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include <array>
 
int main() {
	int *Tab, taille;
	std::cout << "taille ?";
	std::cin >> taille;
	Tab = (int *)malloc(sizeof(int) * taille);
 
	return 0;
}

j'ai l'impression qu'avec std::array, on perd cette possibiiité

[dalfab]

Non cette possibilité existe, elle s'appelle std::vector<> comme déjà dit.

[foetus]

j'ai l'impression qu'avec std::array, on perd cette possibiiité

Je ne vois pas ce que tu ne comprends pas

1 tableau statique a 1 taille fixe parce qu'il est alloué sur la pile ("stack" en anglais) - comme les variables locales ou les paramètres d'1 fonction/ procédure/ méthode.
C'est pour cela que 1) tu ne peux pas modifier sa taille 2) tu peux faire planter ton programme à l'exécution avec 1 "stack overflow" (<- lien wikipedia en français)

1 allocation dynamique (malloc en C, new/ new[] en C++) alloue sur le tas ("heap" en anglais)

[Bousk]

Ton dernier code n'est pas un tableau statique.

définir dynamiquement la taille d'un tableau

Tu comprends ce que tu écris ?
statique = défini et fixé à la compialtion = std::array<Type, Taille> values ou Type values[Taille].
dynamique = à l'exécution = std::vector ou alloué avec malloc.

[kaitlyn]

std::array n'est pas indispensable. D'ailleurs il n'existait pas avant C++11. C'est un peu une version restreinte de std::vector.

[ypcman]

Tu comprends ce que tu écris ?
statique = défini et fixé à la compilation = std::array<Type, Taille> values ou Type values[Taille].
dynamique = à l'exécution = std::vector ou alloué avec malloc.

Je comprends surtout que je faisais manifestement la salade entre les concepts sans avoir bien compris le lien statique/compilation et dynamique/éxécution.
c'est plus clair maintenant ,merci

[koala01]

Salut,

Certes, mais je veux rester sur des tableaux statiques et donc ne pas employer vector.
Il s'agit juste de pouvoir choisir la taille à l'initialisation et non en dur dans le code

D'accord, c'est ton choix.

Puis-je simplement te demander pourquoi

Quel raisonnement as tu suivi pour en arriver à te dire que tu ne voulais pas utiliser std::vector

D'autant plus que là, tu te heurtes à deux volontés totalement opposées:

• d'un coté, tu ne veux pas avoir la possibilité de définir la taille de ton tableau à l'exécution (car, soyons clair, c'est ce que le choix de ne pas utiliser std::vector t'impose)
• et, de l'autre coté, tu ne veux pas définir la taille de ton tableau "en dur" à la compilation

Seulement, voilà... Y a pas vraiment d'autre choix, car la compilation et l'exécution sont les deux seules grosses périodes pendant lesquelles tu pourra agir sur le résultat généré par le compilateur à partir de ton code, la compilation permettant de modifier le résultat obtenu, l'exécution permettant d'envoyer des instructions au processeurs pour qu'elles soient exécutées.

En conclusion, ben, il y a un moment où il faut peut-être décider "d'homogénéiser" ses décisions

NOTA: De plus, std::vector fournit énormément de possibilités (comme la fonction reserve, qui ... réserve directement un espace donné, comme la possibilité de définir un allocateur personnalisé, ou le simple fait que la mémoire allouée est systématiquement doublé lorsque le nombre d'éléments atteint la capacité maxiale, de manière à retarder le moment où il deviendra nécessaire d'allouer encore plus de mémoire) qui en font sans doute "le meilleur choix" à partir du moment où la taille ne pourra être indiquée qu'à l'exécution

[koala01]

std::array n'est pas indispensable. D'ailleurs il n'existait pas avant C++11. C'est un peu une version restreinte de std::vector.

Non, en fait, c'est plus une version améliorée de type valeur[MAX_ELEMENTS], dans le sens où elle présente des fonctions membres destinées à en sécuriser l'usage

[ypcman]

Salut,

D'accord, c'est ton choix.

Puis-je simplement te demander pourquoi

Quel raisonnement as tu suivi pour en arriver à te dire que tu ne voulais pas utiliser std::vector

Ce n'est pas du tout que je ne voulais pas utiliser std::vector ,mais plutôt que je pensais, à tort, que std::array surcouchait l'ensemble du périmètre d'emploi des tableaux et que donc, j'aurais pu déclarer un std::array<type, nosize> et ensuite, avec une méthode surcouchant malloc(), allouer de la place pour ce tableau. J'ai bien compris maintenant que cette librairie std::array est exclusivement dédiée aux tableaux à allocation de mémoire statique et que std::vector est dévolue à l'allocation dynamique.

[Médinoc]

Lors de la conception du C++14, un template std::dynarray<> (qui avait une taille fixe une fois créé, mais cette taille pouvait être choisie à l'exécution) avait été envisagé, mais apparemment cette idée a été abandonnée.

[kaitlyn]

Salut,

Non, en fait, c'est plus une version améliorée de type valeur[MAX_ELEMENTS], dans le sens où elle présente des fonctions membres destinées à en sécuriser l'usage

Ce n'est pas contradictoire ! Et il faut bien justifier l'introduction de std::array par un petit plus quelque part. Mais n'hésite pas à développer ce rapport sécurité / fonctions membres pour qu'on sache exactement à quoi tu fais allusion.

[foetus]

J'ai bien compris maintenant que cette librairie std::array est exclusivement dédiée aux tableaux à allocation de mémoire statique et que std::vector est dévolue à l'allocation dynamique.

Bof tu te trompes

La liste des containers standards, lien cplusplus en anglais
Tous les containers peuvent modifier leur structure à l'exécution (dynamique) sauf le std::array qui englobe 1 tableau statique dans 1 classe container (depuis le C++11)

Pour faire simple, je pense que l'idée est de cacher "la partie langage C" sous 1 couche C++. Mais en le rendant container, il a accès aux manipulations STL: itérateurs, échange, ...
Et puisque tu sembles ne rien connaître aux containers, 1 std::vector te garantie 1 espace contigu pour des données de même type (<- std::vector<void*> existe mais son utilité en C++ me semble être très très à la marge)

La réponse est simple, ça n'existe pas.

Effectivement, je m'interrogeais sur le fait si on pouvait appeler des spécificités du compilateur C en C++. Et on ne peut pas le faire.
Et en cherchant, je suis tombé sur ce que dit @Médinoc, la proposition N3810 de 2013 de Bjarne Stroustrup