momentan programmiere ich eine Mathematik-Lib, in der Polynome als Vektorräume aufgefasst werden, wobei die Koeffizienten in einem std::array/std::vector (letzteres bei Rang 0 -> dynamische Dimension) gespeichert werden.

Nun habe ich folgende Funktion, um das Polynom auf eine Variable anzuwenden (im Fall Rang > 0):

template <typename N,size_t D>
class Polynomial : public VectorSpace<N,D+1>
{
    // stuff
    template <typename T>
    T calc(T t);
    // stuff
}

Mein Problem ist, dass T sowohl ein Basistyp als auch ein benutzerdefinierter Typ (z.B. ein Vektor) sein kann.

1. Gibt es eine Möglichkeit, den Compiler entscheiden zu lassen, ob er als Argument eine Kopie oder eine konstante Referenz nimmt?
2. Falls dies nicht möglich sein sollte, wäre es dann klüger, konstante Referenzen zu nutzen?

MfG

ansonsten lieber const&

du könntest deine funktion für die standard datentypen spezialisieren, das könnte nur sehr viel redundanz und schreibarbeit nach sich ziehen

Das wären extrem viele Spezialisierungen, das widerstrebt irgendwie dem Prinzip der Templates.

Skym0sh0 schrieb:

ansonsten lieber const&

Bringt es eigentlich wirklich so viel, Standardtypen und Iteratoren als Kopie anstatt als Referenz zu übergeben? Was daran effizienter sein soll, habe ich nie wirklich verstanden.

Edit: Ach, das hat der Sepp ja quasi schon geschrieben.

Das wären extrem viele Spezialisierungen, das widerstrebt irgendwie dem Prinzip der Templates.

Och, es geht.

template <typename T> struct identity { typedef T type; };

template <typename T, bool B> struct val_or_cref : identity<T> {};
template <typename T> struct val_or_cref<T, false> : identity<T const&> {};

template <typename T> struct per_value_candidate
: std::integral_constant<bool, std::is_pod<T>::value && sizeof(T)<=sizeof(void*)> {};

template <typename T,
          bool PerValue = per_value_candidate<T>::value>
T calc(typename val_or_cref<T, PerValue>::type t)
{
  std::cout <<
    (std::is_reference<typename val_or_cref<T, PerValue>::type>::value
     ? "per const-ref" : "per value") << '\n';
  return t;
}

int main()
{
  calc<int>(4);
  calc<std::string>("x");
  calc<int*>(0);
}

Mich stört eher, dass T nicht mehr deduziert werden kann. Deshalb würde ich das niemals so machen und mich auf den Compiler verlassen.

Du könntest auch was mit enable_if und is_fundamental basteln.

Edit: Ach, das hat der Sepp ja quasi schon geschrieben.

Jetzt, wo du es erwähnst, fällt mir ein, dass ich mal ein Select<bool,typename,typename> geschrieben habe.

Daran hätte ich mal eher denken sollen, danke

Bringt es eigentlich wirklich so viel, Standardtypen und Iteratoren als Kopie anstatt als Referenz zu übergeben? Was daran effizienter sein soll, habe ich nie wirklich verstanden.

Theoretisch bringt es sehr, sehr viel. Kannst dir ja mal den Unterschied überlegen zwischen einem Wert in einem Register und einem Zeiger auf den Wert. Praktisch wird's aber eh wegoptimiert.

Praktisch wird's aber eh wegoptimiert.

Nur wenn die Funktion in der gleichen UE definiert wird. Das ist bei Templates zufällig der Fall.

template <typename T>
    T calc(T&& t); //C++11 "universal reference"

Nur wenn die Funktion in der gleichen UE definiert wird. Das ist bei Templates zufällig der Fall.

Ich nehme Compiler ohne Link-Time-Optimization eh nicht mehr ernst.

Und verwende bitte nicht den Begriff "konstante Referenz". Warum, erfährst du hier.

Polynomteiler schrieb:

Bringt es eigentlich wirklich so viel, Standardtypen und Iteratoren als Kopie anstatt als Referenz zu übergeben? Was daran effizienter sein soll, habe ich nie wirklich verstanden.

Theoretisch bringt es sehr, sehr viel. Kannst dir ja mal den Unterschied überlegen zwischen einem Wert in einem Register und einem Zeiger auf den Wert.

Das. Außerdem ist ein per Value übergebenes Argument garantiert aliasfrei.

pumuckl schrieb:

Ich werf mal einenspontanen Vorschlag in den Ring, mal gucken wer ihn zerreißt:

template <typename T>
    T calc(T&& t); //C++11 "universal reference"

Das ist immer noch eine Referenz.

pumuckl schrieb:

Ich werf mal einenspontanen Vorschlag in den Ring, mal gucken wer ihn zerreißt:

template <typename T>
    T calc(T&& t); //C++11 "universal reference"

Das ist immer noch eine Referenz.

Nicht nur das, sie ist auch nicht mal const, man kann also das Objekt darüber verändern, das bringt's irgendwie so gar nicht?