Non, vous ne pouvez pas surcharger le lambda!
Les lambdas sont des foncteurs anonymes (c'est-à-dire des objets de fonction sans nom) et non des fonctions simples. Par conséquent, la surcharge de ces objets n'est pas possible. Ce que vous essayez essentiellement de faire est presque
struct <some_name>
{
int operator()(int idx) const
{
return {}; // some int
}
}translate; // >>> variable name
struct <some_name>
{
int operator()(char idx) const
{
return {}; // some int
}
}translate; // >>> variable name
Ce qui n'est pas possible, car le même nom de variable ne peut pas être réutilisé en C ++.
Cependant, en c ++ 17, nous avons if constexpr
par lequel on peut instancier la seule branche qui est vraie au moment de la compilation.
Cela signifie que les solutions possibles sont:
- Un seul modèle de variabe lambda. ou
- Un lambda générique et trouver le type du paramètre à l'aide
decltype
de la if constexpr
vérification. (Crédits @NathanOliver )
En utilisant un modèle variabe, vous pouvez faire quelque chose comme. ( Voir une démo en direct en ligne )
#include <type_traits> // std::is_same_v
template<typename T>
constexpr auto translate = [](T idx)
{
if constexpr (std::is_same_v<T, int>)
{
constexpr static int table[8]{ 7,6,5,4,3,2,1,0 };
return table[idx];
}
else if constexpr (std::is_same_v<T, char>)
{
std::map<char, int> table{ {'a', 0}, {'b', 1}, {'c', 2}, {'d', 3}, {'e', 4}, {'f', 5}, {'g', 6}, {'h', 7} };
return table[idx];
}
};
et l'appelle comme
int r = translate<int>(line[0]);
int c = translate<char>(line[1]);
En utilisant lambda générique (depuis c ++ 14 ), ce qui précède sera: ( Voir une démo en direct en ligne )
#include <type_traits> // std::is_same_v
constexpr auto translate = [](auto idx)
{
if constexpr (std::is_same_v<decltype(idx), int>)
{
constexpr static int table[8]{ 7,6,5,4,3,2,1,0 };
return table[idx];
}
else if constexpr (std::is_same_v<decltype(idx), char>)
{
std::map<char, int> table{ {'a', 0}, {'b', 1}, {'c', 2}, {'d', 3}, {'e', 4}, {'f', 5}, {'g', 6}, {'h', 7} };
return table[idx];
}
};
et appelez le lambda comme vous le faites maintenant:
int r = translate(static_cast<int>(line[0]));
int c = translate(static_cast<char>(line[1]));
translate
ne sont que des variables locales qui ne peuvent pas réutiliser le même nom.