====Déclaration des variables====
===Pointeur sur méthode vs std::function===

''std::function'' supporte les lambda avec des captures, la syntaxe C ne supporte que la capture du ''this''.

De même, il faut préfixer par un ''+'' une lambda pour la forcer à être interprété comme un pointeur avec la syntaxe C. Nécessite uniquement si la déclaration de la variable pointeur sur fonction est de type ''auto''.

<code cpp>
#include <type_traits>

int main() {
  auto funcPtr = +[] {};
  static_assert(std::is_same<decltype(funcPtr), void (*)()>::value);
  void (*funcPtr2)() = [] {};
  static_assert(std::is_same<decltype(funcPtr2), void (*)()>::value);
  // funcPtr3 est un std::function.
  auto funcPtr3 = [] {};
  // error: static assertion failed
  static_assert(std::is_same<decltype(funcPtr3), void (*)()>::value);
}
</code>

[[https://www.cppstories.com/2020/08/c-lambda-week-some-tricks.html/#heading|+[]()]] {{ :lang:cpp:variable:lambda_week_tricks_-_c_stories_7_28_2025_10_28_36_am_.html |Archive du 07/08/2020 le 28/07/2025}}

===Pointeur sur la méthode d'une classe===

{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/variable/pointer_function.cpp}}

Exemple avec une fonction utilisant des template avec auto déduction. Dans ce cas, il faudra faire un cast pour donner le type des éléments déduits.

<code cpp>
struct S5 {
  template <typename... T, typename... U>
  void f(U&&...) const {
    std::cout << "S5" << sizeof...(T) << "-" << sizeof...(U) << "\n";
  }
};

auto ptr = static_cast<void (S5::*)(int&&, char&&) const>(&S5::f<int, double, char>)
</code>

[[https://stackoverflow.com/questions/17874489/disambiguate-overloaded-member-function-pointer-being-passed-as-template-paramet|Disambiguate overloaded member function pointer being passed as template parameter]] {{ :lang:cpp:variable:c_-_disambiguate_overloaded_member_function_pointer_being_passed_as_template_parameter_-_stack_overflow_2021-05-29_08_00_38_.html |Archive du 26/07/2013 le 29/05/2021}}

===Pointeur de pointeur===

<code cpp>
struct Z {
  int z;
};

struct A {
  Z* i;
};

struct B {
  A a;
};

int main() {
  auto ptr1 = &B::a;
  auto ptr2 = &A::i;

  B b;

  // Bien mettre les parenthèses
  int z = (b.*ptr1.*ptr2)->z;
}
</code>

===Variable optionnelle===

Création une variable ''field'' de type ''void*'' si ''T'' est de type ''int''.

<code cpp>
std::conditional_t<std::is_integral_v<T>, int, void*> field;
</code>

====Programmation fonctionnelle====

===Initialisation complexe d'une constante===

Plutôt que

{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/variable/const_variable_bad.cpp}}

écrire

{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/variable/const_variable_good.cpp}}

<WRAP center round info 60%>
Bien noter que la lambda est exécutée tout de suite avec un ''()'' juste après sa déclaration.
</WRAP>