de longueur variable std::array comme

Comme à mon habitude utilisé compilateurs C++ permettent de longueur variable des tableaux (par exemple. les tableaux en fonction de l'exécution de la taille), je me demande si il y a quelque chose comme std::array avec la variable de la taille? Bien sûr std::vectorest de taille variable, mais il alloue sur le tas, et les redistribue sur le besoin.

Je tiens à avoir une pile allouée tableau avec la taille définie au moment de l'exécution. Est-il std-modèle qui peut cette fonctionnalité? Peut-être l'aide d' std::vector fixe la taille maximale?

Lors de l'utilisation de std::array, la taille de la matrice est un paramètre du modèle, de sorte qu'il ne peut pas être une variable d'exécution. Je suppose que std::vector est votre meilleur pari.
Car il n'y a pas de "pile" dans la langue standard, il est difficile de faire de cette question précise, ou de faire sens.
Meh. Il serait assez bizarre verrue sur le système de type pour faire une telle notion précise. Vous pouvez voir les efforts-vous dans l'historique de la révision sur Github. Jusqu'à présent, l'idée est que "il n'y a pas assez d'expérience" avec ce, donc c'est reporté.
La réponse habituelle est d'utiliser std::vector avec un allocateur personnalisé. Puisque vous pensez que les données pour être situé "sur la pile", sans doute qu'ils vont toujours être libéré dans l'ordre inverse ils sont affectés. Il devrait être assez facile à écrire un extrêmement rapide thread local de l'allocateur compte tenu de cette restriction. L'inconvénient est que vous allez faire une attribution distincte à l'avant pour stocker les données, mais ce n'est pas si différent de ce que l'OS fait pour votre pile du thread sur un système d'exploitation moderne de votre bloc est virtuel-seulement jusqu'à l'utilisation, tout comme la pile. Mais il ne bénéficiez pas de la pile en cours à chaud dans le cache.
Que voulez-vous dire, il n'y a pas de "pile"? Stockage automatique se comporte comme une pile, et la langue spec parfois se réfère à elle comme une pile (par exemple, "le déroulement de pile" lorsqu'une exception est levée), alors pourquoi ne pas appeler cela une pile?

OriginalL'auteur dronus | 2013-12-31

  1. 13

    Il y a deux propositions actuellement en cours d'élaboration à ramener à exécution les matrices de taille fixe pour C++ qui peuvent être d'intérêt pour vous:

    • À l'exécution, la taille des tableaux avec automatique de la durée de stockage. Ceci rendrait l'exécution de la taille des tableaux d'une fonctionnalité du langage (comme dans C11). De sorte que vous pouvez faire:

      void foo(std::size_t size) {
  int arr[size];
}

    • C++ Tableaux Dynamiques. Ce serait mettre un nouveau conteneur à la bibliothèque, std::dynarray, qui est de donner une taille fixe à la construction. Il est destiné à être optimisé pour être alloué sur la pile dès que possible.

      void foo(std::size_t size) {
  std::dynarray<int> arr(size);
}

    Ces sont tous les deux travaillé dans le cadre d'un Tableau des Extensions de Spécification Technique, qui sera publié aux côtés de C++14.

    Si le second a l'air vraiment bon. Existe-il des implémentations d'aujourd'hui?
    peut-être cela devrait être fusionné dans le ici ?

    OriginalL'auteur Joseph Mansfield

  2. 5

    Comme Daniel indiqué dans le commentaire, la taille de la std::array est spécifié comme un paramètre du modèle, de sorte qu'il ne peut pas être défini au cours de l'exécution.

    Vous pourrez construire std::vector en passant le minimum de capacités par le biais du paramètre du constructeur:

    #include <vector>

int main(int argc, char * argv[])
{
    std::vector<int> a;
    a.reserve(5);
    std::cout << a.capacity() << "\n";
    std::cout << a.size();

    getchar();
}

    . Encore du vecteur contenu sera stocké sur le tas, pas sur la pile. Le problème, c'est que le compilateur a savoir, comment beaucoup d'espace devraient être allouées à la fonction avant son exécution, il n'est tout simplement pas possible de stocker des données de longueur variable sur la pile.

    Ce que vous faites n'est pas vraiment mis en le minimum de capacités par le biais du paramètre dans le constructeur. Ce que ce fait est d'une taille et depuis size<=capacity cela fonctionne. Pour définir l'utilisation de la capacité reserve.
    Vous avez raison. Effectivement le but serait atteint, mais la solution de la réserve est beaucoup plus élégant.
    C'est en tas, ce qui est la raison pour laquelle je ne veux pas de ça, et demandé à ma question... Cependant, si le std::vector pourrait être mis en place pour allouer c'est inital de la capacité sur la pile, et de passer en tas sur le premier réaffectation. Cela ne fonctionnera pas par reserve, comme il doit être fait sur la première affectation... mais ce serait cool. Cependant je doute que cela fonctionne de cette façon dans la mise en oeuvre habituelle.

    OriginalL'auteur Spook