一种确定成本最低的参数类型的编译时方法

Question

我有一个看起来像这样的模板

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

在参数类型像 bool 或 char 这样微不足道的情况下，是否有一种精明的模板元编程方法可以避免使用 const 引用？喜欢：

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

Answer 1

我认为正确的类型特征是is_scalar。这将按如下方式工作：

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

编辑：

以上内容还是有点老套，感谢@HolyBlackCat 提醒我这个更简洁的版本：

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

Answer 2

我建议使用sizeof(size_t)（或sizeof(ptrdiff_t)）返回与您的机器相关的“典型”大小，希望这种大小的任何变量都适合寄存器。在这种情况下，您可以安全地按值传递它。此外，正如 @n314159 所建议的（请参阅本文末尾的 cmets），确保变量也是 trivialy_copyable 很有用。

这是一个 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
}

Answer 3

我会使用 C++20 关键字 requires。就这样：

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

You can run the code online 查看以下输出：

is scalar
is scalar
is scalar
is not scalar