Discussion :

[bountykiler]

Bonjour à tous,

J'aimerai déduire dans un programme le type d'une méthode d'une de mes classes en utilisant decltype. Le problème, c'est que cette méthode est surchargée, à savoir que j'ai une version de celle-ci qui est déclarée en const et renvoie un const, tandis que l'autre est non-const et renvoient une reference non const.
Du coup, quand j'essaie de compiler le tout, g++ me sort l'erreur suivante

error: decltype cannot resolve address of overloaded function

Au niveau du code, cela donne ceci:

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
 
#include <iostream>
#include <typeinfo>
 
struct A
{
	int value = 0;
	int& get()
	{
		return value;
	}
	const int& get() const
	{
		return value;
	}
};
 
int main() {
	std::cout << typeid(decltype(&A::get)).name() << std::endl;
 
	return 0;
}

Quelqu'un a une idée de comment je puis indiquer au compilo d'utiliser la 1ere surcharge?

Merci

[jo_link_noir]

Code :

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

1
2
3
4
5
6
7
8
9
template<class R, class T, class... Args>
R (T::*
non_cv_mem_fn(R (T::* f)(Args...))
)(Args...)
{ return f; }
 
//...
 
decltype(non_cv_mem_fn(&A::get))

[bountykiler]

Cool ça marche. Et je note au passage le truc de passer en paramètre la méthode pour en récupérer le type
En retravaillant un peu ton code, je suis arrivé à la solution suivante (un poil plus simple):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template<typename ClassT, typename ResultT, typename... ArgsT>
auto mem_fn(ResultT (ClassT::*arg)(ArgsT...))
{
	return arg;
};
 
template<typename ClassT, typename ResultT, typename... ArgsT>
auto const_mem_fn(ResultT (ClassT::*arg)(ArgsT...) const)
{
	return arg;
};

Tous juste ce qu'il me fallait.

[koala01]

Salut,

Ceci dit, une fonction get non constante qui renvoie un référence non constante, c'est... particulièrement suspect

En effet, cela donne à l'utilisateur de ta classe la possibilité de modifier la valeur d'un détail d'implémentation de celle-ci sans qu'il n'y ait le moindre contrôle de ta classe sur les modifications apportées. De là à penser que l'utilisateur indique une valeur totalement aberrante (dans le contexte d'utilisation de l'objet représenté par la classe), il n'y a qu'un pas qu'il est important de franchir sans se poser de question

Tu dois en effet partir du principe que, si tu laisses la moindre possibilité à l'utilisateur d'une de tes fonctionnalités (j'utilise ce terme parce que c'est le cas pour les classes et les structures, mais aussi pour les fonctions) de faire une connerie en l'utilisant, il ne sert à rien de te poser la question de savoir SI il fera la connerie en question un jour ou l'autre, car la loi de finagle nous dit qu'il la fera forcément. Tout ce que tu peux te poser comme question est de savoir QUAND cela arrivera; et la réponse sera toujours la même : au pire moment qui soit.

Que, à l'extrême limite, tu décide de surcharger l'opérateur [] ou l'opérateur (), cela pourrait se comprendre pour une notion qui serait clairement destinée à représenter une sorte de collection (une matrice, par exemple), mais un get (ou tout service permettant d'accéder à un détail d'implémentation de ton objet), par pitié, fait en sorte que cela ne permette pas de modifier la valeur au niveau de l'objet d'origine! Cela t'évitera bien des soucis par la suite