constructeur à N arguments, N étant un paramêtre template

Version imprimable

Je développe actuellement une bibliothèque de géométrie ND (2D, 3D et 4D, principalement), dont voici un extrait.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 using dimension_type = std::size_t; // constexpr compatible mathematical N-dimensional vector template <typename Value, dimension_type Dimensions> class vector { static_assert(Dimensions > 0, "No support for 0D (or less) vectors"); public: using value_type = Value; value_type values[Dimensions]; //agregate initialization constexpr value_type const& operator[](dimension_type i) const { return values[i]; } value_type& operator[](dimension_type i) { return values[i]; } vector& operator += (vector const& other) { for (dimension_type i = 0; i < Dimensions; ++i) (*this)[i] += other[i]; return *this; } constexpr vector add(vector const& other) const { return add(other, make_index_sequence()); } private: using make_index_sequence = std::make_integer_sequence<dimension_type, Dimensions>; template<dimension_type... i> using index_sequence = std::integer_sequence<dimension_type, i...>; template<dimension_type... i> constexpr vector add(vector const& other, index_sequence<i...>) const { return vector{ ((*this)[i] + other[i])... }; } }; template <typename Value, dimension_type dimensions> constexpr inline vector<Value, dimensions> operator + (vector<Value, dimensions> const& a, vector<Value, dimensions> const& b) { return a.add(b); }
J'ai beau chercher, je ne vois pas comment écrire mes constructeurs, avec les contraintes suivantes:

Ils doivent être constexpr c'est "vital"
vector<double, 2> v; doit compiler et être {0, 0} (pas comme std::array)
vector<double, 3> k{0,0,1}; doit être possible
vector<double, 3> v{0, 1}; ne doit pas compiler, car il manque une composante. (pas comme std::array)
f(vector<double, 3>); f({0, 1, 2}); doit compiler, sans avoir à préciser le type (f(vector<double, 3>{0,1,2})

Précisément, je ne sais pas comment écrire mon constructeur à N paramètres.
J'ai essayé avec l'"aggregate initialization", mais je n'ai pas le point 4
J'ai essayé avec un constructeur template variadique, mais le point 5 saute.
Code:

1 2 3 4 template <typename T...> constexpr vector(T... args): values{args...} { static_assert(plein de choses); }
J'essaye avec std::initializer_list, mais le point 4 compile (j'ai seulement une exception).

Avez-vous une idée?

Salut,

(petite correction "purement sémantique" : envisage peut être de nommer ton deuxième paramètre template "count" au lieu de dimensions, cela évitera la confusion nombre d'élément Vs tableau multi dimentionnel)

Sinon, je me demande (il faudra tester) si un code proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 template <typename Needed, typename T, typename ... Others> struct TypeChecker{ template < static constexpr void check(){ TypeChecker<Needed, T>::check(); TypeChecker<Needed, Other ...>::check(); } }; template <typename Needed, typename T> struct TypeChecker<Needed, T>{ static constexpr void check(){ static_assert(std::is_same_v(Needed, T); } } template <typename T, dimension_type Count> class vector{ static_assert(Dimensions > 0, "No support for 0D (or less) vectors"); public: vector(T all=T{}); // constructeur par défaut + constructeur permettant de définir une valeur unique pour tous les éléments template <typename ... Args> vector(Args ... args){ static_assert(sizeof...(Args) == Count, "bad parameter count"); TypeChecker<T, Args ...>::check(); } /* ... */ };
ne pourrait pas faire l'affaire ;)

Au passage, pourquoi n'utiliserais tu pas std::array pour représenter tes données, car, lui, il implémente déjà l'agregate initialization, et cela te faciliterait surement la vie ;)

Ton code pourrait alors prendre une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 template <typename T, dimension_type Count> class vector{ public: vector():datas_{}{} template <typename ... Args> vector(Args ... args):datas_{args ...}{ } private: std::array<T, Count> datas_; };
Et le tour serait joué ;)

18/06/2018, 16h02
ternel

A priori, parce qu'il y a un gros soucis avec std::array: l'aggregate initialization accepte un nombre trop bas d'arguments.
Cela dit, vu la forme que ca prend, c'est envisageable, maintenant.

Je vais étudier ta proposition.
Peut-être aussi ajouter un enable_if, pour que le check soit fait avant l'exécution de l'initialization.

Je tiens quand même à être clair: j'ai écrit ce code à la volée, et je ne l'ai absolument pas testé. quelques adaptations sont peut-être nécessaires ;)

