code in template packen...

hi ich wollte wissen ob man den untenstehenden code in ein template packen kann um an gegeben stellen die rechenarten zu ersetzen? wenn ja wie habe noch nie templates benutzt! das programm setzt positiv arythmetische zahlenreihen fort, und soll nun deom. fortsetzen und darum muss ich an einigen stellen was ersetzen.
wäre für code schnitzeleien dankbar.

#include <iostream>
#include <vector>

using namespace std;

int main(int argc, char *argv[])
{
    vector<char> a;
    char eingabe;

    while( eingabe != 'e' ) {
      cin>>eingabe;
      if ( eingabe <= '9' )
      a.push_back(eingabe);
    }

if ( (a[1]-a[0]) == (a[2]-a[1]) ) { //hier: geteilt
    vector<char> w;
    w.push_back( a[a.size() - 1] + (a[1] - a[0]) ); //hier plus durch mal [oder so]
    cout<<w[w.size()-1]<<endl;
    }

  system("PAUSE");	
  return 0;
}

SideWinder

Dürfte sich um Standard-C++ handeln.

enum als Templateparameter für eine Funktion calculate()?

MfG SideWinder

C++ Forumbot

Dieser Thread wurde von Moderator/in SideWinder aus dem Forum DOS und Win32-Konsole in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

könntest du das bitte daruaf anwenden? dann hab ich noch das problem mit char, ich kann nur einstellige zahlen oder buchstaben eingeben, also 12 oder 54 funzt nicht, wie krieg ich das hin das er bei "e" aber die schleife abbricht? muss ich da nen ...cast-operator nehmen?

while( eingabe != 'e' ) { //hier
      cin>>eingabe;
      if ( eingabe <= '9' )   // nimmt auch ohne if nur zahlen bis neun da nur ein-zeichner akzeptiert werden
      a.push_back(eingabe);
    }

groovemaster

noooob schrieb:

char eingabe;
    
    while( eingabe != 'e' ) {
      cin>>eingabe;
      if ( eingabe <= '9' )
      a.push_back(eingabe);
    }

Das gibt undefiniertes Verhalten, da auf eingabe zuerst lesend und nicht schreibend zugegriffen wird. Entweder du initialisierst eingabe erst oder nimmst besser eine do/while Schleife.
Wenn du mehrstellige Zahlen eingeben willst, dann nimm halt einen std::string. Wenn du's gleich als Integral brauchst, dann nimm halt int oä.

Code für verschiedene Rechenoperatoren zu templatisieren könntest du zB so machen:

enum rechenoperationen
{
    addieren,
    subtrahieren,
    multiplizieren,
    dividieren
};

template <rechenoperationen op>
struct berechnung
{
    template <class T>
    static T calculate(const T& lhs, const T& rhs)
    {
        return lhs + rhs;
    }
};

template <>
struct berechnung<subtrahieren>
{
    template <class T>
    static T calculate(const T& lhs, const T& rhs)
    {
        return lhs - rhs;
    }
};

template <>
struct berechnung<multiplizieren>
{
    template <class T>
    static T calculate(const T& lhs, const T& rhs)
    {
        return lhs * rhs;
    }
};

template <>
struct berechnung<dividieren>
{
    template <class T>
    static T calculate(const T& lhs, const T& rhs)
    {
        return lhs / rhs;
    }
};

template <rechenoperationen op>
struct mein_code
{
    static void execute()
    {
        // hier deinen Code rein
        // Beispiel fuer Berechnung
        c = berechnung<op>::calculate(a, b);
    }
};

int main()
{
    // ...
    // hier wird der Code ausgefuehrt und dabei addiert
    mein_code<addieren>::execute();
    // hier wird der Code ausgefuehrt und dabei multipliziert
    mein_code<multiplizieren>::execute();
    // ...
}
// ungetestet (gefundene Fehler duerfen behalten werden)

thx