ich habe gerade ein kleines Problem. Ich habe eine Vektor mit 4 Integers. Und ich möchte jede mögliche Rechnung mit +,-,* und / bestimmen.

Also nehmen wir Zahl1 = 1; Zahl2 = 2; Zahl3 = 3; Zahl4 = 4;

Dann möchte ich damit z.B. 1+2+3+4; 1+2+3-4 usw. alles ausrechnen. Nun könnte ich natürlich jeder einzelne Gleichung per Hand reinschreiben, aber das müsste doch bestimmt irgendwie mit for-Schleifen gehen. Nur fällt mir grad echt nicht wirklich so ne richtige Lösung dazu ein.

Hat vielleicht jemand ne Idee?

Gruß

int calc(int number, int a, int b)
{
  int c;

  switch(numer)
  {
    case 0: c = a + b;
    case 1: c = a - b;
    case 2: c = a * b;
    case 3: c = a \ b;
  }

  \\und hier vll irgendwie rekursiv aufrufen

  return c
}

mal überlegen.

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

template<char what, int depth> struct berechne
{
  void operator ()(int *numbers, int result, string equation)
  {
    stringstream eq;
    eq << equation;
    if (what == '+')
      {
        eq << " + " << numbers[depth];
        result += numbers[depth];
      }
    if (what == '-')
      {
        eq << " - " << numbers[depth];
        result -= numbers[depth];
      }
    if (what == '*')
      {
        eq << " * " << numbers[depth];
        result *= numbers[depth];
      }
    if (what == '/')
      {
        eq << " / " << numbers[depth];
        result /= numbers[depth];
      }
    berechne<'+', depth+1>()(numbers, result, eq.str());
    berechne<'-', depth+1>()(numbers, result, eq.str());
    berechne<'*', depth+1>()(numbers, result, eq.str());
    berechne<'/', depth+1>()(numbers, result, eq.str());
  }
};

template<> template<char what> struct berechne<what, 4>
{
  void operator ()(int *, int result, string equation)
  {
    if (what == '+')
      cout << equation << " = " << result << '\n';
  }
};

int main()
{
  int numbers[]={1,2,3,4};
  stringstream eq;
  eq << numbers[0];
  berechne<'+', 1>()(numbers, numbers[0], eq.str());
  berechne<'-', 1>()(numbers, numbers[0], eq.str());
  berechne<'*', 1>()(numbers, numbers[0], eq.str());
  berechne<'/', 1>()(numbers, numbers[0], eq.str());
}

Mit klassischer Rekursion geht es quasi genau so. Die Templateparameter werden dann eben zu normalen Parametern und die Templatespezialisierung zu einer if-Abfrage. Das geht dann natürlich zu kosten der Laufzeit. Hier vernachlässigbar, aber man kann's ja aus Prinzip so gut wie möglich machen. Das übt für die schweren Fälle, bei denen es dann drauf ankommt. Bei der TMP-Lösung sollten jedenfalls sämtliche if-Abfragen wegoptimiert werden (daher habe ich kein switch genommen, bin nicht sicher wie gut das wegoptimiert werden kann).
Den Rekursionsanfang kann man sicherlich noch geschickter machen, aber ich bin gerade faul.

oh, vielen dank das istt genau das was ich gesucht habe. muss ich mir aber dennoch mal genauer anschauen damit ich das nächstes mal auch selber hinbekomme

Templatemetaprogrammierung gehört schon zum gehobenen Stoff von der Schwierigkeit her. Ich würde sogar sagen es ist das schwierigste technische Detail von C++. Es war auch vom Sprachdesign gar nicht so geplant, das wurde eher "entdeckt", dass man das machen kann .

Dies ist ein sehr einfaches Beispiel. Falls du mit Templates, teilweiser Templatespezialisierung und rekursivem Denken fit bist, kann ich versuchen, es dir zu erklären (naja, dann verstehst du es wahrscheinlich auch so, da es so einfach ist), ansonsten wirst du vermutlich nur Bahnhof verstehen. Vermutlich reicht dein Wissen über Rekursion aber zumindest, um ungefähr zu verstehen, was da abgeht, selbst wenn du den Teil der Templatemetaprogrammierung ist nicht verstehst. TMP ist so etwas wie funktionale Programmierung (d.h. praktisch, dass man alles mit Rekursion macht) zur Compilezeit, d.h. der Compiler macht die ganze Arbeit (und zwar nur einmal!), nicht das Programm (welches man dann so oft benutzen kann wie man möchte).