quant à enable_if, je t'avouerai que j'ai un peu de mal à voir comment tu t'y prendrais :P

Par contre, ce que tu pourrais envisager de faire, ce serait d'avoir un code proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 template < dimension_type Count> struct CountChecker{ CountChecker(){} template <typename ... Args> CountChecker(Args ...){ static_assert(sizeof...(Args)==count); } }; template <typename T, dimension_type Count> class vector : private CountChecker<Count>{ public: vector():CountChecker<Count>(){} template <typename ... Args> vector(Args ... args):CountChecker<Count>(arg),/* ... */{ } };
Encore une fois, le code n'a pas été testé, et il a été écrit "à la volée", avec tout ce que cela peut impliquer ;)

Une solution avec static_assert va poser quelques soucis avec la surcharge. Par exemple f(vector<double, 3>); et f(vector<double, 2>); vont correspondre toutes les 2 et il y aura une erreur de compilation contrairement à enable_if qui va filtrer les prototypes.
Code:

1 2 3 4 5 6 7 8 9 10 11 template<class T, size_t Dim> struct vector { vector() = default; template<class... U, class = std::enable_if_t<sizeof...(U) == Dim>> constexpr vector(U...) {} std::array<T, Dim> values {}; };

18/06/2018, 17h29
koala01

Oh, si un code proche de

Code:

template<class... U, class = std::enable_if_t<sizeof...(U) == Dim>>

fonctionne, alors allons y gaiement :D

Mais (je peux me tromper, bien sur :P) il me semblait avoir expériementé quelque problèmes en essayant de rajouter un paramètre template (fut-il défini par défaut) après un parameter pack :P

Je suis arrivée une variante avec le code suivant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
template<bool...> struct bool_pack;
template<bool... bs> 
using all_true = std::is_same<bool_pack<bs..., true>, bool_pack<true, bs...>>;
 
// constexpr compatible mathematical N-dimensional vector (spatial displacement)
template <typename Value, dimension_type Dimensions>
class vector {
  static_assert(Dimensions > 0, "no support for 0D (or less) vectors");
public:
  using value_type = Value;
 
private:
  std::array<Value, Dimensions> values;
public:
  vector() { values.fill(0); }
 
  vector(vector&&) noexcept = default;
  vector(vector const&) noexcept = default;
 
  template <typename... Args>
  vector(Args const&... args): values{args...} {
    static_assert(sizeof...(Args) == Dimensions, "bad parameter count");
    static_assert(all_true<(std::is_convertible<Args, Value>::value)...>::value, "non convertible argument");
  }
 
  template <typename... Args>
  vector(Args && ... args): values{std::forward<Args>(args)...} {
    static_assert(sizeof...(Args) == Dimensions, "bad parameter count");
    static_assert(all_true<(std::is_convertible<Args, Value>::value)...>::value, "non convertible argument (&&)");
  }
 
  //...
};

Merci pour votre aide!

J'ai plus qu'à améliorer all_true pour réduire le nombre de templates instanciées (il existe une solution logarithmique)

20/06/2018, 01h45
jo_link_noir

Citation:

Envoyé par ternel

J'ai plus qu'à améliorer all_true pour réduire le nombre de templates instanciées (il existe une solution logarithmique)

Je vois mal comment tu pourrais l'améliorer. all_true en elle même fait 2 instanciations de bool_pack et les is_convertible devront être toutes instancier dans un code qui compile.

En parlant de is_convertible, en n'y mettant que Args comme paramètre, tu perds les types de références et const. Ce n'est pas forcement gênant ici, mais cela peut jouer des tours dans d'autres contextes.

(note: le constructeur forward reference couvre le cas de celui prenant des const&, tu pourrais n'en mettre qu'un).
20/06/2018, 09h14
ternel

Effectivement, je suis passé à Args const& ... et Args && ....
Même si je crois me souvenir que ce dernier suffirait, en vertu du "perfect frowarding".