Discussion :

[Shpounz]

Bonjour à tous, je suis nouveau sur ce genre de forum d'habitude je me contente de lire pour résoudre mes problèmes mais cette fois je bloque .

En gros je suis en train de faire un projet dans lequel je dois avoir une classe abstraite et deux classes filles( qui héritent donc de cette classe abstraite) , ce que j'ai fait dans un premier temps c'est définir les classes filles et maintenant que je dois tout lier ca ne marche pas du tout :/ (je me rend compte que j'aurai du faire l'inverse). Mon problème c'est que quand je fais l'héritage mon compilo me dit que la classe fille est abstraite et donc a chaque méthode ou j'ai en paramètre un objet de ma classe fille une erreur apparait (car on ne peut pas instancier des objets d'une classe abstraite). Auriez-vous une idée de ce que je fais mal ? Je pense que c'est mieux si vous voulez voir mon code de me le demander car ici ce serait trop long :/.

Merci d'avance

[Shpounz]

j'ai trouvé quelque chose, en testant une par une mes méthodes virtuelles pures, je suis tombé sur celles qui faisait faux bond.

classe abstraite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Min_Max{ //la classe de base
 
public:
 
 
	virtual void swap (Min_Max&  , Min_Max& ){} // si je met en pure ca va pas
	virtual void swap (Min_Max& ){}
	virtual bool empty() const = 0;
	virtual std::size_t size () const = 0;
	virtual std::size_t max_size() const = 0;
	virtual bool operator==(const Min_Max& ){}
	virtual bool operator!=(const Min_Max& ){}

une des classes filles

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
class MinMax_Tab  : public Min_Max<T,sizemax>{
 
private:
 
	std::size_t _size = 0;
	int Begin = 0;
	int End = 0;
	T *info = new T[sizemax+1];
 
 
public:
 
	void swap (MinMax_Tab& a , MinMax_Tab& b) //swap(a,b)
    	{
			std::swap(a.Begin , b.Begin);
			std::swap(a.End , b.End);
			std::swap(a._size , b._size);
			std::swap(a.info , b.info);
		}
 
	void swap (MinMax_Tab& b) //a.swap(b)
    	{
		swap(*this,b);
	}
 
 
 
 
	bool operator==(const MinMax_Tab& rv) 
	{
		bool ok = 1;
		if ( this->_size == rv._size)
		{
			tabconst_iterator i = rv.begin();
			tabconst_iterator j = this->begin();
			while ( i != rv.end() && j != this->begin() && ok == 1)
			{
				if (*i != *j)
				{
					ok = 0;
				}
				++i;
				++j;
			}
		}
		else
		{
			ok = 0;
		}
		return ok;
 
	}
 
	bool operator!=(const MinMax_Tab& rv) 
	{
		return !(*this==rv);
	}

en gros ca me dit que l'objet de MinMax_tab que je crée est impossible a créer car MinMax_Tab est une classe abstraite, par contre si j'enleve le = 0 apres la définition de swap et des opérateurs dans le code de la classe mère, tout compile parfait , j'ai l'impression que c'est parce que je n'ai pas les mêmes types de données en parametre donc il compte ca comme de l'overloading et pas de l'overriding, ca m'embête :/

PS ici le code de mes méthodes n'est pas forcément important c'est surtout les déclarations qui sont importantes.

[koala01]

Salut,

En gros, il faut savoir un truc: le compilateur a horreur du vide...

Si tu déclares une fonction virtuelle comme étant pure ( == sans implémentation) dans la classe mère, le compilateur saura qu'elle existe, ce qui est déjà pas mal mais, si tu ne fournis pas une implémentation pour cette fonction dans les classes qui en dérivent, ben... le compilateur ne saura pas fournir lui-même l'implémentation de cette fonction.

Et, du coup, la fonction sera considérée comme... virtuelle pure dans la classe dérivée.

Et comme le compilateur a horreur du vide et que ca ferait vraiment désordre s'il permettait la création d'une instance de classe abstraite, mais que, du fait de la fonction virtuelle pure, la classe dérivée est aussi considérée comme abstraite, le compilateur n'a pas d'autre choix que de t'engueuler parce que tu essaye d'instancier une classe abstraite en créant une instance de la classe dérivée.

C'est aussi simple que cela

La solution, elle est toute simple: toutes les fonctions virtuelles pures de ta classe de base doivent être implémentées au niveau des classes dérivées concrètes.

Ceci étant dit, j'aimerais comprendre comment tu passe d'une classe non template (avec des fonctions virtuelles pures) Min_Max un héritage où la classe mère est une classe template Min_Max<T,sizemax>, car l'un dans l'autre, il y a une des classes (à vue de nez, j'aurais même tendance à dire deux: la classe mère non template et la classe la MinMax_Tab) qui est totalement inutile

[Shpounz]

pour la classe fille le template est une ligne plus haut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 <typename T, std::size_t sizemax>

ce que je ne comprends pas c'est pourquoi le compilo ne prend pas mon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void swap (MinMax_Tab& a , MinMax_Tab& b)

pour mon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

virtual void swap (Min_Max&  , Min_Max& )

je veux dire MinMax_Tab hérite de Min_Max donc tout les objets MinMax_Tab sont aussi de objets de Min_Max...

[Invité]

Bonsoir,

pour la classe fille le template est une ligne plus haut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 <typename T, std::size_t sizemax>

N'hésite pas à éditer ton message.

je veux dire MinMax_Tab hérite de Min_Max donc tout les objets MinMax_Tab sont aussi de objets de Min_Max...

Ceci est vrai lorsque tu appelles un fonction, c'est le Principe de Substitution de Liskov.

Mais ici, tu redéfinis ta fonction membre virtuelle dans la classe dérivée.

ce que je ne comprends pas c'est pourquoi le compilo ne prend pas mon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void swap (MinMax_Tab& a , MinMax_Tab& b)

pour mon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

virtual void swap (Min_Max&  , Min_Max& )

Et pour ce faire, tu dois avoir exactement la même signature, sinon tu ne redéfinis pas la fonction, mais la masques. Le mot-clé override est justement là pour éviter ce problème.
Ceci à une exception près : le type de retour covariant qui tire justement parti de l'héritage, mais il n'est possible que sur le type de retour de la fonction et PAS ses entrées.

• Intéresse-toi au CRTP.
• Qualifie tes operator d'(in)égalité de const : ils ne modifient pas l'instance.
• T *info = new T[sizemax+1]; : utilise std::vector à la place.

[Shpounz]

si je comprends bien, MinMax_Circ n'est pas un Min_Max ( je ne respecte pas le principe de substitution) mais je ne vois pas en quoi ce n'est pas un bon héritage, j'ai essayé les masques ca ne me permet toujours pas d'override par contre mais certain warnings disparaissent ("was hiden ..."). Quand je met le mot clef override apres mes méthodes swap et mes redefinitions d'opérateurs == et != le compilateur me met un message d'erreur comme quoi je n'override rien du tout. C'est a s'y prendre la tête je pensais pourtant faire ce qu'il y a de plus simple en terme d'héritage si j'hérite de Min_Max les objets de la classe dont j'herite sont aussi des objets de type Min_Max ... appraement pas

Merci en tout cas de vous donner le mal de m'expliquer

Ah et pour std::vector l'énoncé impose que je laisse l'array sous cette forme

[koala01]

Le fait est que l'héritage est une pratique issue du paradigme OO (Orienté Objet : qui permet la substituabilité aux termes du principe de substitution de Liskov) alors que les template, c'est une pratique issue du paradigme générique.


Or, si les deux paradigmes se marient très bien, il est au final rarement nécessaire de mélanger les deux:

Tu créeras une hiérarchie de classes, le plus souvent, parce que tu souhaite, à un moment donné, "mélanger" des éléments de type (dérivé) différents dans dans une collection quelconque d'objets connus pour être du "type de base", ce qui induira une restriction majeure: tu nous pourra les utiliser que comme s'il s'agissait... du type de base; le polymorphisme (d'inclusion) et -- le cas échéant -- le double dispatch étant là pour te permettre d'adapter le comportement au type réel de l'objet (la classe la plus dérivée) que tu manipule à chaque fois.

C'est ce que l'on appelle le polymorphisme d'inclusion. Et c'est un polymorphisme résolu essentiellement à l'exécution du programme

Les templates nous autorisent une autre forme de polymorphisme, appelée polymorphisme paramétrique car on part du principe que si on ne sait pas exactement "quel type de donnée" on va manipuler, on sait en revanche très bien "comment on va les manipuler".

Ce genre de polymorphisme nous permet de n'écrire le code qu'une seul fois pour qu'il soit récupéré pour chaque type de donnée qui sera "compatible" avec les manipulations que l'on a prévues de faire (qui supporte les opérations que l'on a prévues d'imposer dans nos comportements).

C'est un style de polymorphisme qui s'évalue essentiellement à la compilation; mais qui ne nous autorise normalement pas à créer une collection d'objets disparates: tu auras tes Min_Max<char, 2> d'un coté et tes Min_Max<double,6> de l'autre (parce que ce sont des types de données totalement différents, bien que tu puisse les manipuler de manière homogène). Ce qui est cohérent, parce que tu ne veux sans doute pas commencer à mélanger les deux dans ta logique.

Alors, bien sur, il y a des "cas à part", dans lesquels il peut être intéressant de mélanger le paradigme orienté objet et le paradigme générique. Ce sont généralement des cas dans lesquels on souhaite avoir recours au duck typing (si je vois un oiseau qui marche comme un canard, qui nage comme un canard et qui cancane comme un canard, c'est que je regarde un canard).

Et je ne crois sincèrement pas que tu sois dans une situation dans laquelle tu aies besoin de ce genre de typage. A vrai dire, je ne suis pas sur que tu aies besoin de l'héritage, car de simple alias de types suffisent amplement à l'utilisation de Min_Max<T,sizemax> et que, comme je te l'ai dit, tu ne veux sans doute pas mélanger des Min_Max<char, 2> et des Min_Max<double,6>.

Maintenant, il est clair que je peux me tromper, ne connaissant pas du tout l'exercice auquel tu es confronté. Mais, si c'est un exercice qui t'oblige à prévoir l'héritage depuis une classe abstraite, j'aurais largement tendance à sa qualité conceptuelle en cause

EDIT: pour ton problème de fonction swap: transforme la fonction prenant deux arguments en fonction libre, et inverse ta logique: void swap(Min_Max &) (fonction membre) fait le boulot, void swap(Min_Max & , Min_Max &) (fonction libre) appelle la fonction membre sur son premier paramètre en lui fournissant le deuxième comme paramètre

[Shpounz]

EDIT: pour ton problème de fonction swap: transforme la fonction prenant deux arguments en fonction libre, et inverse ta logique: void swap(Min_Max &) (fonction membre) fait le boulot, void swap(Min_Max & , Min_Max &) (fonction libre) appelle la fonction membre sur son premier paramètre en lui fournissant le deuxième comme paramètre

je viens d'essayer et le problème persiste, je crois que je vais simplement ne pas mettre cette fonction comme virtuelle pure mais simplement comme vitruelle j'imagine que ca fera quand même le taf .... je ne comprends pas ce que je fais de mal ca me frustre x)

[koala01]

Fais ce que je te dis! Si tu veux les deux versions de la fonction, tu dois avoir:

• une fonction membre virtuelle qui ne prend qu'un seul paramètre et
• une fonction libre (non virtuelle, forcément) qui prend deux paramètres

ce qui devrait se traduire en code sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class Min_Max{
public:
    virtual void swap(Min_Max & other)/* = 0*/;
};
void swap(Min_Max & a, Min_Max & b){
    a.swap(b);
}

Et, comme cela, tu pourras tout aussi bien envisager d'avoir un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int main(){
    Min_Max m1;
    Min_Max m2;
    m1.swap(m2);
}

qu'un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int main(){
    Min_Max m1;
    Min_Max m2;
    swap(m1, m2);
}

