Una forma de tiempo de compilación para determinar el tipo de argumento menos costoso

Tengo una plantilla que se ve así

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

¿Existe una forma inteligente de metaprogramación de plantillas para evitar el uso de una referencia constante en los casos en que el tipo de argumento es trivial como un bool o char? me gusta:

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

Creo que el rasgo de tipo correcto es is_scalar. Esto funcionaría de la siguiente manera:

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

Editar:

Lo anterior sigue siendo un poco anticuado, gracias @HolyBlackCat por recordarme esta versión más concisa:

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

Sugeriría usar sizeof(size_t)(o sizeof(ptrdiff_t)) que devuelve un tamaño "típico" relacionado con su máquina con la esperanza de que cualquier variable de este tamaño encaje en un registro. En ese caso, puede pasarlo de forma segura por valor. Además, como lo sugiere @ n314159 (ver comentarios al final de esta publicación), es útil asegurarse de que la variable también lo sea trivialy_copyable.

Aquí hay una demostración de 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
}

Haría uso de la palabra clave C ++ 20 requires. Así:

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

Puede ejecutar el código en línea para ver el siguiente resultado:

is scalar
is scalar
is scalar
is not scalar