Discussion :

[Math75]

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

[hegros]

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

[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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
 
template<class U> 
 
class SVector:public Vector<T>
{

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

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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>
  {
    ...
  };
  ...
};

[BlackGoddess]

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

[hegros]

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

[Math75]

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

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
 
template<class U> 
 
class SVector:public Vector<T>
{

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

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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>
  {
    ...
  };
  ...
};

[BlackGoddess]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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...

[Math75]

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.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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...

[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 ?

[Math75]

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.

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 ?

[Gandalf]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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...

[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

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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�...

[Gandalf]

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)

[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.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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�...

[Gandalf]

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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...

[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 ?

[Laurent Gomila]

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

[Math75]

BlackGoddess=>concetement ca donnerai quoi

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 ?

[Math75]

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?

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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...