[Shpounz]

je comprends l'idée mais ca ne me permet toujours pas de régler mon problème, a la base mon problème c'est que si je définis l'une des deux ou même les deux comme virtuelles pures les classes filles qui héritent de Min_Max restent abstraites pour une raison qui m'est inconues encore . Merci de ton aide en tout cas !!!

[koala01]

je comprends l'idée mais ca ne me permet toujours pas de régler mon problème, a la base mon problème c'est que si je définis l'une des deux ou même les deux comme virtuelles pures les classes filles qui héritent de Min_Max restent abstraites pour une raison qui m'est inconues encore . Merci de ton aide en tout cas !!!

Et sur ce point, je t'ai déjà répondu: pour que le compilateur décide qu'une classe dérivée d'une classe abstraite n'est pas abstraite, il faut que toutes les fonctions virtuelles pures soient définies au niveau de la classe dérivées.

Mais, attention! la signature des fonctions virutelle pure doit être scrupuleusement respectée, si bien que, si tu as un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class Base{
public:
    virtual void swap(Base &) = 0 ; // fonction virutelle pure : ==> classe abstraite
 
};

dans ta classe de base, il faut que la classe dérivée propose quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
class Derivee : public Base{
public:
    void swap(Base &) /* override */{  //OK
        /*...*/
    }
    /* KO: signature différente, pas de redéfinition
   void swap(Derivee &){
   }
   */
}