Den Rekursionsanfang kann man sicherlich noch geschickter machen, aber ich bin gerade faul.

Naja, du hast es ja quasi schon da stehen, weil deine Aktionen nur bei bestimmten Zeichen geschehen:

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

template<int depth=0, char what='\0'> struct berechne
{
  void operator ()(int *numbers, int result, string equation)
  {
    stringstream eq;
    eq << equation;
    if (what == '+')
      {
        eq << " + " << numbers[depth];
        result += numbers[depth];
      }
    if (what == '-')
      {
        eq << " - " << numbers[depth];
        result -= numbers[depth];
      }
    if (what == '*')
      {
        eq << " * " << numbers[depth];
        result *= numbers[depth];
      }
    if (what == '/')
      {
        eq << " / " << numbers[depth];
        result /= numbers[depth];
      }
    berechne<depth+1, '+'>()(numbers, result, eq.str());
    berechne<depth+1, '-'>()(numbers, result, eq.str());
    berechne<depth+1, '*'>()(numbers, result, eq.str());
    berechne<depth+1, '/'>()(numbers, result, eq.str());
  } 
};

template<char what> struct berechne<4, what>
{
  void operator ()(int *, int result, string equation)
  {
    if (what == '+')
      cout << equation << " = " << result << '\n';
  }
};

int main()
{
  int numbers[]={1,2,3,4};
  stringstream eq;
  eq << numbers[0];
  berechne<>()(numbers, numbers[0], eq.str());
}

BTW: Ich musste das template<> bei der Spezialisierung entfernen, damit VC10 es schluckt.

#include <iostream>
#include <sstream>
#include <string>
#include <functional>

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

template <template <typename> class func> struct func_holder
{
    template <typename T> struct apply
        : identity<func<T>> {};
};

template <char op> struct op2func;
template <> struct op2func<'+'>
    : func_holder<std::plus> {};
template <> struct op2func<'-'>
    : func_holder<std::minus> {};
template <> struct op2func<'*'>
    : func_holder<std::multiplies> {};
template <> struct op2func<'/'>
    : func_holder<std::divides> {};

template<char what, int depth> struct berechne
{
    void operator ()(int* numbers, int result, std::string equation)
    {
      std::stringstream eq;
      eq << equation;
      typedef typename op2func<what>::template apply<int>::type functor;
      eq << ' ' << what << ' ' << numbers[depth];
      result = functor()( result, numbers[depth] );
      berechne<'+', depth+1>()(numbers, result, eq.str());
      berechne<'-', depth+1>()(numbers, result, eq.str());
      berechne<'*', depth+1>()(numbers, result, eq.str());
      berechne<'/', depth+1>()(numbers, result, eq.str());
  }
};

template<char what> struct berechne<what, 4>
{
    void operator ()(int*, int result, std::string equation)
    {
        std::cout << equation << " = " << result << '\n';
    }
};

int main()
{
    int numbers[] = { 1, 2, 3, 4 };
    std::stringstream eq;
    eq << numbers[0];
    berechne<'+', 1>()( numbers, numbers[0], eq.str() );
    berechne<'-', 1>()( numbers, numbers[0], eq.str() );
    berechne<'*', 1>()( numbers, numbers[0], eq.str() );
    berechne<'/', 1>()( numbers, numbers[0], eq.str() );
}

Edit: mit Beachtung des Vorrangs:

#include <iostream>
#include <sstream>
#include <string>
#include <functional>
#include <utility>

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

template <template <typename> class func0, template <typename> class func1> struct func_holder
{
    template <typename T> struct apply0 : identity<func0<T>> {};
    template <typename T> struct apply1 : identity<func1<T>> {};
};

template <typename T> struct noop_plus { T operator()(T, T rhs) const { return rhs; } };
template <typename T> struct noop_minus { T operator()(T, T rhs) const { return -rhs; } };

