Discussion :

[meuns26]

Je travaille sur un bout code ayant besoin de spécialiser un template suivant son nombre de paramètres. Il ne compile pas et il a la "forme" de ce code :

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
 
// NE COMPILE PAS PAS
 
#include <iostream>
using namespace std;
 
template< typename T = void, typename U = void >
struct Dummy
{
	void Hello(T t, U u);
};
 
template< typename T, typename U >
void Dummy< T, U >::Hello(T t, U u)
{
	cout << t << " " << u << endl;
}
 
template< typename T >
struct Dummy< T >
{
	void Hello(T t);
};
 
template< typename T >
void Dummy< T >::Hello(T t)
{
	cout << t << endl;
}
 
template< >
struct Dummy< >
{
	void Hello();
};
 
template< >
void Dummy< >::Hello()
{
	cout << "-" << endl;
}
 
int main(int argc, char** argv)
{
	Dummy< int, double >().Hello(5,0.1);
	Dummy< int >().Hello(5);
	Dummy< >().Hello();
}

Messages de g++ :

main.cpp:64: erreur: template-id `Hello<>' for `void Dummy<void, void>::Hello()' does not match any template declaration
main.cpp:64: erreur: déclaration de fonction invalide

Ces deux autres codes compilent néanmoins très bien.

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
 
// COMPILE...
 
#include <iostream>
using namespace std;
 
template< typename T = void, typename U = void >
struct Dummy
{
	void Hello(T t, U u);
};
 
template< typename T, typename U >
void Dummy< T, U >::Hello(T t, U u)
{
	cout << t << " " << u << endl;
}
 
template< typename T >
struct Dummy< T >
{
	void Hello(T t);
};
 
template< typename T >
void Dummy< T >::Hello(T t)
{
	cout << t << endl;
}
 
int main(int argc, char** argv)
{
	Dummy< int, double >().Hello(5,0.1);
	Dummy< int >().Hello(5);
}

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
 
// COMPILE
#include <iostream>
using namespace std;
 
template< typename T = void, typename U = void >
struct Dummy
{
	void Hello(T t, U u)
	{
		cout << t << " " << u << endl;
	}
};
 
template< typename T >
struct Dummy< T >
{
	void Hello(T t)
	{
		cout << t << endl;
	}
};
 
template< >
struct Dummy< >
{
	void Hello()
	{
		cout << "-" << endl;
	}
};
 
int main(int argc, char** argv)
{
	Dummy< int, double >().Hello(5,0.1);
	Dummy< int >().Hello(5);
	Dummy< >().Hello();
}

Ou est l'erreur dans la spécialisation de Dummy sans paramètre de la première version ?

Merci d'avance

[screetch]

Salut,

ta structure Dummy<void void> est deja entierement specialisee

pour la definition,

Code :

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

1
2
3
4
void Dummy< void, void >::Hello()
{
	cout << "-" << endl;
}

fonctionne.

Si tu places le

Code :

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

template<>

devant, il va s'emmeler les pinceaux. Je ne connais pas la raison profonde de cela (en tous cas je sais pas l'exprimer avec mes mots a moi)

[meuns26]

Ta solution fonctionne mais un nouveau problème est survenu... et le code ne compile plus.
Dummy à besoin de la définition de Crazy et vice versa :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
// NE COMPILE PAS
// Les pointeurs man et woman sont censés être initialisés dans main
 
template< typename T = void, typename U = void >
struct Dummy;
 
/** Crazy template and his specialisations */
template< typename T = void, typename U = void >
struct Crazy
{
	Dummy< T, U >* man;	
	void Hello(T t, U u);
};
 
template< typename T, typename U >
void Crazy< T, U >::Hello(T t, U u)
{
	man->Bingo(t,u);
}
 
template< typename T >
struct Crazy< T >
{
	Dummy< T >* man;
	void Hello(T t);
};
 
template< typename T >
void Crazy< T >::Hello(T t)
{
	man->Bingo(t);
}
 
template< >
struct Crazy< >
{
	Dummy< >* man;
	void Hello();
};
 
void Crazy< >::Hello()
{
	man->Bingo();
}
 
/** Dummy template and his specialisations */
template< typename T, typename U >
struct Dummy
{
	Crazy< T, U >* woman;
	void Hello(T t, U u);
	void Bingo(T t, U u);
};
 
template< typename T, typename U >
void Dummy< T, U >::Hello(T t, U u)
{
	woman->Hello(t,u);
}
 
