ich habe eine Stack Klasse und eine Summen-Funktion, beides templates. Leider komme ich nun mit den Typ-Bezeichnern (allgemeint T) durcheinander :xmas1:

//Stack Klasse
template<typename T>
class MyStack
{
 private:
     struct Node{
           T value;
           Node *next; //nur ein Zeiger auf Node
     };
 public:
     Node* p; //Zeiger auf Top-Node/Anker
     class Iterator{
      public:
             Node* element; //Zeiger auf Node

             T operator*() {return element->value;}
             Iterator & operator ++(int)
             {element=element.next;  return *this;}
             };
    Iterator begin(){Iterator beg; beg.element = p; return beg;}
    Iterator end(){Iterator e = NULL; return e;}
};

//Summen Funktion
template<typename T>
void summe(T* first)
{
T summe = 0;

for(T* p=first; p != 0; ++p)
summe += *p;

Der Typ in summe müsste der gleiche Typ wie vom Stack sein, oder?

Bin mir unsicher

danke für deine Antwort. Ich habe das Problem vielleicht nicht deutlich gemacht.
Wenn ich in main() ein Exemplar z.B. vom Typ MyStack<int> A definiere und im Verlauf die Summe aller Listenelemente benötige, dann rufe ich summe<int>(A.begin()) oder summe<Iterator>(A.begin()) oder auf?
Auf der einen Seite brauche ich Iterator p zum durchlaufen der Liste, auf der anderen Seite muss die lokale Variable summe den gleichen typ wie die Variable value in Struct Node haben.

Du darfst auch ruhig zwei Template-Parameter für deine Familie von summiere-Funktionen verwenden:

template<class T, class Iter>
T summiere(Iter von, Iter bis);

...

List<int> lst;
...
int summe = summiere<int>(lst.begin(),lst.end());

...zumindest für den Anfang...