Un moyen de compilation pour déterminer le type d'argument le moins cher

J'ai un modèle qui ressemble à ceci

template <typename T> class Foo
{
public:
    Foo(const T& t) : _t(t) {}
private:
    const T _t;
};

Existe-t-il un moyen de métaprogrammation de modèle avisé pour éviter d'utiliser une référence const dans les cas où le type d'argument est trivial comme un bool ou un char? comme:

Foo(stl::smarter_argument<T>::type t) : _t(t) {}

Je pense que le bon trait de type est is_scalar. Cela fonctionnerait comme suit:

template<class T, class = void>
struct smarter_argument{
    using type = const T&;
};

template<class T>
struct smarter_argument<T, std::enable_if_t<std::is_scalar_v<T>>> {
    using type = T;
};

Éditer:

Ce qui précède est encore un peu old-school, merci @HolyBlackCat de me rappeler cette version plus laconique:

template<class T>
using smarter_argument_t = std::conditional_t<std::is_scalar_v<T>, T, const T&>;

Je suggérerais d'utiliser sizeof(size_t)(ou sizeof(ptrdiff_t)) qui renvoie une taille "typique" liée à votre machine avec l'espoir que toute variable de cette taille rentre dans un registre. Dans ce cas, vous pouvez le transmettre en toute sécurité par valeur. De plus, comme suggéré par @ n314159 (voir les commentaires à la fin de ce post), il est utile de s'assurer que la variable l'est également trivialy_copyable.

Voici une démo C ++ 17:

#include <array>
#include <ccomplex>
#include <iostream>
#include <type_traits>

template <typename T>
struct maybe_ref
{
  using type = std::conditional_t<sizeof(T) <= sizeof(size_t) and
                                  std::is_trivially_copyable_v<T>, T, const T&>;
};

template <typename T>
using maybe_ref_t = typename maybe_ref<T>::type;

template <typename T>
class Foo
{
 public:
  Foo(maybe_ref_t<T> t) : _t(t)
  {
    std::cout << "is reference ? " << std::boolalpha 
              << std::is_reference_v<decltype(t)> << std::endl;
  }

private:
  const T _t;
};

int main()
{
                                                          // with my machine
  Foo<std::array<double, 1>> a{std::array<double, 1>{}};  // <- by value
  Foo<std::array<double, 2>> b{std::array<double, 2>{}};  // <- by ref

  Foo<double>               c{double{}};                // <- by value
  Foo<std::complex<double>> d{std::complex<double>{}};  // <- by ref
}

J'utiliserais le mot-clé C ++ 20 requires. Juste comme ça:

#include <iostream>

template<typename T>
class Foo
{
public:
    Foo(T t) requires std::is_scalar_v<T>: _t{t} { std::cout << "is scalar" <<std::endl; }
    Foo(const T& t) requires (not std::is_scalar_v<T>): _t{t} { std::cout << "is not scalar" <<std::endl;}
private:
    const T _t;
};

class cls {};

int main() 
{
    Foo{true};
    Foo{'d'};
    Foo{3.14159};
    cls c;
    Foo{c};

    return 0;
}

Vous pouvez exécuter le code en ligne pour voir la sortie suivante:

is scalar
is scalar
is scalar
is not scalar