Cast d'un type de base vers une classe que j'ai créée

Bonjour à tous.

J'ai un problème de cast : j'ai créé une classe Array (rq : elle est complètement bidon, je ne l'ai créée que pour faire des tests) :

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

class Array{ private: vector<double> table; int dim;   public: Array(){ dim = 0; } void setTable(vector<double> t){ table = t; } vector<double> getTable(){ return table; } void setDim(int d){ dim = d; } int getDim(){ return dim; } double & operator()(int i){ return table[i]; } };

---

Je cherche à savoir comment je peux faire de la conversion de type d'un double vers un Array (par exemple en donnant la valeur du double au membre dim de ma classe).

Je trouve tous les exemples que je veux pour faire ce genre de manipulation entre deux types que je définis, et d'un type définis vers un type existant (par exemple j'ai réussi à coder le cast Array=>double), mais je n'arrive pas à pondre le cast d'un type prédéfini vers ma classe.

Est-ce possible ? Si oui comment ?
Merci de votre aide !

Code:

---

1 2 3

Array(double d) : dim(d) { }

---

Merci de la réponse, mais j'ai voulu simplifier ma question et je crois que j'ai un peu déformé ce que je cherche à faire.

En fait dans la classe Array, j'ai défini un opérateur * qui multiplie deux Array. Je voudrais que ce même opérateur puisse multiplier un Array et un double. Pour ça je voulais que l'appel de 2.*A convertisse le 2. en un Array puis fasse appel à la multiplication des Array. Est-ce possible ?

Juste pour remarque je ne peux pas (je vous passe les détails de mon implémentation, mais vraiment c'est une contrainte inévitable) définir un autre opérateur * avec des types d'entrée différents.

Et j'aimerais vraiment pouvoir faire l'appel :

Code:

---

1 2 3

Array A; // definition de A 2.*A;

---

plutôt que de faire qqch du genre :

Code:

---

1 2 3 4

Array A; // definition de A Array B(2.); B*A;

---

Mais merci quand même JolyLoic de ta réponse.

Citation:

---

Envoyé par Simpom

Merci de la réponse, mais j'ai voulu simplifier ma question et je crois que j'ai un peu déformer ce que je cherche à faire.

En fait dans la classe Array, j'ai défini un opérateur * qui multiplie deux Array. Je voudrais que ce même opérateur puisse multiplier un Array et un double. Pour ça je voulais que l'appel de 2.*A convertisse le 2. en un Array puis fasse appel à la multiplication des Array. Est-ce possible ?

---

Oui, si tu definis ton operator* en tant que fonction libre et pas en tant que membre.

Bon alors je fais ce que j'aurais dû faire dès le départ : qqch de clair !! (dsl pour l'imbroglio précédent...)

Voilà ce que je voudrais faire :

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 35 36 37 38 39 40 41 42 43 44 45

template<class T> class Toto{ private: T value;   public: Toto<T>(T t=0.){ value = t; } void setValue(T t){ value = t; } int getValue(){ return value; } void operator=(Toto a){ cout << "(operator =)" << endl; value = a.value; }   template<class S> friend Toto<S> operator+(Toto<S>, Toto<S>); };   template<class S> Toto<S> operator+(Toto<S> a1, Toto<S> a2){ cout << "(operator +)" << endl; Toto<S> a; a.value = a1.value + a2.value; return a; }   int main(int argc, char* argv[]) { Toto<int> s(1); cout << "value : " << s.getValue() << endl;   Toto<int> t(2); cout << "value : " << t.getValue() << endl;   Toto<int> u; u=s+t; cout << "value : " << u.getValue() << endl;   Toto<int> v; v=2+u;   return 0; }

---

Tout fonctionne sauf la dernière instruction, où il m'insulte :

Code:

---

erreur: no match for 'operator+' in '2 + u'

---

Comment m'en sortir ?

Tu n'avais pas dit que tu etais dans un template.

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

