Initialisation de la taille d'un array

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

Code:

---

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 ?

Citation:

---

Envoyé par ypcman

Comment faire ?

---

std::vector

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

Citation:

---

Envoyé par ypcman

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++ :koi: ?

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.

Citation:

---

Envoyé par 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.

---

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

Citation:

---

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

---

Salut,

Citation:

---

Envoyé par foetus

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

---

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

Salut,

Citation:

---

Envoyé par 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.

---

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

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:

---

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é

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

Citation:

---

Envoyé par ypcman

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

---

Je ne vois pas ce que tu ne comprends pas :weird: :koi:

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)

Ton dernier code n'est pas un tableau statique. :weird:

Citation:

---

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.

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.

Citation:

---

Envoyé par Bousk

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 :hola:

Salut,

Citation:

---

Envoyé par 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

---

D'accord, c'est ton choix.

Puis-je simplement te demander pourquoi :question:

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

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 ;)

Citation:

---

Envoyé par 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.

---

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 ;)

Citation:

---

Envoyé par koala01

Salut,

D'accord, c'est ton choix.

Puis-je simplement te demander pourquoi :question:

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

---

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.

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.

Salut,

Citation:

---

Envoyé par koala01

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.

Citation:

---

Envoyé par ypcman

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 :mrgreen:

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 (<- :whistle: std::vector<void*> existe mais son utilité en C++ me semble être très très à la marge)

Citation:

---

Envoyé par kaitlyn

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

---

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

Citation:

---

Envoyé par foetus

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.

---

Si si il y a toujours moyen de bricoler et les compilateurs C++ offrent généralement pas mal de possibilités en tant qu'extensions, y compris les VLA pour certains mais voilà dans ce cas précis ce n'est ni standard, ni portable. Par contre il peut y avoir des choses plus intéressantes dans les options de compilations, même celles implicites, et qu'un compilateur décide dans le cadre d'une optimisation de placer un petit tableau dynamique sur la pile ne serait pas étonnant, autrement dit les avantages du VLA mais sans sacrifier le code.