Discussion :

[camboui]

Je sais, le C++ ne le permet pas.

Ce code n'est pas valide:

Code :

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

1
2
3
4
5
6
7
struct query
{
	long get()
		{ return 5l; }
	std::string get()
		{ return "abc"; }
};

Comment contourner le problème sans passer par un variant géré au runtime.

Voici une solution:

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
struct query;
struct my_variant
{
	query & f_q;
	my_variant(query & q) : f_q(q) {}
	template<typename T>
	operator T()
	{
		T t;
		f_q.get(t);
		return t;
	}
};
 
struct query
{
	void get(long & l)
		{ l=5l; }
	void get(std::string & s)
		{ s="abc"; }
	my_variant get()
	{
		return my_variant(*this);
	}
};
 
void main()
{
	query q;
	long i = q.get();
	std::string s = q.get();
}

Si quelqu'un a mieux je suis preneur

[ternel]

Et quelle est ta question?

Plus important, pourquoi te la poses-tu? Le savoir nous permettra probablement de te dire comment t'en passer.

[camboui]

Oui, désolé, j'ai malencontreusement cliqué sur Envoyer avant d'avoir fini le post

[ternel]

Un get template, non défini, et spécialisé pour get<long> et get<string>?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct query {
template <typename T>
T get();
};
 
template <>
long query::get<long>() {return 5l;}
 
template <>
std::string query::get<std::string>() {return "string";}
 
int main() {
std::cout << query().get<std::string>() << std::endl;
}

[camboui]

Je souhaite vraiment conserver cette écriture:

Code :

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

1
2
3
4
5
6
7
8
void main()
{
	long l;
	std::string s;
	query q;
	l = q.get();
	s = q.get();
}

Si c'est pour écrire ceci:

Code :

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

1
2
3
4
5
6
7
8
void main()
{
	long l;
	std::string s;
	query q;
	l = q.get<long>();
	s = q.get<std::string>();
}

Je préfère alors ceci:

Code :

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

1
2
3
4
5
6
7
8
void main()
{
	long l;
	std::string s;
	query q;
	l = q.get_long();
	s = q.get_string();
}

[ternel]

Alors tu ne peux vraiment pas comme ca.

Ou faire preuve d'astuce et retourner un Bidule™ qui se convertit tout seul dans le bon type.

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
struct query_result {
    explicit operator long () const { return 5l; }
    explicit operator std::string () const { return "string"; }
};
 
struct query {
    query_result get() const {return query_result();}
};
 
int main() {
	long l;
	std::string s;
	query q;
	l = q.get();
	s = q.get();
}

En version plus constructive:

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
 struct query;
struct query_result {
    query const& q;
 
    template <typename T>
    explicit operator T () const { return q.get<T>(); }
};
 
struct query {
    query_result get() const {return {*this};}
 
    template <typename T>
    T get() const;
};
//les spécialisations...
 
int main() {
	long l;
	std::string s;
	query q;
	l = q.get();
	s = q.get();
}

[Pyramidev]

Je souhaite vraiment conserver cette écriture:

Code :

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

1
2
3
4
5
6
7
8
void main()
{
	long l;
	std::string s;
	query q;
	l = q.get();
	s = q.get();
}

Si c'est pour écrire ceci:

Code :

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

1
2
3
4
5
6
7
8
void main()
{
	long l;
	std::string s;
	query q;
	l = q.get<long>();
	s = q.get<std::string>();
}

Je préfère alors ceci:

Code :

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

1
2
3
4
5
6
7
8
void main()
{
	long l;
	std::string s;
	query q;
	l = q.get_long();
	s = q.get_string();
}

Donc le but est seulement esthétique ?

L'avantage de la solution avec des templates, c'est que tu peux faire du polymorphisme paramétré :

Code :

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

1
2
3
4
5
6
7
 
template<class T>
void foo(const query& q) {
	T var1 = q.get<T>();
	T var2 = q.get<T>();
	...
}

ou du polymorphisme ad hoc :

Code :

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

1
2
3
4
5
6
7
 
typedef long TypeQuiPourraChanger;
void bar(const query& q) {
	TypeQuiPourraChanger var1 = q.get<TypeQuiPourraChanger>();
	TypeQuiPourraChanger var2 = q.get<TypeQuiPourraChanger>();
	...
}

ce que ne permettent pas les écritures q.get_long() et q.get_string().