template<class T> class Toto{ private: T value;   public: Toto(T t=0){ value = t; }   void setValue(T t){ value = t; } int getValue(){ return value; } void operator=(Toto a){ cout << "(operator =)" << endl; value = a.value; }   friend Toto operator+(Toto a1, Toto a2) { cout << "(operator +)" << endl; Toto a; a.value = a1.value + a2.value; return a; } };

---

Mais j'ai pas le temps d'expliquer pourquoi.

Yep merci beaucoup !

Et si maintenant je veux faire :

Code:

---

1 2 3 4

Toto<int> s(1); Toto<double> t(2); Toto<int> u; u=s+t;

---

Comment (et où) dois-je le coder ?

Citation:

---

Envoyé par Simpom

Yep merci beaucoup !

Et si maintenant je veux faire :

Code:

---

1 2 3 4

Toto<int> s(1); Toto<double> t(2); Toto<int> u; u=s+t;

---

Comment (et où) dois-je le coder ?

---

Comment determines-tu le type retourne?

Effectivement dans ma petite tête en déclarant u comme un Toto<int> ça permettait de déclarer le type de retour mais effectivement pas...

Comment dois-je procéder ? Il y a une solution pour que je ne sois pas obligé de préciser le type de retour de mon opérateur ?

En C++0X : decltype, tu peux dire que le résultat est du type de (int + double)
En C++98 : Une classe de traits, mais c'est laborieux, tu dois spécifier ça à la main.

Tu peux ne pas utiliser l'opérateur + et définir une fonction qui prend trois paramètres dont son retour (retour par réference);

Citation:

---

Envoyé par Simpom

Effectivement dans ma petite tête en déclarant u comme un Toto<int> ça permettait de déclarer le type de retour mais effectivement pas...

Comment dois-je procéder ? Il y a une solution pour que je ne sois pas obligé de préciser le type de retour de mon opérateur ?

---

Il y a differents choix, dont:

Citation:

---

Envoyé par JolyLoic

En C++0X : decltype, tu peux dire que le résultat est du type de (int + double)
En C++98 : Une classe de traits, mais c'est laborieux, tu dois spécifier ça à la main.

---

L'utilisation d'un type proxy comme resultat avec des conversions implicites ou des operateur d'assignation template (voir les expressions template par exemple).

Ma question etait plus pour pouvoir t'orienter directement vers un choix pertinent.

Citation:

---

Envoyé par MatRem

Tu peux ne pas utiliser l'opérateur + et définir une fonction qui prend trois paramètres dont son retour (retour par réference);

---

Le type resultat ne peut pas etre deduit, il devrait etre specifie explicitement ce qui n'est pas desire.

Citation:

---

Le type resultat ne peut pas etre deduit, il devrait etre specifie explicitement ce qui n'est pas desire.

---

S'il est passé en paramètre (prend trois paramètres dont son retour) il sera déduit. Ma phrase n'était peut être pas claire...

Merci de vos réponses. J'ai réussi à faire ce que je voulais. Bon je force un tout petit peu la chose en demandant que le type de retour de ma fonction soit le type du deuxième argument (c'est le cas d'utilisation le plus probable).

Salut,

Quand je lis

Citation:

---

Envoyé par Simpom

(c'est le cas d'utilisation le plus probable).

---

je ne peux m'empêcher d'avoir une série de flash rouges dans la tête pour m'indiquer un danger potentiel :aie:

Je suis peut être trop prudent de nature ou tout à fait parano, mais je ne peux m'empêcher de penser que si c'est le cas "le plus probable", c'est qu'il y a, sans doute, des circonstances où ce ne sera pas le cas :aie:

Je ne remets pas en cause ton analyse, et il est donc tout à fait possible que le type de retour soit, effectivement, toujours identique au deuxième paramètre, mais, si tu as le moindre doute, il serait sans doute intéressant de pousser la réflexion un peu plus loin, soit pour lever le doute, soit pour trouver une solution qui prenne les "cas peu probables / improbables" en compte :P

