====Auto====

===Présentation===

''auto'' et ''decltype'' permettent de déduire le type automatiquement.

''auto'' va se baser de façon implicite sur le résultat d'une opération.

''decltype'' va se baser de façon explicite sur une variable ou sur le résultat d'une opération.

<code cpp>
auto i = 3;
decltype(i) j = i + 3;
</code>

===Différences===
Mais il y a des différences. ''auto'' ne conserve pas ''const'', ''volatile'' ni ''&'' ou ''&&''. ''decltype'' garde tout.

Il est possible de faire ''decltype(auto)'' pour tout conserver et déduire automatiquement le type de retour.

===Retour d'une fonction===
''auto'' : tous les ''return'' doivent être de même type.
<code cpp>
auto foo(int a, int b)
{
  if (a != 0)
    return 0;
  else
    return '0';
}
</code>

''decltype'' doit utiliser une syntaxe particulière s'il veut utiliser le type des arguments.

<code cpp>
auto bar(int a, int b) -> decltype(a)
{return 0;}
</code>

[[http://thbecker.net/articles/auto_and_decltype/section_01.html|C++ auto and decltype Explained]] {{ :lang:cpp:auto:auto_and_decltype.zip |Archive du 05/2013 le 11/11/2019}}

===Conteneur multi-types (''std::map'', ''std::tuple'', ...)===

[[lang:cpp:boucles#conteneur_multi-types_stdmap_stdtuple|Voir les boucles]]

===Connaître le type à la compilation===
Cela se fait en lisant le message d'erreur à la compilation.

<code>
template<class Type> struct S;

int main() {
   auto x = ...;
   S<decltype(x)>();
}
</code>

Message d'erreur possible (le type est le template de la structure S) :
  utilisation du type non défini 'S<const std::list<unsigned char> &>'

[[https://stackoverflow.com/questions/24441505/retrieving-the-type-of-auto-in-c11-without-executing-the-program|Retrieving the type of auto in C++11 without executing the program]] {{ :lang:cpp:variable:c_-_retrieving_the_type_of_auto_in_c_11_without_executing_the_program_-_stack_overflow_2019-12-18_22_53_20_.html |Archive du 26/06/2014 le 18/12/2019}}

====Lambda====

  * Compatibilité entre lambda et pointeur de fonction C

  error: no viable conversion from '(lambda at file.cpp)' to 'void (*)(void *, const char *, const char *, uint32_t)' (aka 'void (*)(void *, const char *, const char *, unsigned int)')

Alors que la fonction lambda respecte bien la signature.

2 solutions : forcer le type de retour et ne pas faire de captures (laisser vide entre les ''[]'').

<code cpp>
[](void *, const char *, const char *, uint32_t) -> void{...}
</code>