(Remarque: cette question concerne le fait de ne pas avoir à spécifier le nombre d'éléments et de toujours permettre aux types imbriqués d'être directement initialisés.)
Cette question traite des utilisations restantes pour un tableau C comme int arr[20];
. Sur sa réponse , @James Kanze montre l'un des derniers bastions des tableaux C, ses caractéristiques d'initialisation uniques:
int arr[] = { 1, 3, 3, 7, 0, 4, 2, 0, 3, 1, 4, 1, 5, 9 };
Nous n'avons pas à spécifier le nombre d'éléments, hourra! Maintenant, parcourez-le avec les fonctions C ++ 11 std::begin
et std::end
from <iterator>
( ou vos propres variantes ) et vous n'avez même jamais besoin de penser à sa taille.
Maintenant, y a-t-il des moyens (éventuellement TMP) pour obtenir la même chose avec std::array
? L'utilisation de macros a permis de le rendre plus joli. :)
??? std_array = { "here", "be", "elements" };
Edit : La version intermédiaire, compilée à partir de diverses réponses, ressemble à ceci:
#include <array>
#include <utility>
template<class T, class... Tail, class Elem = typename std::decay<T>::type>
std::array<Elem,1+sizeof...(Tail)> make_array(T&& head, Tail&&... values)
{
return { std::forward<T>(head), std::forward<Tail>(values)... };
}
// in code
auto std_array = make_array(1,2,3,4,5);
Et utilise toutes sortes de trucs sympas C ++ 11:
- Modèles Variadic
sizeof...
- références rvalue
- acheminement parfait
std::array
, bien sûr- initialisation uniforme
- omettre le type de retour avec une initialisation uniforme
- inférence de type (
auto
)
Et un exemple peut être trouvé ici .
Cependant , comme le souligne @Johannes dans le commentaire sur la réponse de @ Xaade, vous ne pouvez pas initialiser des types imbriqués avec une telle fonction. Exemple:
struct A{ int a; int b; };
// C syntax
A arr[] = { {1,2}, {3,4} };
// using std::array
??? std_array = { {1,2}, {3,4} };
En outre, le nombre d'initialiseurs est limité au nombre d'arguments de fonction et de modèle pris en charge par l'implémentation.
TMP
votre question?