web-dev-qa-db-fra.com

Différences entre C # "var" et C ++ "auto"

J'apprends le C++ maintenant parce que j'ai besoin d'écrire des programmes de bas niveau.

Lorsque j'ai découvert le mot clé "auto", cela me rappelle le mot clé "var", en C #.

Alors, quelles sont les différences de C # "var" et C++ "auto"?

c#c++varauto
21
Kangjun Heo

En C # var, le mot clé ne fonctionne que localement à l'intérieur de la fonction:

var i = 10; // implicitly typed

Dans le mot clé automatique C++ peut en déduire tapez non seulement dans les variables, mais aussi dans les fonctions et les modèles:

auto i = 10;

auto foo() { //deduced to be int
    return 5;
}

template<typename T, typename U>
auto add(T t, U u) {
    return t + u;
}

Du point de vue des performances, le mot clé auto en C++ n'affecte pas les performances . Et le mot-clé var n'affecte pas non plus les performances .

Une autre différence peut être dans le support intellisense dans IDE. Le mot-clé Var en C # peut être facilement déduit et vous verrez le type avec la souris sur. Avec le mot-clé auto en C++, cela pourrait être plus compliqué, cela dépend de l'IDE.

23
Tomas Kubes

Pour faire simple, auto est une bête beaucoup plus compliquée que var.

Premièrement, auto ne peut faire partie que du type déduit; par exemple:

std::vector<X> xs;
// Fill xs
for (auto x : xs) x.modify(); // modifies the local copy of object contained in xs
for (auto& x : xs) x.modify(); // modifies the object contained in xs
for (auto const& x : xs) x.modify(); // Error: x is const ref

Deuxièmement, auto peut être utilisé pour déclarer plusieurs objets à la fois:

int f();
int* g();
auto i = f(), *pi = g();

Troisièmement, auto est utilisé dans le cadre de la syntaxe du type de retour de fin dans les déclarations de fonction:

template <class T, class U>
auto add(T t, U u) -> decltype(t + u);

Il peut également être utilisé pour la déduction de type dans les définitions de fonction:

template <class T, class U>
auto add(T t, U u) { return t + u; }

Quatrièmement, à l'avenir, il pourrait commencer à être utilisé pour déclarer des modèles de fonction:

void f(auto (auto::*mf)(auto));
// Same as:
template<typename T, typename U, typename V> void f(T (U::*mf)(V));
8
ach

Ils sont équivalents. Ils vous permettent tous les deux de ne pas spécifier vous-même le type d'une variable, mais la variable reste fortement typée. Les lignes suivantes sont équivalentes en c #:

var i = 10; // implicitly typed  
int i = 10; //explicitly typed

Et les lignes suivantes sont équivalentes en c ++:

auto i = 10;
int i = 10;

Cependant, vous devez garder à l'esprit qu'en c ++ le type correct d'une variable auto est déterminé en utilisant les règles de déduction des arguments de modèle pour un appel de fonction.

6
SingerOfTheFall