Reply to Allgemeine Frage zu Templaet "policies" on Thu, 20 Jun 2013 22:36:16 GMT

PolicyClasses — Thu, 20 Jun 2013 22:36:16 GMT

Hallo,
ich habe mal eine allgemeine Frage an euch: Nehmen wir an, es gibt eine Klasse, mit der Benutzer arbeiten sollen. Diese Klasse ändert ihr Verhalten aufgrund eines Templateparameters (sowas in Richtung policy Classes). Welchen "Stil" würdet ihr in folgendem Beispiel bevorzugen? (Es geht hier ums Prinzip, nicht darum, dass man es mit std::accumulate direkt implementieren könnte...)

const int Add = 0;
const int Mult = 1;

template //0 = addiere, 1 = multipliziere
class MathContainer
{
    double value;
public:
    void calculate(const std::vector&);
};

//Möglichkeit 1: Spezialisierung
template //"default" Fall
void MathContainer::calculate(const std::vector& vec)
{
    value = 0.;
    for(std::vector::size_type i=0; i!= vec.size(); ++i)
        value += vec[i]; 
}
template<> //weitere Spezialisierungen
void MathContainer<1>::calculate(const std::vector& vec)
{
    value = 1.;
    for(std::vector::size_type i=0; i!= vec.size(); ++i)
        value *= vec[i]; 
}

//Möglichkeit 2: if/else
template
void MathContainer::calculate(const std::vector& vec)
{
    if(Policy==Mult)
        value = 1.;
    else
        value = 0.;
    for(std::vector::size_type i=0; i!= vec.size(); ++i)
        if(Policy==Mult)
            value *= vec[i];
        else
            value += vec[i];
}

In dem Fall sollten Performance Fragen ja eigentlich egal sein, da der Compiler in beiden Fällen den gleichen Code produzieren sollte. Ich persönlich finde Möglichkeit 1 besser verständlich, da man sofort sieht, was gemeint ist. Außerdem ist die Spezialisierung im allgemeinen flexibler. Wie seht ihr das? Welche Version würdet ihr in einem so einfachen Fall wählen?

Reply to Allgemeine Frage zu Templaet "policies" on Thu, 20 Jun 2013 22:46:34 GMT

politically — Thu, 20 Jun 2013 22:46:34 GMT

Ich sehe beides nicht als Policy.

struct Addieren {
  template  defaultval() { return 0; }
  template  static void opeq(T& l, T const& r)
  { l += r; }
};
struct Multiplizieren {
  template  defaultval() { return 1; }
  template  static void opeq(T& l, T const& r)
  { l *= r; }
};

template // Addieren oder Multipliziere
class MathContainer
{
    double value;
public:
  calculate(const std::vector& vec)
  {
    value = Policy::defaultval();
    for(std::vector::size_type i=0; i!= vec.size(); ++i)
        Policy::opeq(value, vec[i]);
  }
};

Das macht den Code nicht nur generischer (der Nutzer kann neue Policies hinzufügen), sondern auch übersichtlicher.