Discussion :

[victor_gasgas]

Bonjour à tous!

Quelqu'un sait-il s'il existe une proposition pour std::make_array pour le futur standard c++? En effet il existe déjà make_tuple par exemple qui permet de déduire automatiquement le nombre d'argument, ce qui se révèle particulièrement intéressant!

Le site http://www.meetingcpp.com/index.php/start.html qui recense pas mal de paper ne mentionne rien à ce sujet là!

Merci beaucoup à tous!

[Kalith]

Bonjour,

On peut déjà faire ça :

Code :

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

1
2
std::array<float, 5> a1 = {{0.1, 0.2, 0.3, 0.4, 0.5}}; // possible en C++11
std::array<float, 5> a2 = {0.1, 0.2, 0.3, 0.4, 0.5}; // suggéré pour la prochaine norme

Tu voudrais pouvoir écrire quelque chose comme ça ?

Code :

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

1
2
3
auto a1 = std::make_array({0.1, 0.2, 0.3, 0.4, 0.5});
// ... ou: 
auto a2 = std::make_array(0.1, 0.2, 0.3, 0.4, 0.5);

[victor_gasgas]

Exactement! Je souhaiterais faire cela en fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
auto my_array = std::make_array(
    1,
    2,
 
#if defined (MY_DEFINE)
    3,
#endif
 
    4);
 
    for(auto const i& : my_array)
        // some code ...

Sachant que le code qui suit la déclaration et l'initialisation de my_array ne dépend en aucun cas du nombre d'éléments! Il reste donc valide!

[Bousk]

Salut,

Cette syntaxe ne fonctionnerait pas ?

Code :

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

1
2
3
4
5
6
7
8
9
auto my_array = {{
    1,
    2,
 
#if defined (MY_DEFINE)
    3,
#endif
 
    4}};

[victor_gasgas]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <array>
 
int main()
{
    auto my_array = {{
        1,
        2,
 
    #if defined (MY_DEFINE)
        3,
    #endif
 
        4}};
 
    for(auto &i : my_array)
    {
    }
}

Erreur de la part du compilateur :

Code :

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

1
2
3
4
5
6
7
g++ -o main.o -c main.cpp -W -Werror -Wall -Wfatal-errors -pedantic -pedantic-errors  -std=c++11
main.cpp: In function ‘int main()’:
main.cpp:13:11: error: unable to deduce ‘std::initializer_list<_Tp>’ from ‘{{1, 2, 4}}’
         4}};
           ^
compilation terminated due to -Wfatal-errors.
make: *** [main.o] Error 1

P.S. La sortie bizarre c'est gcc 4.8

[Kalith]

Voilà une implémentation qui fonctionne :

Code :

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

1
2
3
4
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array<T, sizeof...(Args)+1> {
    return std::array<T, sizeof...(Args)+1>({{t, args...}});
}

Il ne te reste plus qu'à écrire la proposition

[ternel]

Voila une idée à garder sous la main.

[Klaim]

Je ne vois pas l'interet de make_array si il ne permet pas de definir la taille dynamiquement, au runtime.

[Kalith]

Je ne vois pas comment tu pourrais utiliser une syntaxe comme celle-ci avec un nombre d'argument défini au runtime. Autrement dit, qu'écrirais-tu ici:

Code :

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

auto a = make_array(...);

Sinon, l'intérêt de std::array est justement d'avoir un tableau de taille fixe et connue à la compilation. Pour une taille fixe mais connue au runtime, il faudrait aller voir du côté de std::dynarray (également proposée pour la prochaine norme). Mais tu peux y perdre en performance, j'imagine, car le compilateur a d'avantage de liberté quand la taille du tableau est connue à la compilation.

[ternel]

Dans int tab[]={1,2,3}; le compilateur connait la taille, pourquoi ne le pourrait-il pas pour make_array({1,2,3});?

L'objectif de std::array est d'avoir la sécurité d'une classe autour d'un tableau crocheteux.

[Emmanuel Deloget]

Je ne vois pas l'interet de make_array si il ne permet pas de definir la taille dynamiquement, au runtime.

Un std::array dont la taille est déterminée au runtime s'appelle un std::vector

J'aillais dire qu'un make_array() n'est pas nécessairement une bonne chose, mais en même temps, je me suis dit ceci :

Code :

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

1
2
3
4
5
 
std::array<????, 2> array = { 
  [](int n) -> bool { return n & 1 ? true : false; },
  [](int n) -> bool { return n & 1 ? false : true; }
};

Quel est le type ???? ?

En gros, make_array() pour des int, float, ... n'a pas grand intérêt. Mais si on complexifie le type stocké, alors ça peut devenir intéressant d'utiliser le mécanisme de déduction de type proposé par le standard C++ en conjonction avec auto. Si on fabrique un array de lambda, c'est même obligatoire (et un array de lambda peut permettre de faire des choses originales).

Voilà une implémentation qui fonctionne :

Code :

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

1
2
3
4
5
 
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array<T, sizeof...(Args)+1> {
    return std::array<T, sizeof...(Args)+1>({{t, args...}});
}

Il ne te reste plus qu'à écrire la proposition

Je pencherais plutôt pour l'utilisation d'une liste d'initialiseurs (chrome me propose de changer ce mot par "administrationaliser" ; bien joué, chrome...). Tous les arguments sont de même type après tout.

[Kalith]