[Shpounz]

en gros ce que tu me dis c'est que ce que j'essaye de faire est impossible :p ?

[koala01]

en gros ce que tu me dis c'est que ce que j'essaye de faire est impossible :p ?

Ben, si tu veux avoir une fonction swap dans la classe dérivée dont les paramètres sont du type de ta classe dérivée, ca ne te dispense pas de fournir l'implémentation de la fonction telle qu'elle est décrite dans la classe de base...

Car il n'y a que si la fonction de la classe de base est définie dans les classes dérivées que tes classes dérivées ne seront pas considérées comme abstraites.

Le seul élément de la fonction qui puisse varier dans une certaine mesure, ce serait le type de retour. on appelle cela le retour covariant

Donc, oui, j'ai l'impression que ce que tu cherches à faire est impossible. Et cela me confirme dans l'idée que l'héritage n'a aucun sens dans le cas présent

[Shpounz]

Donc, oui, j'ai l'impression que ce que tu cherches à faire est impossible. Et cela me confirme dans l'idée que l'héritage n'a aucun sens dans le cas présent

c'est pour ce que j'ai opté pour ne pas mettre le swap en virtuelle pure , etant donné que je n'en ai pas utilité dans la classe fille. L'héritage ici est nécessaire car j'implémente de deux facon différentes le type de conteneur que j'appélle Min_Max , en fait c'est une file a priorité . je dois pouvoir traiter des objets des deux implementation via un ptr de Min_Max.

