Một cách thời gian biên dịch để xác định loại đối số ít tốn kém nhất

Tôi có một mẫu trông như thế này

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

Có một cách hiểu siêu lập trình mẫu để tránh sử dụng tham chiếu const trong trường hợp kiểu đối số không quan trọng như bool hoặc char? giống:

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

Tôi nghĩ rằng đặc điểm loại đúng là is_scalar. Điều này sẽ làm việc như sau:

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

Biên tập:

Ở trên vẫn còn một chút trường học cũ, cảm ơn @HolyBlackCat đã nhắc nhở tôi về phiên bản ngắn gọn hơn này:

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

Tôi sẽ đề nghị sử dụng sizeof(size_t)(hoặc sizeof(ptrdiff_t)) trả về kích thước "điển hình" liên quan đến máy của bạn với hy vọng rằng bất kỳ biến nào có kích thước này phù hợp với một thanh ghi. Trong trường hợp đó bạn có thể vượt qua nó một cách an toàn. Hơn nữa, như được đề xuất bởi @ n314159 (xem bình luận ở cuối bài này), rất hữu ích để đảm bảo rằng biến cũng là trivialy_copyable.

Đây là bản 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
}

Tôi sẽ sử dụng từ khóa C ++ 20 requires. Chỉ như thế:

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

Bạn có thể chạy mã trực tuyến để xem đầu ra sau:

is scalar
is scalar
is scalar
is not scalar