Initialisation de std :: tuple à partir de la liste d’initialisation

Je me demande si le tuple peut être initialisé par la liste d’initialisation (pour être plus précis – par initializer_list de initializer_lists)? Considérant la définition du tuple:

typedef std::tuple< std::array, std::array, std::array, std::array > vertex; 

y a-t-il un moyen de faire ce qui suit:

 static vertex const nullvertex = { {{0, 0, 0}}, {{0.0, 0.0}}, {{0, 0, 0, 0}}, {{0, 0, 0, 0}} }; 

Je veux juste obtenir la même fonctionnalité que j’ai obtenue en utilisant struct au lieu de tuple (donc seuls les tableaux sont initialisés par initializer_list):

 static struct vertex { std::array m_vertex_coords; std::array m_texture_coords; std::array m_color_1; std::array m_color_2; } const nullvertex = { {{0, 0, 0}}, {{0.0, 0.0}}, {{0, 0, 0, 0}}, {{0, 0, 0, 0}} }; 

Il n’y a aucune raison pour que je doive utiliser des tuples, me demandant simplement. Je vous le demande, car je ne peux pas parcourir les erreurs g ++ générées par ma tentative d’initialisation du tuple.

@Motti: J’ai donc manqué la syntaxe correcte pour une initialisation uniforme –

 static vertex const nullvertex = vertex{ {{0, 0, 0}}, {{0.0, 0.0}}, {{0, 0, 0, 0}}, {{0, 0, 0, 0}} }; 

et

 static vertex const nullvertex{ {{0, 0, 0}}, {{0.0, 0.0}}, {{0, 0, 0, 0}}, {{0, 0, 0, 0}} }; 

Mais il semble que tous les problèmes se trouvent dans les tableaux, qui n’ont pas de constructeur pour initializer_list et dont l’enveloppement avec un constructeur approprié ne semble pas être une tâche facile.

Les listes d’initialisation ne sont pas pertinentes pour les tuples.

Je pense que vous confondez deux utilisations différentes d’accolades en C ++ 0x.

  1. initializer_list est une collection homogène (tous les membres doivent être du même type, donc pas pertinent pour std::tuple )
  2. L’initialisation uniforme est celle où les accolades sont utilisées pour construire toutes sortes d’objects. tableaux, POD et classes avec constructeurs. Qui a aussi l’avantage de résoudre l’parsing la plus vexante )

Voici une version simplifiée:

 std::tuple t = { 1, '1' }; // error: converting to 'std::tuple' from initializer list would use // explicit constructor 'std::tuple<_T1, _T2>::tuple(_U1&&, _U2&&) // [with _U1 = int, _U2 = char, _T1 = int, _T2 = char]' std::tuple t { 1, '1' }; // note no assignment // OK, but not an initializer list, uniform initialization 

Le message d’erreur indique que vous essayez d’appeler implicitement le constructeur mais que c’est un constructeur explicite, donc vous ne pouvez pas.

En gros, ce que vous essayez de faire, c’est quelque chose comme ceci:

 struct A { explicit A(int) {} }; A a0 = 3; // Error: conversion from 'int' to non-scalar type 'A' requested A a1 = {3}; // Error: converting to 'const A' from initializer list would use // explicit constructor 'A::A(int)' A a2(3); // OK C++98 style A a3{3}; // OK C++0x Uniform initialization