Différences

Ci-dessous, les différences entre deux révisions de la page.

--- lang:cpp:variable [2020/02/11 23:34] – Ajout de "Initialisation complexe d'une variable constante" root
+++ lang:cpp:variable [2025/07/28 10:36] (Version actuelle) – Précision sur l'utilisation de la lambda dans "Initialisation complexe d'une constante" root
@@ Ligne 1: / Ligne 1: @@
-===Initialisation complexe d'une variable constante===
+====Déclaration des variables====
+===Pointeur sur méthode vs std::function===
-Plutôt que
+''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>
-std::string str;
+#include <type_traits>
-if (i == 1)
-  str = "un";
+int main() {
-else if (i = 2)
+  auto funcPtr = +[] {};
-  str = "deux";
+  static_assert(std::is_same<decltype(funcPtr), void (*)()>::value);
-else
+  void (*funcPtr2)() = [] {};
-  str = "trois";
+  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>
-écrire
+[[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>
-const std::string str = [&i]()
+struct S5 {
-{
+  template <typename... T, typename... U>
-  if (i == 1)
+  void f(U&&...) const {
-    return "un";
+    std::cout << "S5" << sizeof...(T) << "-" << sizeof...(U) << "\n";
-  else if (i == 2)
+  }
-    return "deux";
+};
-  else
-    return "trois";
+auto ptr = static_cast<void (S5::*)(int&&, char&&) const>(&S5::f<int, double, char>)
-}();
 </code>
-===Pointeur sur la méthode d'une classe===
+[[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>
-// La classe
+struct Z {
-class Classe
+  int z;
-{
-public:
-  // Pas ici.
-  const Classe* function(size_t i) const
-  { return this; }
-  // Ici.
-  const Classe* function2(size_t i) const
-  { return this; }
 };
-int main()
+struct A {
-{
+  Z* i;
-  // Le pointeur de nom ptr.
+};
-  const Classe* (Classe::*ptr)(size_t i) const = &Classe::function2;
-  Classe C;
+struct B {
-  (C.*ptr)(2);
+  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>
-===Connaître le type d'une variable auto à la compilation===
+===Variable optionnelle===
-Cela se fait en lisant le message d'erreur à la compilation.
-<code>
+Création une variable ''field'' de type ''void*'' si ''T'' est de type ''int''.
-template<class Type> struct S;
-int main() {
+<code cpp>
-   auto x = ...;
+std::conditional_t<std::is_integral_v<T>, int, void*> field;
-   S<decltype(x)>();
-}
 </code>
-Message d'erreur possible (le type est le template de la structure S) :
+====Programmation fonctionnelle====
-  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}}
+===Initialisation complexe d'une constante===
-===Pointer vers une classe template depuis une classe sans template===
+Plutôt que
-Il faut mettre une interface commune sans template à la classe template.
-<code cpp>
+{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/variable/const_variable_bad.cpp}}
-struct BaseExample {
-    virtual void do_stuff() = 0;
-    virtual ~BaseExample() {}
-};
-template <typename T>
+écrire
-struct Example : BaseExample { ... };
-// ..
+{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/variable/const_variable_good.cpp}}
-BaseExample *obj;
-</code>
+<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>
-[[https://stackoverflow.com/questions/8205902/how-can-i-declare-a-template-pointer-without-knowing-the-type|How can I declare a template pointer without knowing the type?]] {{ :lang:cpp:variable:c_-_how_can_i_declare_a_template_pointer_without_knowing_the_type_-_stack_overflow_2019-12-18_22_53_28_.html |Archive du 21/11/2011 le 18/12/2019}}