[Template] < T, T inValue1, T inValue2> Mingw : compilation erreur ( VC : ok )

Bonjour à tous.

J'ai une fonction définie comme ce qui suit :

Header :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

namespace Ca { namespace Math { /** Retourne l'angle compris dans l'intervalle [inOrigine, inOrigine + inModulo]         *   @remarks inModulo peut être négatif         */ template< typename T, T inOrigine, T inModulo > T GetRadianAngleModulo( T inRadianAngle ) ; } } #include "Ca/Math.tpp"

---

Template corps :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template< typename T, T inOrigine, T inModulo > T Ca::Math::GetRadianAngleModulo( T inRadianAngle ) { T aAlpha = std::atan2( std::sin( inRadianAngle ), std::cos( inRadianAngle ) ) ;   aAlpha += inModulo ;   // http://pubs.opengroup.org/onlinepubs/007904975/functions/fmod.html T aY = inOrigine + inModulo ; return aY ? std::fmod( aAlpha, inOrigine + inModulo ) + inOrigine : aAlpha + inOrigine ; }

---

Elle est appelée de la manière suivante :

Code:

---

1 2	float aResult = Ca::Math::GetRadianAngleModulo<float, 0, 6.2831853071795f>( m_SurfaceNode->getOrientation().getYaw().valueRadians() ) ;

---

Sous Visual express 2008 la compilation et l’exécution se déroule bien.
Sous Mingw la compialtion échoue et m'affiche le message suivant :
error: no matching function for call to 'GetRadianAngleModulo(Ogre::Real)'
( Ogre::Real est le type float )

Voici ma version de Mingw :

Citation:

---

=== TDM-GCC Compiler Suite for Windows ===
--- GCC 4.4/4.5 Series ---
*** Standard MinGW 32-bit Edition ***

...

REQUIRED BASE:
* gcc-core (gcc-4.5.2-tdm-1-core)
* binutils (binutils-2.21-3-mingw32-bin)
* mingwrt (mingwrt-3.18-mingw32-dev, mingwrt-3.18-mingw32-dll)
* w32api (w32api-3.17-2-mingw32-dev)

---

Peut être qu'il y a une fonction existante pour faire ce travail. Si oui je suis tout même intéresser par la résolution de cette erreur.

Merci d'avance ;).

As-tu essayer de mettre Ogre::Real à la place de float dans les arguments templates ?
Voir message de 3DArchi.

Salut,

Citation:

---

Envoyé par C++11

A non-type template-parameter shall have one of the following (optionally cv-qualified) types:
— integral or enumeration type,
— pointer to object or pointer to function,
— lvalue reference to object or lvalue reference to function,
— pointer to member,
— std::nullptr_t.

---

(en C++03, la différence est que std::nullptr_t n'existe pas et les références ne sont pas précisées lvalue mais les restrictions sont pour le reste identiques)

Un paramètre générique (non type) doit donc être un de ceux précisés dans la norme ci-dessus. Ce qui ne saurait être le cas d'un float :(

Bref ton code est invalide car il est interdit d'avoir une quelconque fonction générique f<float valeur>
My 2 cents :

• ca ne résout pas ton problème mais par habitude, je préfère mettre les types déductibles à la fin pour ne pas avoir à les spécifier :
  
  Code:

  ---

  1 2 3 4

  template< T inOrigine, T inModulo,typename T > T Ca::Math::GetRadianAngleModulo( T inRadianAngle ); //... Ca::Math::GetRadianAngleModulo<1,2>(3);

  ---

• en C++11, tu pourrai faire quelque chose comme ça (mais je me pince un peu le nez pour te présenter ce hack) :
  
  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

  template< typename T, typename inOrigine, typename inModulo > T GetRadianAngleModulo( T inRadianAngle ) { T aAlpha = std::atan2( std::sin( inRadianAngle ), std::cos( inRadianAngle ) ) ;   aAlpha += inModulo::value ;   // http://pubs.opengroup.org/onlinepubs/007904975/functions/fmod.html T aY = inOrigine::value + inModulo::value ; return aY ? std::fmod( aAlpha, inOrigine::value + inModulo::value ) + inOrigine::value : aAlpha + inOrigine::value ; }   template<class T> struct param_1 { static constexpr T value = 1.; };   template<class T> struct param_2 { static constexpr T value = 2.; };   // .... GetRadianAngleModulo<float,param_1<float>,param_2<float>>(1.0);

  ---

• passe en paramètre :
  
  Code:

  ---

  1 2 3 4 5

  template< typename T > T GetRadianAngleModulo( T inRadianAngle, T inOrigine, T inModulo );   // puis : float aResult = Ca::Math::GetRadianAngleModulo( m_SurfaceNode->getOrientation().getYaw().valueRadians(),0, 6.2831853071795f ) ;

  ---

• Mais en réalité, quel est l'intérêt de rendre cette fonction générique ??? Laisse jouer la conversion :
  
  Code:

  ---

  double GetRadianAngleModulo( double inRadianAngle, double inModulo, double inOrigine)

  ---

  ou à la place de double un typedef au bon endroit pour fixer une fois pour toute ton type 'real'

Belle réponse :ccool:

J'espérais faire un typedef de cette fonction pour un type et un intervalle particulier pour plus d'une utilisation de celle-ci. Ce qui aurait été élégant je trouves.

Mais c'est finalement plus contraignant qu'autres choses.

Avec l'intervalle passé en template je ne peux pas utilisé ma fonction GetPi

Code:

---

1 2 3 4 5 6

template < typename T > T Ca::Math::GetPi() { return std::atan2( static_cast<T>( 0 ), static_cast<T>( -1 ) ) ; }

---

Ce qui m'oblige à définir la constante en dure. Ce qui est encore acceptable si un typedef viens définir GetRadianAngleModulo.

Je vais donc opter pour la solution par passage de paramètre. Mais je ne vais pas laisser la conversion se faire, ça remettrait en cause toute ma librairie Math qui n'est que du template ( cf : GetPi ).

Merci beaucoup pour la réponse. Elle est très claire et complète.

Remarques :

Citation:

---

par habitude, je préfère mettre les types déductibles à la fin pour ne pas avoir à les spécifier :

---

C'est donc comme ça qu'il faut faire. Merci ça m'avait titillé l'esprit.

Bonjour,
utilisant quelques fois la forme template<typename T, T value [...]>, la détection automatique de T m’intéressait.

Citation:

---

Envoyé par 3DArchi

ca ne résout pas ton problème mais par habitude, je préfère mettre les types déductibles à la fin pour ne pas avoir à les spécifier :

Code:

---

1 2 3 4

template< T inOrigine, T inModulo,typename T > T Ca::Math::GetRadianAngleModulo( T inRadianAngle ); //... Ca::Math::GetRadianAngleModulo<1,2>(3);

---

---

Mais je pense que cela pose un problème de "scope" :(.

Citation:

---

Envoyé par norme

The potential scope of a template parameter name begins at its point of declaration (3.3.2) and ends at the
end of its declarative region. [ Note: This implies that a template-parameter can be used in the declaration
of subsequent template-parameters and their default arguments but cannot be used in preceding template-parameters
or their default arguments. For example,

template<class T, T* p, class U = T> class X { /* ... */ };
template<class T> void f(T* p = new T);
This also implies that a template-parameter can be used in the specification of base classes. For example,
template<class T> class X : public Array<T> { /* ... */ };
template<class T> class Y : public T { /* ... */ };

The use of a template parameter as a base class implies that a class used as a template argument must be
defined and not just declared when the class template is instantiated. —end note ].

---

Citation:

---

Envoyé par gb_68

Mais je pense que cela pose un problème de "scope" :(.

---

Exact. Je n'avais pas fait attention que dans ce cas cela ne s'y prêtait pas.

Je suis curieux et je n'arrive pas à comprendre le problème de portée .

Le paramètre générique devient 'connu' du compilateur à partir du moment où il est déclaré. Et pas avant. En particulier pas dans l'ensemble de l'expression déclarative. C'est pour cela que : template <T v, typename T> est invalide car T ne commence qu'à typename T. Donc dans T v, T ne correspond à rien.
Ce qui est dit aussi c'est que T devient 'connu' dès typename T - non pas avant comme on l'a dit précédemment - mais non pas non plus seulement dans la classe/fonction générique). On peut donc l'utiliser dans la suite des paramètres génériques ou comme classe de base.
La portée paramètre générique s'achève avec la déclaration à laquelle elle prend part.

template<class A, class B, class C = B> struct foo : B { ..} ; ...........
|--------1-------|--------------------2------------------|----3-------
1 : B est inconnu et ne peut être utilisé
2 : B peut être utilisé dans toute cette zone
3 : B n'est plus connu

Dit comme ça, ça peut avoir l'air trivial, mais en fait c'est un choix et il faut le préciser.
Par exemple, le paramètre aurait pu être valable dès le début de la déclaration et donc être utilisé comme ça : template <T v, typename T>. A l'instar des membres d'une classe qui peuvent être utilisés dans la classe avant leur déclaration :

Code:

---

1 2 3 4 5 6 7 8

struct foo { foo() :bar() // -> Ici, bar n'a pas encore été rencontré et pourrait être considéré comme 'inconnu' {} //.... int bar; };

---

Ou au contraire ne devenir utilisable qu'à l'intérieur de la classe, de même que les paramètres d'une fonction ne sont utilisable que dans la fonction[*] :

Code:

---

1 2 3 4

void fonction(int p1, int p2 = p1) // => erreur : on ne peut utiliser p1 avant d'être entré dans la fonction { p2 = p1; }

---

Aucun de ces deux choix n'a été fait et donc il a fallu préciser exactement quelle portée on souhaitait à un paramètre générique.

[*] j'oublie volontairement le cas du constructeur où le paramètre est visible dans la liste d'initialisation, çad, avant d'avoir ouvert l'accolade de définition.