Impossible de convertir le paramètre de 'int' en 'int & amp;'

Je suis pluralsight C++ sûr, et c'est le code suivant:

#include <iostream>

template <class T>
T max(T& t1, T& t2)
{
    return t1 < t2 ? t2 : t1;
}

int main()
{
    std::cout << "Max of 33 and 44 is " << max(33, 44) << std::endl;

    return 0;
}

J'ai tapé sur ce morceau de code, mais à la différence du code de la cours, je reçois un message d'erreur:

C2664: 'max' : cannot convert parameter 1 from 'int' to 'int &'

Le code dans le cours est écrit en Visual Studio Express 2010, alors que le mien est écrit en Visual Studio Ultimate 2010.

MODIFIER

Merci à tout le monde (même Kate Grégoire lui-même) pour apporter des réponses et de compensation tout en place.

source d'informationauteur Garth Marenghi

c++visual-studio-2010

30

Parce que les littéraux (et rvalues en général) ne peut pas être transmis par des non-const de référence (car il n'aurait aucun sens si le destinataire de l'appel peut les modifier). Soit le passage par valeur ou par référence const:
```
template <class T>
T max(const T& t1, const T& t2)
{
    return t1 < t2 ? t2 : t1;
}
```
ou
```
template <class T>
T max(T t1, T t2)
{
    return t1 < t2 ? t2 : t1;
}
```
4

Ici, la réponse s'avère être le code non lié vous n'utilisez pas dans votre test. Absolument mon petit max() doit prendre soit en valeur ou en const-ref, et c'était juste un cerveau-slip que je vais corriger dès que je peux.

Mais la démo de code fonctionne à merveille. C'est parce qu'il comprend plusieurs têtes, dont l'une apporte xutility et donc std::max. Cela m'a conduit à ne pas remarquer que mon max n'était pas utilisé. Je vais refaire la démo avec un nom comme biggest pour éliminer ce qui se passe de nouveau. Et en attendant, oui, si vous voulez passer des littéraux à une fonction par référence, ils ont besoin d'être const réf. Je le savais, mais je n'ai pas pensé lors de l'écriture du test, puis a été trompé, quand un mauvais code est apparu à travailler. J'aurais du relire le code plus attentivement: merci pour appeler à mon attention. (Et merci d'avoir pris le cours et j'espère que vous trouvez utiles.)
4

33 et 44 sont des rvalues; ils sont passés à la fonction par valeur et non par référence. Le compilateur ne peut pas convertir ces deux dans le type attendu int &. Utiliser des variables (lvalues), car ils peuvent être transmis par la référence:
```
int a = 33, b = 44;

max(a, b); //44
```
Puisque vous êtes simplement de traiter avec des types fondamentaux ici (int), le passage par référence est redondante. Passage par valeur entraîne une copie, mais la différence sera négligeable:
```
template <class T>
T max(T t1, T t2);
```
Ici, nous pouvons passer à la fois rvalues et lvalues. Mais il y est la chance que vous pourriez passer dans un objet de type classe. Dans ce cas, le passage par référence est recommandée.

Mais pour le cas où nous ne voulons pas d'une copie et veulent à la fois lvalues et rvalues, nous pouvons passer par const référence:
```
template <class T>
T max(T const &t1, T const &t2);
```
En C++11, vous pouvez passer les arguments par un universel de référence de sorte que nous pouvons lier glvalues:
```
template <class T>
T max(T&& t1, T&& t2);

int main()
{
    int a{0}, b{0};

    max(a, b);
    max(1, 2);
}
```
Si vous voulez garder la lvalue-syntaxe de référence dans votre code, vous pouvez utiliser cette lvalue shim:
```
template<typename T>
T& lvalue(T&& t)
{
    return t;
}

int main()
{
    max(lvalue(1), lvalue(2));
}
```
3

Vous ne pouvez pas passer temporaire de la valeur que T&. Puisque vous ne modifiez pas les arguments, l'utilisation const T& au lieu

BTW, il est intégré dans la max fonction
3

Les littéraux entiers ne peuvent pas être transmis en tant que non-const de référence. En outre, votre max fonction peut travailler avec const références, afin de marquer de façon appropriée:
```
T max(const T& t1, const T& t2)
```
2

Si vous avez défini votre fonction avec des paramètres par référence, vous ne pouvez pas utiliser quoi que ce soit mais les noms de variables pour les paramètres et vous essayez d'utiliser des chiffres.

Petite remarque. Vous pouvez utiliser votre code initial de la fonction "max". Essayez de changer d'appel de max(34, 44) à max<const int>(34,44). Parfois, il peut être utile.

#include <iostream>

template <class T>
T max(T& t1, T& t2)
{
   return t1 < t2 ? t2 : t1;
}
int main()
{
   std::cout << "Max of 33 and 44 is " << max<const int>(33, 44) << std::endl;
   return 0;
}

Vous devez vous connecter pour publier un commentaire.