Eine Methode zur Kompilierungszeit, um den kostengünstigsten Argumenttyp zu bestimmen

Ich habe eine Vorlage, die so aussieht

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

Gibt es eine clevere Methode zur Metaprogrammierung von Vorlagen, um die Verwendung einer const-Referenz in Fällen zu vermeiden, in denen der Argumenttyp trivial ist wie ein Bool oder ein Zeichen? mögen:

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

Ich denke, das richtige Merkmal ist is_scalar. Dies würde wie folgt funktionieren:

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

Bearbeiten:

Das Obige ist immer noch ein bisschen altmodisch, danke @HolyBlackCat, dass du mich an diese knappere Version erinnert hast:

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

Ich würde vorschlagen, sizeof(size_t)(oder sizeof(ptrdiff_t)) zu verwenden, die eine "typische" Größe für Ihre Maschine zurückgibt, in der Hoffnung, dass jede Variable dieser Größe in ein Register passt. In diesem Fall können Sie es sicher als Wert übergeben. Darüber hinaus ist es, wie von @ n314159 vorgeschlagen (siehe Kommentare am Ende dieses Beitrags), sicherzustellen, dass die Variable auch vorhanden ist trivialy_copyable.

Hier ist eine C ++ 17-Demo:

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

Ich würde das Schlüsselwort C ++ 20 verwenden requires. Genau so:

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

Sie können den Code online ausführen , um die folgende Ausgabe anzuzeigen:

is scalar
is scalar
is scalar
is not scalar