Tu sais, il est généralement admis comme "peu probable" que deux trains se trouvent à contre-sens l'un de l'autre sur un même tronçon de ligne, et, pourtant, quand cela arrive, on compte les morts par dizaines ou par centaines...

Quelles conséquences pourrait avoir un cas improbable de ton coté :question:

Citation:

---

Envoyé par JolyLoic

En C++0X : decltype, tu peux dire que le résultat est du type de (int + double)
En C++98 : Une classe de traits, mais c'est laborieux, tu dois spécifier ça à la main.

---

En C++98, BOOST_TYPEOF permet de faire comme en C++0X (au comportement chelou sur les references prés mais ici ca ne jouera pas)

Citation:

---

Envoyé par Jean-Marc.Bourguet

Tu n'avais pas dit que tu etais dans un template.

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

template<class T> class Toto{ private: T value;   public: Toto(T t=0){ value = t; }   void setValue(T t){ value = t; } int getValue(){ return value; } void operator=(Toto a){ cout << "(operator =)" << endl; value = a.value; }   friend Toto operator+(Toto a1, Toto a2) { cout << "(operator +)" << endl; Toto a; a.value = a1.value + a2.value; return a; } };

---

Mais j'ai pas le temps d'expliquer pourquoi.

---

Serait-il possible d'avoir l'explication précise, parce que là je sèche.

Si tu ne mets pas en amie, le système des template fait qu'il ne sauras pas quel fonction appeler en cas de nécessité de conversion implicite (il n'arrivera pas à matcher les paramètre template).

Le fait de déclarer la fonction en amie force le compilateur à l'utiliser si il peut et donc autorise les conversions implicites.

NB: Dans la classe, Toto équivaut à Toto<T>, donc la fon,ction amie n'est pas template.

Citation:

---

Envoyé par Flob90

Si tu ne mets pas en amie, le système des template fait qu'il ne sauras pas quel fonction appeler en cas de nécessité de conversion implicite (il n'arrivera pas à matcher les paramètre template).

Le fait de déclarer la fonction en amie force le compilateur à l'utiliser si il peut et donc autorise les conversions implicites.

NB: Dans la classe, Toto équivaut à Toto<T>, donc la fon,ction amie n'est pas template.

---

Le fait de déclarer la fonction amie a surtout comme résultat de... la sortir de la portée de la classe, et donc d'en faire... une fonction libre.

De ce fait, et, comme il s'agit, malgré tout, d'une fonction template (car il s'agit d'une fonction déclarée dans une classe template et manipulant les arguments template ainsi définis), le compilateur choisira cette version s'il s'agit du meilleur "match".

Ce sera, entre autres, le cas lorsqu'un des paramètres sera de type Toto<XXX>.

Si l'autre paramètre n'est pas du type Toto<XXX>, il y aura conversion implicite grâce au constructeur de Toto prenant... un XXX comme paramètre ;) (ici: XXX représente n'importe quel type susceptible de représenter une valeur numérique :D)

Non koala, ici friend n'a pas pour but de sortir la fonction de la classe.

Sortir la fonction c'est ce qu'avait fait l'op, et il n'avait pas utiliser friend car il n'avait pas besoin d'accéder à la classe. Cependant ici, le frien est obligatoire pour avoir une fonction bel et bien déclaré.

Ce n'est pas une fonction template, c'est une fonction amie d'une classe template, la nuance est là. Si c'était une méthode template d'une classe (template ou non) alors la méthode qui correspond au paramètre ne serait déclaré qu'au moment de la compilation (et le match des paramètre devrait être exact). Alors qu'une méthode d'une classe template est déclaré dès qu'une version de la classe à été "utilisé".

Si tu essays d'appeler une fonction template et que les paramètre ne correspondent pas exactement (à la compilation) alors l'appel échouera, il n'y a pas de conversion implicite possible. Ces conversions ne sont possibles qu'avec des fonctions non-template.

Le but de friend n'est pas ici de permettre l'accés à la classe, mais d'assurer qu'une fonction est bien déclaré et permettre les conversions implictes.

Citation:

---

Envoyé par Flob90

Si tu ne mets pas en amie, le système des template fait qu'il ne sauras pas quel fonction appeler en cas de nécessité de conversion implicite (il n'arrivera pas à matcher les paramètre template).