template <char op> struct op2func;
template <> struct op2func<' '> : func_holder<noop_plus, noop_plus> {};
template <> struct op2func<'+'> : func_holder<std::plus, noop_plus> {};
template <> struct op2func<'-'> : func_holder<std::plus, noop_minus> {};
template <> struct op2func<'*'> : func_holder<noop_plus, std::multiplies> {};
template <> struct op2func<'/'> : func_holder<noop_plus, std::divides> {};

template <char what, int depth> struct berechne
{
    template <typename T>
    void operator()(T* numbers, T partial_sum, T partial_product, std::string equation)
    {
        std::stringstream eq;
        eq << equation << ' ' << what << ' ' << *numbers;
        partial_sum     = typename op2func<what>::template apply0<T>::type()( partial_product, partial_sum );
        partial_product = typename op2func<what>::template apply1<T>::type()( partial_product, *numbers );
        berechne<'+', depth-1>()( numbers + 1, partial_sum, partial_product, eq.str() );
        berechne<'-', depth-1>()( numbers + 1, partial_sum, partial_product, eq.str() );
        berechne<'*', depth-1>()( numbers + 1, partial_sum, partial_product, eq.str() );
        berechne<'/', depth-1>()( numbers + 1, partial_sum, partial_product, eq.str() );
    }
};

template <char what> struct berechne<what, 0>
{
    template <typename T>
    void operator()(T*, T, T, std::string)
    {}
};

template <> struct berechne<'+', 0>
{
    template <typename T>
    void operator()(T*, T partial_sum,  T partial_product, std::string equation)
    {
        std::cout << equation << " = " << partial_sum + partial_product << '\n';
    }
};

template <typename T, std::size_t N>
void run(T (&numbers)[N])
{
    berechne<' ', N>()( numbers, T(), T(), std::string() );
}

int main()
{
    double numbers[] = { 1, 2, 3, 4 };
    run( numbers );
}

Es ist jetzt nicht so schön templatisiert und auch nicht rekursiv, dafür hab ich aber Funktionszeiger drin:

#include <cstddef>
#include <iostream>
#include <stack>
#include <vector>

double add     (double x, double y) { return x + y; }
double subtract(double x, double y) { return x - y; }
double multiply(double x, double y) { return x * y; }
double divide  (double x, double y) { return x / y; }

struct calculation {
  char     op_char;
  unsigned priority;
  double (*calc)(double, double);
} const calculations[] = {
  { '+', 0, add      },
  { '-', 0, subtract },
  { '*', 1, multiply },
  { '/', 1, divide   }
};

template<typename T, std::size_t N>
inline std::size_t array_size(T(&)[N]) { return N; }

bool next_combo(std::vector<std::size_t> &data) {
  std::size_t max_value = array_size(calculations) - 1;

  ++data.back();
  for(std::size_t i = data.size() - 1; i != 0 && data[i] > max_value; --i) {
    data[i] = 0;
    ++data[i - 1];
  }

  return data[0] <= max_value;
}

void perform_top_operation(std::stack<double> &num_stack, std::stack<calculation> &op_stack) {
  double x = num_stack.top(); num_stack.pop();
  double y = num_stack.top(); num_stack.pop();
  num_stack.push(op_stack.top().calc(y, x));
  op_stack.pop();
}

int main() {
  double numbers[] = { 1, 2, 3, 4 };
  std::vector<std::size_t> op_indices(array_size(numbers) - 1, 0);

  while(next_combo(op_indices)) {
    // Was folgt, ist der relevante Teil des Shunting-Yard-Algorithmus

    std::stack<calculation> op_stack;
    std::stack<double>      num_stack;

    num_stack.push(numbers[0]);

    for(std::size_t i = 0; i < op_indices.size(); ++i) {
      calculation const &current_calc = calculations[op_indices[i]];

      while(!op_stack.empty() && current_calc.priority <= op_stack.top().priority) {
        perform_top_operation(num_stack, op_stack);
      }

      op_stack.push(current_calc);
      num_stack.push(numbers[i + 1]);
    }

    while(!op_stack.empty()) {
      perform_top_operation(num_stack, op_stack);
    }

    for(std::size_t i = 0; i < op_indices.size(); ++i) {
      calculation const &current_calc = calculations[op_indices[i]];
      std::cout << numbers[i] << ' ' << current_calc.op_char << ' ';
    }

    std::cout << numbers[op_indices.size()] << " = " << num_stack.top() << '\n';
  }
}