LG

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.

#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);
}

+[]() Archive du 07/08/2020 le 28/07/2025

cpp/variable/pointer_function.cpp

class Classe
{
 public:
  int function(int i) const { return i; }
};
 
int main()
{
  // The name of the variable is ptr_func.
  int (Classe::*ptr_func)(int i) const = &Classe::function;
  Classe c;
  return (c.*ptr_func)(2);
}

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.

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>)

Disambiguate overloaded member function pointer being passed as template parameter Archive du 26/07/2013 le 29/05/2021

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;
}

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

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

Plutôt que

cpp/variable/const_variable_bad.cpp

int foo(int i);
int foo(int i)
{
  int value;
  if (i == 1)
  {
    value = 1;
  }
  else if (i == 2)
  {
    value = 2;
  }
  else
  {
    value = 3;
  }
  return value;
}
int main(int argc, char* /* argv */[]) { return foo(argc); }

écrire

cpp/variable/const_variable_good.cpp

int foo(int i);
int foo(int i)
{
  const int value = [i]() {
    if (i == 1)
    {
      return 1;
    }
    if (i == 2)
    {
      return 2;
    }
    return 3;
  }();
  return value;
}
int main(int argc, char* /* argv */[]) { return foo(argc); }