Le fait de déclarer la fonction en amie force le compilateur à l'utiliser si il peut et donc autorise les conversions implicites.

---

Je m'aperçoit que ma question n'était vraiment pas précise.

J'ai bien saisie la raison d'être du friend et que le problème tourne autour de la déclaration de fonction amies d'une classe template. Jusque là il n'y a pas de souci.

Pour être précis, j'avais compris que la différence entre le code original et la correction apporté par Jean-Marc vient du fait que dans le premier cas on a une fonction template amie de la classe template alors que dans le second cas on a une fonction amie de cette classe template et qu'il n'y a pas de manière de déclarer une telle fonction dans la classe et de la définir en dehors.
Est-ce que ma compréhension est bonne ?

Citation:

---

Envoyé par Flob90

Sortir la fonction c'est ce qu'avait fait l'op, et il n'avait pas utiliser friend car il n'avait pas besoin d'accéder à la classe. Cependant ici, le frien est obligatoire pour avoir une fonction bel et bien déclaré.

---

Si la fonction (enfin le template de fonction) était bien friend dans le code original..

J'ai vraiment pas le temps... Le code de l'OP fonctionne si on vire les templates. Ceux qui comprennent comment http://en.wikipedia.org/wiki/Barton-Nackman_trick fonctionne devraient etre capables d'expliquer le probleme et la solution en detail.

(Si il n'y a pas de reponses convenables, m'envoyer un mail dans 15 j. Avant je risque de l'oublier)

Citation:

---

Envoyé par Jean-Marc.Bourguet

J'ai vraiment pas le temps... Le code de l'OP fonctionne si on vire les templates. Ceux qui comprennent comment http://en.wikipedia.org/wiki/Barton-Nackman_trick fonctionne devraient etre capables d'expliquer le probleme et la solution en detail.

---

Merci. En fait ça réponds à ma question et confirme bien ce que j'avais cru comprendre.

Flob90, en relisant ta seconde intervention de manière plus attentive (et surtout en étant plus réveillé aprs quelques cafés), je viens de comprendre ce que tu cherches à expliquer. Le but est bien de remplacer une fonction template par une fonction non-template.

PS : promis j'arrête de répondre le matin avant de prendre mon premier café. Comme ça je percuterais peut être sur les réponses qui ont été faites.

Si l'aspect fonction non instantiation de template/instantiation de template semble clair (j'avais survolle un peu trop rapidement quand j'ai repondu ce matin), il me semble qu'un point qui risque de ne pas etre clair pour tout le monde est pourquoi ici une instantiation d'un template de fonctions ne permet pas l'utilisation de conversion implicite. (Je ne suis pas sur que ce soit aborde dans la page de Wikipedia). Si c'est bien le cas et que personne ne l'eclaire d'ici la, relancez moi dans 15 j, je risque de n'avoir pas le temps et d'oublier d'ici la.

Une autre ressource ou est présenté ceci est le Meyers, un des items traitant des templates.

En effet le code de l'op utilisait aussi friend (lu trop vite), mais ca fonction était quand même template, ce qu'il ne faut pas. Je vais essayer de reformuler ce que j'ai dit (et de préciser un peu).

Pour comprendre le pourquoi il faut comprendre comment le compilateur résout l'appel à une méthode

Dans un premier temps il regarde si une fonction a été déclaré (pour savoir ou il regarde et dans quel ordre cf name lookup, des articles sur GotW notamment, ou dans la norme pour le détail), si une classe template a été déclaré avant, alors il vérifie aussi les fonction déclaré avec cette classe (dedans et amie), mais juste les fonctions de cette classe, pas les fonctions template. Si une fonction correspond il regarde alors si les paramètre sont bon (système des surcharges) si non il test les possibilités de conversion. Si il n'y a toujours pas de fonctions qui correspondent il regarde les fonction template et essaye de matcher les paramètre, si il y arrive il déclare la fonction correspondante et l'utilise, mais les paramètre doivent parfaitement matcher, ce qui interdit d'éventuelle conversion.

Il est donc important que la fonction soit déclaré, ce qui est le cas avec une fonction d'une classe template (dés qu'une classe réel aura été déclaré d'après le modèle, ie dés qu'on va s'en servir généralement), mais pas avec une fonction libre template. Le fait que la fonction doivent être libre (et non membre) est aussi lié aux conversion implicites (pour permettre les appels du type 2+monType), donc la seul possibilité pour insérer la fonction dans la classe (pour qu'elle soit déclaré quand on l'utilisera) est d'utiliser l'amitié.

Rapidement, le name lookup est l'ensemble des règle qui précise ou sont rechercher les noms des fonctions/méthodes lors des appels. Pour faire simple en premier le compilateur regarde dans les namespace des type des variables passé en paramètre (et dans la classe si l'on appel sur un objet). Puis il remonte progressivement les namespace jusqu'au global. Un autre point est que le compilateur s'arrête de chercher dés qu'il atteint un phase ou il y a des noms qui correspondent, si à cette étapes il n'y a pas moyen de faire correspondre les paramètre alors vous aurez une erreur de compilation (même si une fonction correspond bien dans le namespace supérieur).