[koala01]

Mais le fait est qu'une fonction swap ne devrait -- à mon sens -- déjà pas être virtuelle... Alors, tu penses: virtuelle pure!!!

Et si tu n'a pas besoin d'une fonction de la classe mère dans les classes filles, tu as deux solutions: ou bien elle est inutile, et n'a donc aucune raison d'être présente dans la classe mère, ou bien, tu es face à un problème de conception, car l'héritage publique implique que toutes les caractéristiques des classes parent doivent être valides pour les classes dérivées.

Et on en revient donc au même point que là tantôt, quand je te disais que l'héritage était à mon sens inutile

Et tu vas donc commencer à répondre à une question toute simple:

L'héritage ici est nécessaire car j'implémente de deux facon différentes le type de conteneur que j'appélle Min_Max , en fait c'est une file a priorité . je dois pouvoir traiter des objets des deux implementation via un ptr de Min_Max.

Pourquoi l'héritage est-il nécessaire à ton idée

Perso, je verrais bien une implémentation purement générique, basée sur des traits et des politiques, et on n'en parlerait plus

[Shpounz]

Mais le fait est qu'une fonction swap ne devrait -- à mon sens -- déjà pas être virtuelle... Alors, tu penses: virtuelle pure!!!

Et si tu n'a pas besoin d'une fonction de la classe mère dans les classes filles, tu as deux solutions: ou bien elle est inutile, et n'a donc aucune raison d'être présente dans la classe mère, ou bien, tu es face à un problème de conception, car l'héritage publique implique que toutes les caractéristiques des classes parent doivent être valides pour les classes dérivées.

Et on en revient donc au même point que là tantôt, quand je te disais que l'héritage était à mon sens inutile

oui je réalise qu'elle m'est inutile dans la classe mère mais l'énoncé du projet exige que je respecte la norme c++ en ce qui concerne les conteneurs et dans ce cas je suis obligé de mettre le swap... je vais enlever le virtuel oui.

[koala01]

oui je réalise qu'elle m'est inutile dans la classe mère mais l'énoncé du projet exige que je respecte la norme c++ en ce qui concerne les conteneurs et dans ce cas je suis obligé de mettre le swap... je vais enlever le virtuel oui.

Montre moi une fois l'énoncé de ton projet, si tu veux bien ...

[Shpounz]

j'envoie ca sur votre mail : philippe.dunski@hotmail.fr

[koala01]

Merci, mais met le en pièce jointe ici, que tout le monde puisse le lire

Car je crois que tu te laisses abuser par la première ligne de ton énoncé:

Le problème posé consiste à définir une structure de données abstraite

Comme, par la suite, il est clairement stipulé que ce doit être des classes template, ce terme d'abstrait peut -- purement et simplement -- être pris au sens premier du terme : qui ne peut être instanciée telle quelle (sans spécification particulière). Et ca, c'est le cas des classes template, qui attendent de connaitre les paramètre templates utilisés

[Shpounz]

Merci, mais met le en pièce jointe ici, que tout le monde puisse le lire

pas sur que le professeur sois d'accord avec cela je préfères être prudent