template et heritage de l'operateur =

Version imprimable

Bonjour.
Histoire de jouer avec les lambda, j'ai voulue créer un système de property comme en C#
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 enum PropertyAccess { G = 1, S = 2, G_S }; template<typename T,PropertyAccess pa = G_S> struct Property { private : //interdit la copie Property<T,pa> & operator=(const Property<T,pa> & ); };
spécialisation pour le GET
Code:

1 2 3 4 5 6 template<typename T> struct Property<T,G> { std::function< T ()> GET; operator T () {return GET();}; };
spécialisation pour le SET
Code:

1 2 3 4 5 6 template<typename T> struct Property< T,S> { std::function< void ( const T &)> SET; void operator = ( const T & t) {SET(t);} };
spécialisation pour le GET et le SET qui me pose problème
Code:

1 2 3 4 5 template<typename T> struct Property<typename T,G_S> : public Property< typename T,S>, Property<typename T,G> { };
Pour que le compilateur trouve l'operateur = je doit réécrire

Code:

void operator = ( const T & t) {SET(t);}

Alors qu'il en hérite de la spécialisation pour le SET :koi:
Visual 2010 et mingw 4.5.2 me font le même problème.

Citation:

Envoyé par yan

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
enum PropertyAccess
{
   G = 1,
   S = 2,
   G_S
 
};
 
// Le = 2 est inutile.
 
template<typename T,PropertyAccess pa = G_S>
struct Property
{
private :
//interdit la copie
        Property<T,pa> & operator=(const Property<T,pa> & );
// La définition est inutile.
};

spécialisation pour le GET et le SET qui me pose problème

Code:

1
2
3
4
5
6
template<typename T>
struct Property<typename T,G_S>
    : public Property< typename T,S>, Property<typename T,G>
{
};
// Ce n'est pas ton vrai code, tu ne m'aides pas.

Pour que le compilateur trouve l'operateur = je doit réécrire

Code:

void operator = ( const T & t) {SET(t);}

Oui, ou

Code:

using Property< T, S >::operator=

La compilation d'une classe template se fait en 2 temps. Dans le premier temps, le compilateur ne cherche pas dans les classes héritées :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
 
int foo() { return 1; }
 
template< typename T > struct B { 
 
int foo() { return 0; }
 
};
 
template< typename T > struct D: B< T > {
 
int bar() { return foo(); }
 
};
 
int main() {
D<int> d; std::cout << d.bar() << "\n";
}

Dans le cas particulier de operator= ; il génére celui par défaut. Avec ton code,

Code:

1
2
3
4
int main() {                                                                                    
  Property< int, G_S > p;
  Property< int, G_S > q= p;
}

fonctionne très bien.

25/02/2011, 09h22
yan

Ok.
Je comprend mieux.
:merci: