Un modo di compilazione per determinare il tipo di argomento meno costoso

Ho un modello che assomiglia a questo

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

Esiste un metodo esperto di metaprogrammazione per evitare l'uso di un riferimento const nei casi in cui il tipo di argomento è banale come un bool o un char? piace:

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

Penso che il tratto giusto sia is_scalar. Funzionerebbe come segue:

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

Modificare:

Quanto sopra è ancora un po 'vecchio stile, grazie @HolyBlackCat per avermi ricordato questa versione più concisa:

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

Suggerirei di usare sizeof(size_t)(o sizeof(ptrdiff_t)) che restituisca una dimensione "tipica" relativa alla tua macchina con la speranza che qualsiasi variabile di queste dimensioni si inserisca in un registro. In tal caso puoi tranquillamente passarlo per valore. Inoltre, come suggerito da @ n314159 (vedere i commenti alla fine di questo post) è utile assicurarsi che anche la variabile sia trivialy_copyable.

Ecco una demo di 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
}

Vorrei utilizzare la parola chiave C ++ 20 requires. Proprio così:

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

È possibile eseguire il codice online per visualizzare il seguente output:

is scalar
is scalar
is scalar
is not scalar