Cara kompilasi waktu untuk menentukan jenis argumen yang paling murah

Saya memiliki template yang terlihat seperti ini

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

Apakah ada cara pemrograman cerdas template untuk menghindari menggunakan referensi const dalam kasus di mana jenis argumen sepele seperti bool atau char? Suka:

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

Saya pikir sifat tipe yang tepat adalah is_scalar. Ini akan berfungsi sebagai berikut:

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

Edit:

Di atas masih agak kuno, terima kasih @HolyBlackCat untuk mengingatkan saya pada versi yang lebih singkat ini:

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

Saya akan menyarankan untuk menggunakan sizeof(size_t)(atau sizeof(ptrdiff_t)) yang mengembalikan ukuran "khas" yang terkait dengan mesin Anda dengan harapan bahwa setiap variabel ukuran ini cocok dengan register. Dalam hal ini Anda dapat dengan aman menyampaikannya berdasarkan nilai. Selain itu, seperti yang disarankan oleh @ n314159 (lihat komentar di akhir posting ini) berguna untuk memastikan bahwa variabelnya juga trivialy_copyable.

Berikut ini adalah demo 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
}

Saya akan menggunakan kata kunci C ++ 20 requires. Seperti itu:

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

Anda dapat menjalankan kode secara online untuk melihat output berikut:

is scalar
is scalar
is scalar
is not scalar