Discussion :

[omaanu]

Bonjour,

J'ai deux classes dérivant l'une de l'autre, portant le même nom (MyClass), mais définies dans deux namespaces différents.
Une fonction foo() est définie dans ma classe de base, et surchargée dans ma sous classe (prototype différent).
Cette dernière (dans la sous classe) doit appeler celle de la classe de base.

Mais c'est alors que commence mon souci : je suis obligé d'être plus qu'explicite pour éviter une erreur de compilation de type "no matching function".

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
 
namespace nspaceA
{
	class MyClass
	{
		protected:
			int foo(int n);
	};
 
	int MyClass::foo(int n)
	{
		return n+1;
	}	
}
 
namespace nspaceB
{
	class MyClass : protected nspaceA::MyClass
	{
	  public:
		 void foo();
	};
 
	void MyClass::foo()
	{
		int i=0;	
 
		//i = foo(i); // => error: no matching function for call to 'nspaceB::MyClass::foo(int&)'
		i = nspaceA::MyClass::foo(i); // solution OK, mais trop explicite à mon sens
	}   
}

Ma solution n'est du coup pas très élégante. Si j'avais du polymorphisme à réaliser, ça serait d'ailleurs il me semble un point bloquant.
Et puis c'est un comportement que je trouve étrange, d'autant plus qu'un renommage de la fonction foo() de la classe de base (en mettons fooA()) suffit à faire accepter l'appel sans avoir à préciser le namespace nspaceA::MyClass:: devant.

Quelqu'un saurait il m'expliquer pourquoi, et s'il y a une alternative à ma solution ?

Merci à vous.

[stendhal666]

Eh bien... J'avoue ne pas trop comprendre tes scrupules à ajouter le nom du namespace à foo quand par ailleurs tu décides de donner à deux classes d'une hiérarchie le même nom et à les placer dans deux namespaces différents. Pour une solution plus élégante, je verrais bien, tout simplement, deux classes de noms différents dans un même namespace!

Avec tes choix initiaux la seule solution un peu plus élégante que je verrais serait de placer:

Code :

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

using nspaceA::foo;

quelque part dans le fichier de la classe heritière.

[omaanu]

Merci Stendhal666 pour ta réponse.

C'est vrai que de choisir le même nom pour ces deux classes ne parait pas très judicieux...

Je reprends en fait le travail d'une autre personne qui, elle, a fait ce choix. Ce choix se comprend également dans le fait de vouloir spécialiser l'objet de base pour l'utiliser dans un système différent, mais avec au final un comportement identique (ce n'est grosso modo qu'une adaptation d'API). D'où la volonté de garder le même nom, mais de changer de namespace.

Après, ce qui me gène dans le fait d'avoir à spécifier le namespace, c'est d'empêcher par cette précision l'utilisation éventuelle (si on le souhaitait) d'une redéfinition de cette fonction foo() dans la classe fille...

[Ehonn]

Avec tes choix initiaux la seule solution un peu plus élégante que je verrais serait de placer:

Code :

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

using nspaceA::foo;

quelque part dans le fichier de la classe heritière.

Juste avant l'appel de foo (comme dans l’idiome copy-and-swap).

[Bousk]

Je vois pas trop ce qui te dérange, surtout que t'as pas le choix.

Code :

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

1
2
struct A { void foo() {} };
struct B : A { void foo() {A::foo();} };

Que tu hérites de A, ou de Toto::Namespace::BV2::AAA::.....::A, il faut juste écrire le nom du "truc" dont tu hérites.

Code :

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

1
2
namespace TOTO { struct A { void foo() {} }; }
struct B : TOTO::A { typedef TOTO::A BaseType; void foo() {BaseType::foo();} };

[omaanu]

Merci à vous pour vos réponses.
Si je veux redéfinir la fonction foo() de ma classe de base dans ma classe "fille", et l'utiliser dans cette dernière, je serai alors obligé de lors son appel de supprimer le "basetype" nspaceA::MyClass:: qui la précède. Cela manque un peu je trouve de flexibilité que donne ordinairemeent le C++. Je pensais qu'il y avait un moyen que le compilateur puisse automatiquement chercher la définition de foo() dans la classe de base, à moins qu'elle ne soit redéfinie dans la classe dérivée (auquel cas il prenait cette dernière).
Mais je dois probablement en demander trop ;-)

[ternel]

C'est virtual qui permettra cela, à condition de manipuler une référence (ou un pointeur)