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