Class dans une Class

j essaie de me familiariser avec cette structure. Voici quelques lignes de code tres simples qui, malheureusement se soldent par le message:

error C2661: 'Vector<double>::Vector<double>' : no overloaded function takes 2 parameters
Error executing cl.exe. :?

Voici le code:


template <class T>
class Vector {
public:

template<class U,class T>

class SVector:public Vector<T>
{
public:
SVector(const size_t NRows_, const T& aScal){}
~SVector(){}
};

template<class U>
Vector(const size_t NRows_, const T& aScal)
{
Vector<T>::SVector<U,T>* aVector;
aVector=new SVector<U,T>(NRows_, aScal);
}

~Vector(){}
};


Et le main


void main()
{
Vector<double> aVector(2,1.5);
}

Voila si quelqu un peut m 'aider ca serait super sympa :)

la class vector ne posséde pas de constructeur a deux arguments svector oui

le probleme de vient pas de ta 'sous classe' mais de ton constructeur template ... il n'est apparement pas pris en compte.

class SVector:public Vector<T>

=> n'oublie pas qu'un Vector va être construit pour tout SVector construit ... fait attention a ne pas tourner en rond

int main pas void main

Code:

---

1 2 3 4 5

template<class U,class T>   class SVector:public Vector<T> {

---

=> sémantiquement, T est déjà défini, donc :

Code:

---

1 2 3 4 5

template<class U>   class SVector:public Vector<T> {

---

pourquoi ne définit tu pas qq chose comme ca :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <typename U, typename T> class Vector { public: class SVector : public Vector<U, T> { ... }; ... };

---

hegros => Vector(const size_t NRows_, const T& aScal)
reveille toi :p

Citation:

---

hegros => Vector(const size_t NRows_, const T& aScal)

---

:oops:

Merci BlackGoddess pour ta reponse mais je cherche veritablement a ne pas changer le type de Vector. Je ne souhaite pas qu il depende de 2 templates.

J ai tente de ne declarer que class U pour la definition de SVector. Mais c est pire car :Vector<T> n a plus de sens. je ne crois pas qu il y ait redondance.

Le but de la class SVector a pour but de me permettre de definir le produit d un Vector de type T avec un Scalaire de type U.
Tout le reste de la class Vector n a besoin que de type T

Citation:

---

Envoyé par BlackGoddess

le probleme de vient pas de ta 'sous classe' mais de ton constructeur template ... il n'est apparement pas pris en compte.

class SVector:public Vector<T>

=> n'oublie pas qu'un Vector va être construit pour tout SVector construit ... fait attention a ne pas tourner en rond

int main pas void main

Code:

---

1 2 3 4 5

template<class U,class T>   class SVector:public Vector<T> {

---

=> sémantiquement, T est déjà défini, donc :

Code:

---

1 2 3 4 5

template<class U>   class SVector:public Vector<T> {

---

pourquoi ne définit tu pas qq chose comme ca :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <typename U, typename T> class Vector { public: class SVector : public Vector<U, T> { ... }; ... };

---

---

Code:

---

1 2 3

Vector<T>::SVector<U,T>* aVector; aVector=new SVector<U,T>(NRows_, aScal);

---

tu ne compte pas porter de type SVector<> dans ton Vector ?

si c'est le cas, tu devras bien avoir une propriété SVector<U, V>* var;
donc ton Vector devra avoir un paramètre template U pour pouvoir porter le type...

En effet ce que je veux faire c est Scal (U)* Vecteur (T)

et que donc
{ int a=2;
Vector<double> aVector(2,3.25);
Vector<int> bVector;
bVector=a*aVector
}



ce que je veux faire c est une methode subtile pour ne pas avoir a definir
template< class U, class V> pour la class Vector.

Citation:

---

Envoyé par BlackGoddess

Code:

---

1 2 3

Vector<T>::SVector<U,T>* aVector; aVector=new SVector<U,T>(NRows_, aScal);

---

tu ne compte pas porter de type SVector<> dans ton Vector ?

si c'est le cas, tu devras bien avoir une propriété SVector<U, V>* var;
donc ton Vector devra avoir un paramètre template U pour pouvoir porter le type...

---

d'apres ce que j'ai compris ce dont je suis pas sur ...)
ce sont tes operateurs qui doivent alors etre template, pas un eventuel contenu ?

oui exact
mais plus que ca je cherche a rendre executable une synthaxe que j ai vu dans QANTLIB. Le but la c est que le constructor de vector soit accessible.

Citation:

---

Envoyé par BlackGoddess

d'apres ce que j'ai compris ce dont je suis pas sur ...)
ce sont tes operateurs qui doivent alors etre template, pas un eventuel contenu ?

---

Code:

---

1 2 3 4 5 6

template<class U> Vector(const size_t NRows_, const T& aScal) { Vector<T>::SVector<U,T>* aVector; aVector=new SVector<U,T>(NRows_, aScal); }

---

Je ne comprend pas cette partie du code :

1- c'est un membre template de classe template, mais le parametre U n'est pas utilisé dans les arguments de la ligne de commande
2- Pour chaque Vector construit ou construit un SVector qui herite de Vector ?
est-ce bien raisonnable ? quel constructeur de Vector penses-tu utiliser ?
n'en faudrait-il pas un sans arguments ?

Code:

---

1 2 3 4 5 6 7

template<class U,class T> class SVector:public Vector<T> { public: SVector(const size_t NRows_, const T& aScal){} ~SVector(){} };

---

pourquoi repeter le T ici ?
soit c'est toujours le meme que celaui de la classe imbriquante et alors il est inutile, soit s'en est un autre et alors il cache le precedent... et le nom est mal choisi et trompeur...

Gandalf =>Cette structure est bien volonatire
je ne veux pas avoir recours a un heritage simple et declarer Vector de U et T.

Le but du jeu est de faire compiler en gardant le format class de class
je sais que je ne sus pas loin car j ai deja vu uns structure similaire.


Pour Simplifier, je cherche a ce que

template <class T>
class Vector {

public:

template<class U, class T>
class SVector:public Vector<T>{
public:
SVector(const size_t NRows_, const T& aScal){}
~SVector(){}
};

template<class U>
Vector(const size_t NRows_, const T& aScal){}

};

compile ce qui ne st pas le cas
Je repete je veux garder cette structure

Citation:

---

Envoyé par Gandalf

Code:

---

1 2 3 4 5 6

template<class U> Vector(const size_t NRows_, const T& aScal) { Vector<T>::SVector<U,T>* aVector; aVector=new SVector<U,T>(NRows_, aScal); }

---

Je ne comprend pas cette partie du code :

1- c'est un membre template de classe template, mais le parametre U n'est pas utilisé dans les arguments de la ligne de commande
2- Pour chaque Vector construit ou construit un SVector qui herite de Vector ?
est-ce bien raisonnable ? quel constructeur de Vector penses-tu utiliser ?
n'en faudrait-il pas un sans arguments ?

Code:

---

1 2 3 4 5 6 7

template<class U,class T> class SVector:public Vector<T> { public: SVector(const size_t NRows_, const T& aScal){} ~SVector(){} };

---

pourquoi repeter le T ici ?
soit c'est toujours le meme que celaui de la classe imbriquante et alors il est inutile, soit s'en est un autre et alors il cache le precedent... et le nom est mal choisi et trompeur...

---

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

#include <stdio.h>   template <class T> class Vector { public:   template<class U,class T>   class SVector:public Vector<T> { public: SVector(const size_t NRows_, const T& aScal) {} ~SVector(){} };   Vector() {}   template<class U> Vector(const size_t NRows_, const T& aScal,U toto) { Vector<T>::SVector<U,T>* aVector; aVector=new SVector<U,T>(NRows_, aScal); }   ~Vector(){} };       int main() { Vector<double> aVector( 2, 1.5, 5.0); }

---

Voila une version qui compile sur ma plateforme...

les modifications :
1- Le constructeur template de Vector prend un argument supplémentaire pour indiquer quel constructeur utiliser (resoudre U - sinon le compilo n'a pas l'idée d'utiliser un constructeur template... en effet le <double> après vector se rapporte à T et non à U...


2- Ajout d'un constructeur sans arguement à Vector, en effect comme il y a un constructeur avec argument, le constructeur sans arguments par defaut est 'caché' or c'est celui qu'utilise SVector puisqu'aucun autre n'est indiqué...

Citation:

---

Envoyé par Math75

Gandalf =>Cette structure est bien volonatire
je ne veux pas avoir recours a un heritage simple et declarer Vector de U et T.

Le but du jeu est de faire compiler en gardant le format class de class
je sais que je ne sus pas loin car j ai deja vu uns structure similaire.


Pour Simplifier, je cherche a ce que

template <class T>
class Vector {

public:

template<class U, class T>
class SVector:public Vector<T>{
public:
SVector(const size_t NRows_, const T& aScal){}
~SVector(){}
};

template<class U>
Vector(const size_t NRows_, const T& aScal){}

};

compile ce qui ne st pas le cas
Je repete je veux garder cette structure

---

Je ne remets pas en cause ta structure, mais au contraire les manques de ton code...

regarde ma réponse precedente...

... et change le T de SVector : il ne peut t'apporter que des ennuis (appelle le V par exemple)

On y est presque et merci pour cette reponse deja tres satisfaisante
En effet ca compile.
Mais je cherche a rendre intuitif l utilisation de Vector

en fait, tout cet artifice a pour but de permettre:

Vector<T> operator * (const U & aScal);

dans la classe Vector<T>

n y a t il pas d autre moyen que de rajoute U toto?
NB j avais mis le constructeur vide.

Citation:

---

Envoyé par Gandalf

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

#include <stdio.h>   template <class T> class Vector { public:   template<class U,class T>   class SVector:public Vector<T> { public: SVector(const size_t NRows_, const T& aScal) {} ~SVector(){} };   Vector() {}   template<class U> Vector(const size_t NRows_, const T& aScal,U toto) { Vector<T>::SVector<U,T>* aVector; aVector=new SVector<U,T>(NRows_, aScal); }   ~Vector(){} };       int main() { Vector<double> aVector( 2, 1.5, 5.0); }

---

Voila une version qui compile sur ma plateforme...

les modifications :
1- Le constructeur template de Vector prend un argument supplémentaire pour indiquer quel constructeur utiliser (resoudre U - sinon le compilo n'a pas l'idée d'utiliser un constructeur template... en effet le <double> après vector se rapporte à T et non à U...


2- Ajout d'un constructeur sans arguement à Vector, en effect comme il y a un constructeur avec argument, le constructeur sans arguments par defaut est 'caché' or c'est celui qu'utilise SVector puisqu'aucun autre n'est indiqué...

---

Citation:

---

Envoyé par Math75

On y est presque et merci pour cette reponse deja tres satisfaisante
En effet ca compile.
Mais je cherche a rendre intuitif l utilisation de Vector

en fait, tout cet artifice a pour but de permettre:

Vector<T> operator * (const U & aScal);

dans la classe Vector<T>

n y a t il pas d autre moyen que de rajoute U toto?
NB j avais mis le constructeur vide.

---

De toute maniere il faut bien que ce U soit resolu, non ?
or je ne connais que deux maniere de le resoudre, soit un des arguments de la fonction est de type U (ce que j'ai fait) soit on ajoute <> avec le type en question, mais cette forme ne semble pas marcher avec les constructeurs... peut-etre cela marche-t-il avec les methodes ?

Ce que tu fais ne marche à mon avis pas :

Code:

---

Vector<T> operator * (const U & aScal);

---

Le U ici sera il le meme que pour le constructeur ?
Ici le problème ne se pose pas de la meme maniere que pour le constructeur puisque un des arguments est bien de type U...

Pense bien au cas du T de SVector... ne l'oublie pas, car il reste un piege dangereux...

je ne comprends toujours pas pourquoi tu veux garder des paramètres templates durant toute la vie de ton objet alors qu'ils ne serviront qu'aux opérateurs ... pourquoie ne pas mettre de paramètre template U qu'a tes opérateurs ?

Citation:

---

en fait, tout cet artifice a pour but de permettre:
Vector<T> operator * (const U & aScal);

---

J'ai dû louper un truc mais je pose quand même la question : pourquoi est-ce que ceci ne suffirait pas :?:

Code:

---

1 2	template <class T, class U> Vector<T> operator *(const Vector<T>& v, const U& u);

---

EDIT : ouf on dirait que je suis pas le seul à avoir loupé un truc :)

BlackGoddess=>concetement ca donnerai quoi

Citation:

---

Envoyé par BlackGoddess

je ne comprends toujours pas pourquoi tu veux garder des paramètres templates durant toute la vie de ton objet alors qu'ils ne serviront qu'aux opérateurs ... pourquoie ne pas mettre de paramètre template U qu'a tes opérateurs ?

---

public:

....

template<class U, class T>
class SVector:public Vector<T>{
public:
SVector(const size_t NRows_, const T& aScal){
NRows=NRows_;
Values = new T[NRows];
(size_t i=0;i<NRows;i++) (*this)(i) = aScal;
Vector<T> operator * (const U & aScal);
}
~SVector(){}
};
...

Vector<T> operator * (const U & aScal);

pose probleme. Je dois avouer tres humblement que ca ne compile pas
Tu declarerais comment alors?

Citation:

---

Envoyé par Gandalf

Citation:

---

Envoyé par Math75

On y est presque et merci pour cette reponse deja tres satisfaisante
En effet ca compile.
Mais je cherche a rendre intuitif l utilisation de Vector

en fait, tout cet artifice a pour but de permettre:

Vector<T> operator * (const U & aScal);

dans la classe Vector<T>

n y a t il pas d autre moyen que de rajoute U toto?
NB j avais mis le constructeur vide.

---

De toute maniere il faut bien que ce U soit resolu, non ?
or je ne connais que deux maniere de le resoudre, soit un des arguments de la fonction est de type U (ce que j'ai fait) soit on ajoute <> avec le type en question, mais cette forme ne semble pas marcher avec les constructeurs... peut-etre cela marche-t-il avec les methodes ?

Ce que tu fais ne marche à mon avis pas :

Code:

---

Vector<T> operator * (const U & aScal);

---

Le U ici sera il le meme que pour le constructeur ?
Ici le problème ne se pose pas de la meme maniere que pour le constructeur puisque un des arguments est bien de type U...

Pense bien au cas du T de SVector... ne l'oublie pas, car il reste un piege dangereux...

---

Soit en fonction non-membre comme dans mon précédent post, soit en fonction membre comme ceci

Code:

---

1 2 3 4 5 6

template <class T> Vector { // ...   template <class U> Vector<T> operator *(const U& u); };

---

Et bien sûr tu n'as plus besoin de SVector et de toutes ces "bidouilles".

A noter que tu peux avoir des difficultés avec ce genre de code, si tu compiles avec VC6. Dans ce cas, prendre la version non-membre peut régler un éventuel problème de compilation.

je verrais ca comme ca ...
(d'apres ce que j'ai compris que tu voulais)

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

#include <vector> #include <algorithm>   template<typename T> class Vector : public std::vector<T> // pour l'exemple, apres faudrait encapsuler proprement { template <typename Type> class MultValue { private: Type Factor; public: MultValue ( const Type& _Val ) : Factor ( _Val ) { }   int operator ( ) ( Type& elem ) const { return elem * Factor; } };   public:   template<typename Param> Vector<T> operator * (const Param & p) { Vector<T> r; r.reserve(size()); std::transform(begin(), end(), r.begin(), MultValue<Param>(p)); return r; } };   int main() { Vector<int> v, w; w = v*3;   }

---

en effet j ai une version VC6
ce qui explique que ca ne compile pas
c est pourquoi j ai pense a ce strategeme

Citation:

---

Envoyé par Loulou24

Soit en fonction non-membre comme dans mon précédent post, soit en fonction membre comme ceci

Code:

---

1 2 3 4 5 6

template <class T> Vector { // ...   template <class U> Vector<T> operator *(const U& u); };

---

Et bien sûr tu n'as plus besoin de SVector et de toutes ces "bidouilles".

A noter que tu peux avoir des difficultés avec ce genre de code, si tu compiles avec VC6. Dans ce cas, prendre la version non-membre peut régler un éventuel problème de compilation.

---

[pinaillage]

Je pense que MultValue::operator () devrait renvoyer un T plutôt qu'un int, non ?

Sinon pour la multiplication à moindre frais (en terme de lignes de code), je pense qu'on peut s'en tirer avec un std::multiplies et un std::bind2nd, par exemple.

EDIT : Ton opérateur va crasher je pense, il faut soit utiliser resize au lieu de reserve, soit utiliser un back_inserter.

[/pinaillage]

En théorie VC6 n'aime pas les fonctions membres templates de classes templates. En pratique, si tu ne sépares pas la définition de la déclaration, ça devrait compiler. Sinon, comme je l'ai dit le fait de faire de tes opérateurs des fonctions non-membres devrait passer sans problème.

...Et à noter aussi que pour avoir des vecteurs "mathématiques" il existe la classe std::valarray, qui permet entre autres d'effectuer ce genre d'opération.

Par contre je n'arrive pas à la trouver dans mes docs de référence, est-elle bien standard ?

std::valarray est standard. Par contre son implémentation efficace est récente. (oubliez VC6)
Je préfère lorgner du côté de Blitz++ et à termes de boost::ublas.

Les opérations sur des vecteurs se portent beaucoup mieux quand elles sont non membres. Cela permet d'avoir des opérations véritablement commutatives et qui supportent les cast implicites -- en rendant la fonction membre template, ce n'est plus forcément utile.

(Sinon un code compliqué que je n'ai pas cherché à approfondir.)

Loulou24
=>
en effet on peut remplacer class MultValue par std::multiplies, je ne conaissais pas ...

pour l'erreur du int, c'est parce que j'ai recopié betement mon exemple des MSDN qui faisait exactement cela, mais qui contenait aussi cette erreur.