Que signifie "->" après une déclaration de fonction ?

Question

Dans un fichier d'en-tête du système, je vois l'expression suivante :

auto create_task(_Ty _Param) -> task<typename details::_TaskTypeFromParam<_Ty>::_Type>
{…}

Je ne sais pas ce que "->" signifie, ce n'est pas une expression pointeur ou une expression lambda, quelqu'un peut-il m'aider ?

Answer 1

Il s'agit de la nouvelle syntaxe de déclaration de fonction du C++11, appelée "trailing return type". A la fin de la déclaration d'une fonction, -> signifie que le type de retour de la fonction est le suivant. Il ne peut être utilisé que lorsque la fonction auto est utilisé à la place d'un type de retour réel là où vous l'attendez normalement.

Par exemple, ces deux déclarations sont compatibles :

int foo();
auto foo() -> int;

Selon vos goûts, vous pouvez la trouver plus jolie que l'ancienne syntaxe de déclaration, surtout lorsque le type de retour est extrêmement long/complexe :

task<typename details::_TaskTypeFromParam<_Ty>::_Type> create_task(_Ty _Param);
auto create_task(_Ty _Param) -> task<typename details::_TaskTypeFromParam<_Ty>::_Type>;

Mais cela peut parfois être nécessaire avec les modèles, lorsque le type de retour de la fonction peut varier en fonction des arguments.

Disons que vous voulez une fonction modèle pour ajouter des variables :

template<typename T>
T add(const T& x, const T& y)
{
    return x + y;
}

C'est très bien, mais vous ne pourrez ajouter que des variables du même type. Supposons que vous souhaitiez pouvoir ajouter des variables de n'importe quel type (par exemple add((int)1, (double)2) ).

template<typename T, typename U>
??? add(const T& x, const U& y)
{
    return x + y;
}

---

EDIT : notez qu'en C++14 et au-delà, il est légal d'écrire auto add(const T& x, const U& y) sans type de retour de fin, pour la fonction définitions (en d'autres termes, lorsque vous définissez le corps de votre fonction).

---

Le problème est que l'on ne peut pas savoir à l'avance quel sera le type de résultat de x + y seront. En l'état actuel des modèles, ils pourraient même être des types non intégraux. (N'aimeriez-vous pas pouvoir faire add(std::string("x"), "y") ?)

Decltype ainsi que la nouvelle syntaxe de déclaration de fonction, vous permettent de résoudre ce problème.

template<typename T, typename U>
auto add(const T& x, const U& y) -> decltype(x + y)
{
    return x + y;
}

Decltype "renvoie" le type d'une expression. Puisque vous avez besoin de x y y d'avoir été déclaré pour decltype(x + y) pour fonctionner, vous avez besoin de la nouvelle syntaxe.