template< typename T, typename U >
void Dummy< T, U >::Bingo(T t, U u)
{
	// ...
}
 
template< typename T >
struct Dummy< T >
{
	Crazy< T >* woman;
	void Hello(T t);
	void Bingo(T t);
};
 
template< typename T >
void Dummy< T >::Hello(T t)
{
	woman->Hello(t);
}
 
template< typename T >
void Dummy< T >::Bingo(T t)
{
	// ...
}
 
template< >
struct Dummy< >
{
	Crazy< >* woman;
	void Hello();
	void Bingo();
};
 
void Dummy< >::Hello()
{
	woman->Hello();
}
 
void Dummy< >::Bingo()
{
	// ...
}
 
int main(int argc, char** argv)
{
	// ...
}

Messages de g++ :

main.cpp: In member function `void Crazy<void, void>::Hello()':
main.cpp:72: erreur: invalid use of undefined type `struct Dummy<void, void>'
main.cpp:34: erreur: declaration of `struct Dummy<void, void>'

Bien sur il n'y a aucun problème si je compile ceci à la place :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
// NE COMPILE PAS
// Les pointeurs man et woman sont censés être initialisés dans main
 
template< typename T = void, typename U = void >
struct Dummy;
 
/** Crazy template and his specialisations */
template< typename T = void, typename U = void >
struct Crazy
{
	Dummy< T, U >* man;	
	void Hello(T t, U u);
};
 
template< typename T, typename U >
void Crazy< T, U >::Hello(T t, U u)
{
	man->Bingo(t,u);
}
 
template< typename T >
struct Crazy< T >
{
	Dummy< T >* man;
	void Hello(T t);
};
 
template< typename T >
void Crazy< T >::Hello(T t)
{
	man->Bingo(t);
}
 
/** Dummy template and his specialisations */
template< typename T, typename U >
struct Dummy
{
	Crazy< T, U >* woman;
	void Hello(T t, U u);
	void Bingo(T t, U u);
};
 
template< typename T, typename U >
void Dummy< T, U >::Hello(T t, U u)
{
	woman->Hello(t,u);
}
 
template< typename T, typename U >
void Dummy< T, U >::Bingo(T t, U u)
{
	// ...
}
 
template< typename T >
struct Dummy< T >
{
	Crazy< T >* woman;
	void Hello(T t);
	void Bingo(T t);
};
 
template< typename T >
void Dummy< T >::Hello(T t)
{
	woman->Hello(t);
}
 
template< typename T >
void Dummy< T >::Bingo(T t)
{
	// ...
}
 
int main(int argc, char** argv)
{
	// ...
}

Une idée ?

[screetch]

cela depend de l'ordre ou tu definis les fonctions je pense. Je n'ai plus le compilo sous la main donc je ne peux pas verifier.

Mais en gros quand tu fais man->kekchose() alors il faut que le type de man soit connu, donc que sa definition (du type, pas de la variable) soit avant.

[meuns26]

C'est bien le problème, Crazy et Dummy ont besoin reciproquement l'un de l'autre, donc si change l'ordre le problème sera toujours là. J'ai essayé de prédéfinir le template placé en seconde position mais le cas du < > ne fonctionne pas contrairement aux autres... :S

[screetch]

mets les definitions de classe en haut et les definitions de methodes en bas. Fais toujours ca ^^

si possible, pour ranger, mets les definitions de classe dans un .h, les definitions de methode dans un .inl, inclus le .inl apres le .h, et inclus dans le .inl le .h qui manque

en gros
fichier dummy.h

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
 
/* predecl */
template< typename T U >
struct Crazy<T,U>;
 
struct Dummy< >
{
};
 
struct Dummy< >
{
};
 
struct Dummy< void void >
{
};
 
#include "dummy.inl"

fichier crazy.h

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
 
/* predecl */
template< typename T U >
struct Dummy<T,U>;
 
struct Crazy< >
{
};
 
struct Crazy< >
{
};
 
struct Crazy< void void >
{
};
 
#include "crazy.inl"

fichier dummy.inl

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
/* besoin de crazy */
#include "crazy.h"
 
Dummy< >::GoodBye()
{
};
 
Dummy< void void >::GoodBye()
{
}

fichier crazy.inl

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
/* besoin de dummy */
#include "dummy.h"
 
Crazy< void void >::Hello()
{
}
 
Crazy< void void >::Hello()
{
}

sans oublier les include gards qui vont bien.
Inclus dummy.h crazy.h dans ton main.