Discussion :

[yan]

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

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

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

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 :

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

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 :

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

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 :

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

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

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

[N i h i l]

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

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

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 :

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

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

Oui, ou

Code :

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

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 :

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

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

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

fonctionne très bien.

[yan]

Ok.
Je comprend mieux.