Je vais essayer de répondre à la question laissé en suspend par Jean-Marc Bourguet (ma réponse sera peut-être incomplète)

Citation:

---

pourquoi ici une instanciation d'un template de fonctions ne permet pas l'utilisation de conversion implicite.

---

Le compilateur ne peut pas procéder à des conversion implicite à partir du template car il ne sait pas quel template choisir.

Code:

---

1 2 3 4 5

template<class T> void foo(T, T) {}   foo(0, 0.f); //foo<int> ou foo<float> ?

---

Ce n'est pas le code de l'op mais c'est exactement la même chose (operator+<MonType<T> > ou operator+<int> ?)
Si vous lui indiqué le type à utiliser alors pas de problème :

Code:

---

foo<float>(0, 0.f);

---

<Petit HS>
Pour donner un autre exemple ou ce mécanisme est important est lors de la création de constructeur de copie "généralisé" pour une classe template (ou d'opérateur d'affectation). Au mécanisme décrit au-dessus s'ajoute une chose pour les constructeur et fonction spécial du même genre (destructeur et opérateur d'affectation). Si la méthode recherchée est un constructeur par défaut, le compilateur va déjà regardé si vous n'en avez pas déclaré un, si ce n'est pas le cas il regarde si il peu en générer un (cf norme pour les conditions nécessaire, en gros les membres doivent avoir un constructeur par défaut et les classes de base aussi), si c'est le cas il le déclare et l'appel.

Il va donc y avoir un problème si votre classe est template, que le compilateur peut générer le constructeur de copie et que vous voulez redéfinir un constructeur de copie "généralisé" (ie qui permet de copier depuis les autre classes basé sur ce modèle). L'idée est de faire ceci :

Code:

---

1 2 3 4 5 6 7 8 9

template<class T> struct A { template<class T> A(A<T>&) {/*code*/} }; //A première vue tout est bon, sauf que si vous tentez d'appeler le constrcuteur de copie normal A<T1> a1; A<T1> a2(a1); //en vous attendant à utiliser votre constructeur template, vous allez avoir une surprise, car le mécanisme fait que le compilateur ne va pas voir de constructeur déclaré et va donc décider (comme il le peut) d'en générer un tout seul, résultat : pas ce que vous vouliez.

---

C'est un autre exemple où ce mécanisme nous oblige à la prudence (surtout que là il n'y aura pas d'erreur de compilation) et à ne pas oublier de déclaré aussi notre propre constructeur de copie.
</HS>

Petite rectification de mon post précédent, les conversions implicites sont tentées après avoir testé les templates. Ce qui ne change rien au problème.