Utilisation de enable_if sur un argument de modèle par défaut pour un constexpr lambda

Francis Cugler

J'essaye d'écrire une fonction générique qui retournera toujours un fichier -1. Je veux que la liste d'arguments du modèle soit par défaut int. J'essaie d'utiliser std::enable_ifou std::enable_if_tde tester si le type Test un type arithmétique valide en utilisant std::is_arithmeticou std::is_arithmetic_v. J'ai des problèmes de syntaxe pour pouvoir le compiler correctement. Voici à quoi ressemble mon lambda:

template<typename T = int,
std::enable_if_t<std::is_arithmetic_v<T>> >
static constexpr T negative_one = [](){ 
    return static_cast<T>(-1); 
};

C'est une fonction et un concept très triviaux, mais le compilateur veut se plaindre que l'argument par défaut ne se trouve pas à la fin de la liste d'arguments ... À quoi ressemblerait sa définition correcte?

Voici comment je l'utiliserais:

{
    int i = negative_one();
    float f = negative_one<float>();
}

bolov

Utilisez un argument de modèle facultatif non-type pour sfinae. Votre type doit être un type lambda (pas T) si vous voulez l'appeler / le transmettre comme prédicat. Vous pouvez y parvenir avec la déduction automatique de type.

template<typename T = int, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
static constexpr auto negative_one = [](){ 
    return static_cast<T>(-1); 
};

Une autre option pourrait être d'utiliser une fonction au lieu d'un lambda:


template<typename T = int, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
static constexpr T negative_one() { 
    return static_cast<T>(-1); 
};

std :: enable_if sur un argument de modèle pour déterminer le conteneur STL

Hans Roggeman Sur la base d' une réponse de Nawaz, je souhaite utiliser enable_if pour déterminer si un argument de modèle est un conteneur ou non et si tel est le cas, je souhaite afficher un message personnalisé pour le nom du type au lieu du nom du typeid.

enable_if pour ajouter un paramètre de fonction qui a un argument par défaut?

Oz Le Je ne comprends pas le deuxième scénario présenté ici . Ça dit: • Scénario 2: Ajout d'un paramètre de fonction qui a un argument par défaut: template <your_stuff> your_return_type_if_present yourfunction(args, enable_if_t<your condition, FOO> = BAR) {

Est-il possible d'utiliser une variable de modèle `constexpr` comme valeur par défaut pour un argument de modèle formel

Matthieu En utilisant clang 3.6.0, je ne parviens pas à compiler l'exemple de code suivant. #include <type_traits> template <typename T> constexpr bool IS_SCALAR = ::std::is_scalar<T>::value; template <typename T, bool = IS_SCALAR<T>> struct Class_Breaks { };

Utilisation de enable_if pour désactiver un constructeur de modèle d'une classe de modèle

John Wayne J'essaie de désactiver un constructeur de modèle d'une classe de modèle en utilisant std::enable_iflorsque le type des arguments du constructeur de modèle correspond au type " MyClass" afin que je puisse utiliser mon autre constructeur qui me permet

Argument par défaut pour un foncteur dans un paramètre basé sur un modèle

Salgar Je voudrais avoir un lambda par défaut pour un argument de foncteur dans ma fonction. Je suis conscient qu'il est possible d'utiliser un structet operator()comme ceci: struct AddOne { int operator()(int a) { return a+1; } }; template <t

Utilisation d'un membre de classe comme argument par défaut pour une fonction membre

thi gg Existe-t-il un autre moyen que de surcharger manuellement la fonction membre correspondante et d'appeler la première surcharge avec le membre comme argument? J'essaye quelque chose du genre class test { string t1="test"; testfun( string& val =

Comment spécifier un argument par défaut pour un pack de paramètres de modèle ?

zhangina j'ai la methode suivante template <std::size_t N, std::size_t... Indices> void doSomething() { ... }; Il semble impossible de fournir des valeurs par défaut pour Indices, par exemple template <std::size_t N, std::size_t... Indices = std::make_ind

Utilisation d'un membre statique constexpr d'une référence comme argument de modèle

Lukas Barth J'essaie de savoir si GCC ou Clang interprètent le standard C ++ 17 différemment / mal ici. Voici mon code, qui compile en utilisant GCC 8, mais pas en utilisant Clang 6: struct BoolHolder { constexpr static bool b = true; }; template<bool b>

Utilisation de l'argument de modèle par défaut

Gowrath Cette question est mieux posée par l'exemple. Disons que je veux déclarer un std::priority_queueavec une fonction de comparaison. Je pourrais faire: auto cmp_fn = [](const std::string& left, const std::string& right) { return right < left; }; std:

Utilisation de enable_if sur un argument de modèle par défaut pour un constexpr lambda

Articles connexes

liste