Je ne pense pas qu'il soit possible d'avoir une liste d'initialisation {...} comme argument de make_array (si l'objectif est bel et bien de créer un std::array). Les deux prototypes possibles seraient :

• std::array<T,N> make_array(std::initializer_list<T> v), mais il est impossible de déterminer automatiquement N (limitation de std::initializer_list, je trouve ça dommage d'ailleurs),
• ou encore std::array<T,N> make_array(const T (&v)[N]), mais je n'arrive pas à faire en sorte que le compilateur déduise automatiquement T et/ou N. Quand bien même ce serait possible, la seule manière de construire un std::array à partir de là serait de faire une boucle et d'assigner les éléments uns à uns. Ça peut paraître plus lourd à première vue, mais (avec toutes les optimisations activées) gcc me génère le même assembleur qu'avec le premier code que j'ai posté. Sans optimisation, il exécute la boucle aveuglément, ça sera donc moins performant.

Si on se fiche d'avoir une taille connue à la compilation, alors le problème de l'OP ne se pose plus, et on peut écrire directement :

Code :

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

1
2
3
4
5
6
7
std::vector<float> v = {
    1.0f,
#ifdef TODO
    2.0f,
#endif
    3.0f
};

Pas besoin d'un make_array ici.

[ternel]

comment ca, impossible?
Et std::initializer_list::size(), c'est pour quoi faire, dans ce cas?

A tout hasard, une breve question à Notre-Ami-a-Tous (c++11 make_array) m'a donné ceci (github) et cela (stackoverflow)

et aussi une boost proposal

[victor_gasgas]

Je pense qu'il voulait dire que std::initializer_list::size() ne peut pas être utiliser pour déduire l'argument N de std::array<T, N>.

[Kalith]

Exactement. La taille d'une std::initializer_list<T> n'est pas un paramètre template, et std::initializer_list<T>::size() n'est pas constexpr.
Les version qui sont citées dans le dernier post de leternel reposent sur le même principe que ce que j'ai proposé, si ce n'est qu'elles sont plus complètes et plus performantes (perfect forwarding).

[Klaim]

Un std::array dont la taille est déterminée au runtime s'appelle un std::vector

Oui mais en meme temps je n'ai pas parle d'allocation.
Le debat a lieu en ce moment dans le groupe de discussion du standard a propos de dynarray, comme quoi il devrais allouer sur la pile ou sur le tas...

Perso, tant que je peux allouer une quantitee fixe et etre garanti que ca ne bougera jamais, ca m'eviterai d'avoir a construire des helpers autour de std::vector.

[gl]

Un std::array dont la taille est déterminée au runtime s'appelle un std::vector

Pas nécessairement, tu peux vouloir un conteneur dont la taille est fixée à la construction sans pour autant que cette taille ne soit connu lors de la compilation (par ex. si elle est lue en conf).

Ce n'est pas quelque chose dont j'aurais besoin tout les jours mais je conçois que l'on puisse avoir ce besoin.

[Iradrille]

En gros, make_array() pour des int, float, ... n'a pas grand intérêt. Mais si on complexifie le type stocké, alors ça peut devenir intéressant d'utiliser le mécanisme de déduction de type proposé par le standard C++ en conjonction avec auto. Si on fabrique un array de lambda, c'est même obligatoire (et un array de lambda peut permettre de faire des choses originales).

C'est possible un array de lambda ? (ça devrait, mais impossible de compiler chez moi, ni sur VS2012, ni sur gcc 4.8.0)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array<T, sizeof...(Args)+1> {
	return std::array<T, sizeof...(Args)+1>({{t, args...}});
}
 
int main() {
	auto f = [](int i)->int { return i; };
	auto f2 = [](int i)->int { return i*2; };
 
	std::array<decltype(f), 2> arr = {{ f, f2 }};
	auto arr2 = make_array(f, f2);
 
	return 0;
}

Mais au moins l'erreur est originale

il n'existe aucune conversion définie par l'utilisateur appropriée de "lambda []int (int i)->int" en "lambda []int (int i)->int"

[Bousk]

Pas nécessairement, tu peux vouloir un conteneur dont la taille est fixée à la construction sans pour autant que cette taille ne soit connu lors de la compilation (par ex. si elle est lue en conf).

C'est exactement ce que fait vector, il a même un constructeur fait pour ça : std::vector(size_type n);

[gl]

C'est exactement ce que fait vector, il a même un constructeur fait pour ça : std::vector(size_type n);

Non ce n'est pas exactement ce que fait vector. La taille n'est pas fixée à la construction.
Tu peux certes réserver une certaine taille à la construction (ou via un appel à reserve()) mais cela ne fixe pas la taille définitivement, celle-ci est susceptible d'évoluer par la suite (construit un vector d'une taille 10 et insère 11 éléments par push_back : ça fonctionne très bien et la taille du vector est bel et bien supérieure à 10).
Fondamentalement, la taille d'un vector est dynamique. Un array a fondamentalement une taille fixe lui mais cela ne signifie pas nécessairement que celle-ci doit être connu à la compilation (comme dans le cas de std::array), il est tout à fait envisageable de souhaiter un array (avec une taille fixe donc) dont la taille n'est connue qu'au runtime (n'est-ce pas la raison d'être des VLA en C ? Même si je n'apprécie pas la façon dont ils sont définis, il remplisse bel et bien ce rôle).