listes char et initialiseur

Question

Je voudrais passer des valeurs d'octets numériques via une liste d'initialisation un modèle variadique dans un tableau. Est-ce possible?

template < int N > struct a { 
    char s[N]; 
    template < typename ... A > 
    a (A ... _a) : s {_a...} {} 
}; 

int main() { 
    // g++-4.5: error: narrowing conversion of »_a#0« from »int« to »char« inside { } 
    a <3> x { 1, 2, 3 }; 
} 

Ce que je peux penser est

• à utiliser la représentation octal, '\ 001', etc., ou
• de jeter chaque valeur unique.

Mais les deux ne sont pas satisfaisants.

Answer 1

REMARQUE: Tout cela n'est pas nécessaire, sauf si vous avez ajouté des fonctionnalités à la classe, donc ce n'est plus un agrégat. (Par exemple, d'autres constructeurs, des membres privés, une classe de base, etc.) La manière immédiate de corriger le code dans la question est simplement de supprimer le constructeur. Alors, supposons qu'il y a quelque chose de plus.

J'ai vu des gens essayer de faire des choses comme ça. Il semble laid, traitant de la sémantique de conversion et essayant de recréer artificiellement la fonctionnalité d'un appel de fonction habituel.

Voici une stratégie pour créer une classe de tableau qui a simplement le bon constructeur en premier lieu.

L'aliasing de modèle mettrait la cerise sur le gâteau en cachant la laideur ::type, mais ce n'est pas encore dans GCC.

template< typename ... NT > 
struct var_ctor_array { 
    enum { size_e = 0 }; // only used for zero size case 
}; 

template< typename T, typename ... NT > 
struct var_ctor_array< T, NT ... > { 
    enum { size_e = 1 + sizeof...(NT) }; 

    T st[ size_e ]; 

    var_ctor_array(T elem0, NT ... elemN) 
     : st { elem0, elemN ... } {} 
}; 

template< typename T, size_t N, typename ... NT > 
struct gen_var_ctor_array { 
    typedef typename gen_var_ctor_array< T, N-1, T, NT ... >::type type; 
}; 

template< typename T, typename ... NT > 
struct gen_var_ctor_array< T, 0, NT ... > { 
    typedef var_ctor_array< NT ... > type; 
}; 

int main() { // usage 
    gen_var_ctor_array< char, 5 >::type five(1, 2, 3, 4, 5); 
} 

Answer 2

Vous n'utilisez pas réellement les listes d'initialisation. Le constructeur reçoit un variadic template et vous initialisez x avec uniform initialization.

Le seul problème est que je ne sais pas d'une façon élégante de l'initialisation d'un tableau avec un initializer_list, AFAIK std::array devrait avoir un constructeur qui accepte initializer_list mais il ne semble pas être pris en charge par g ++ encore.

#include <utility> 
template < int N > struct a { 
    char s[N]; 

    a (std::initializer_list<char> list) { 
     if (N != list.size()) 
      throw "list wrong size"; 

     int i = 0; 
     const char* p = list.begin(); 
     while(p != list.end()) 
      s[i++] = *p++; 
    } 
}; 

Answer 3

Vous n'avez pas besoin de code compliqué

template < int N > struct a { 
    char s[N]; 
    template < typename ... A > 
    a (A ... _a) : s {static_cast<char>(_a)...} {} 
};