auto c/C++

Question

Est-ce que quelqu'un a déjà vu la classe de stockage auto explicitement utilisée en c/C++? Si oui, dans quelle situation?

Answer 1

auto n'est jamais utile dans le langage C/C++ actuel car toutes les variables sont implicitement auto. Il est utile en C++ 0x, où il peut remplacer entièrement la déclaration de type - si vous avez une variable avec une affectation initiale, 'auto' en fera juste le type de cette valeur d'assignation, comme dans les commentaires.

Answer 2

Non, il est supposé que vous omettez le spécificateur de classe. Les seules utilisations raisonnables que je peux penser seraient d'attirer l'attention sur une variable locale particulière qui remplace, disons, une variable globale avec le même nom, ou comme une question d'entrevue.

Les chances sont, vous allez confondre le pauvre programmeur qui est coincé en maintenant le code!

Answer 3

Je n'ai pas vu auto utilisé dans le code écrit au cours des 10 dernières années. Il n'y a aucune raison d'utiliser auto puisque les seuls endroits où vous pouvez l'utiliser est de toute façon implicite. La seule raison pour laquelle il existe encore est pour la rétrocompatibilité, mais il devrait être évité dans le nouveau code.

Answer 4

auto est bon pour les véhicules :-) déclarant

Answer 5

Comme Alex a couvert, auto est utilisé dans C++ 0x pour déclarer des types dans les déclarations d'initialisation où le type est déduit à partir du code d'initialisation.

Il y avait une proposition pour qu'il soit également utilisé comme type de retour, où le type est déduit du code renvoyant une valeur. Cependant, cela a donné lieu à une ambiguïté, donc, au moment de l'écriture, quelque chose de plus cohérent avec la syntaxe lambda de C++ 0x est à l'étude.

Answer 6

Dans GCC, vous devrez peut-être automatique pour déclarer la fonction imbriquée afin de pouvoir définir partout dans le corps de la fonction - voir http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Nested-Functions.html

Answer 7

Voici un exemple de mon code, écrit en C++ 11:

c_srgb find_in_book(const c_HVC &HVC) { 
    auto b = munsell.mun_to_rgb_book.find(HVC); 
    if(b != munsell.mun_to_rgb_book.end()) { 
     c_srgb f = b->second; 
     return f; 
    } else { 
     c_srgb ret; 
     ret.r=ret.g=ret.b=0; 
     return ret; 
    } 
} 

Je préfère que ceci:

c_srgb find_in_book(const c_HVC &HVC) { 
std::_Tree_iterator<std::_Tree_val<std::_Tmap_traits<dj::color::c_HVC,dj::color::c_srgb,std::less<dj::color::c_HVC>,std::allocator<std::pair<const dj::color::c_HVC,dj::color::c_srgb>>,false>>> b = munsell.mun_to_rgb_book.find(HVC); 
    if(b != munsell.mun_to_rgb_book.end()) { 
     c_srgb f = b->second; 
     return f; 
    } else { 
     c_srgb ret; 
     ret.r=ret.g=ret.b=0; 
     return ret; 
    } 
}