Le fait de contraindre l'"auto" en C++ ne va-t-il pas à l'encontre de son objectif ?

Question

En C++20, nous sommes maintenant en mesure de contraindre l'option auto pour n'être que d'un type spécifique. Donc si j'avais du code qui ressemble à ce qui suit sans aucune contrainte :

auto something(){
  return 1;
}

int main(){
  const auto x = something();
  return x;
}

La variable x on en déduit que c'est un int . Cependant, avec l'introduction de C++20, nous pouvons maintenant contraindre le paramètre auto pour être un certain type comme celui-ci :

std::integral auto something(){
  return 0;
}

int main(){
  const auto x = something();
  return x;
}

Est-ce que ça ne va pas à l'encontre du but de auto ici ? Si j'ai vraiment besoin d'un std::integral ne pourrais-je pas simplement omettre le type de données auto complètement ? Est-ce que je comprends mal l'utilisation de auto complètement ?

Answer 1

Une contrainte sur les déductions auto ne signifie pas qu'il doit être une spécifique cela signifie qu'il doit être l'un des types suivants set de types qui satisfont à la contrainte. Notez qu'une contrainte et un type ne sont pas la même chose, et qu'ils ne sont pas interchangeables.

Par exemple, un concept comme std::integral contraint le type déduit à être un type intégral, tel que int o long mais pas float o std::string .

Si j'ai vraiment besoin d'un std::integral je ne pourrais pas simplement omettre le type de données auto complètement ?

En principe, je suppose que vous pourriez le faire, mais cela entraînerait au minimum des difficultés d'analyse syntaxique, par exemple dans une déclaration du type

foo f = // ...

est foo un type, ou une contrainte sur le type ?

Alors que dans la syntaxe actuelle, nous avons

foo auto f = // ...

et il n'y a aucun doute que foo est une contrainte sur le type de f .

Answer 2

Si j'ai vraiment besoin d'un std::integral ne pourrais-je pas simplement omettre complètement l'auto ?

Non, parce que std::integral n'est pas un type, c'est un concept une contrainte sur les types (ou, si vous voulez, un ensemble de types plutôt qu'un seul type).

Cela ne va-t-il pas à l'encontre du but de l'auto ici ?

L'objectif initial de auto dans C++11 est de dire au compilateur : Quel que soit le type que vous déduisez . *

Avec C++20, auto a un cas d'utilisation élargi - avec un concept, une contrainte sur les types. auto toujours indique au compilateur : Quel que soit le type que vous déduisez - mais la déduction doit également respecter la contrainte.

_{* - en ignorant des questions comme la constance, la référence l/valeur, etc.}

Answer 3

Le concept permet souvent de déplacer l'erreur plus tôt dans la compilation et rend le code un peu plus lisible (puisque le nom du concept est une indication pour le lecteur de ce que vous attendez du type).

Reformulé :

Il est rare que vous utilisiez une variable automatique de manière à ce qu'elle fonctionne sur tous les types.

Par exemple :

auto fn(auto x) {
    return x++;
}

ne fonctionnera pas si vous le faites :

f(std::string("hello"));

parce que vous ne pouvez pas incrémenter std::string L'erreur est quelque chose comme :

error: cannot increment value of type 'std::basic_string<char>'
    return x++;

Si vous changez la fonction en :

auto fn(std::integral auto x) {
    return x++;
}

Vous obtiendrez une erreur du type :

:6:6 : note : modèle candidat ignoré : contraintes non satisfaites satisfaites [avec x:auto = std::basic_string] auto fn(std::integral auto x) {

Pour un petit exemple, cela n'a pas beaucoup d'importance, mais pour un code réel, souvent le fn appelle le fn2 qui appelle le fn3... et vous obtiendrez l'erreur au plus profond du fichier d'implémentation std/boost/....

De cette façon, les concepts déplacent l'erreur vers le site du premier appel de fonction.