Template-Klasse Operatoren überladen...Fehler?

Hallo Leute, ich wollte grad mal ne template klasse schreiben, und operatoren überladen!
Nun häng ich aber schon an den ersten 2:

template <class T>
class vector
{
 public:
  vector(int size){data=new T[size];index=-1;}
  ~vector(){delete[] data;}
  T GetTop(){return data[index];}
  void DeleteLast(){index=index-1;}
  void SetLast(T digit){index=index+1;data[index]=digit;}
  friend ostream& operator <<(ostream &stream,vector &t);
  friend istream& operator >>(istream &stream,vector &t);

 private:
  T* data;
  int index;
};
 ostream &operator <<(ostream &stream,vector &t)   //wie müssen die aussehen?
 {
  stream<<t.GetTop();
  return stream;
 }
 istream &operator >>(istream &stream,vector &t)  //der auch??
 {
 stream>>t.data[t.index];
 return stream;
 }

int main(int argc, char* argv[])
{
 vector<double> v(10);
 cin>>v;
 cout<<v;

 getch();     //hier nach tastendruck, hängt sich programm auf, warum?  
 return 0;
}

was muss ich denn bei operatoren von templateklassen beachten?

camper

die betreffenden operatoren müssen auch templates sein, denn innerhalb der definition musst du die genaue instanz von vector angeben:

template<class T>
ostream &operator <<(ostream &stream,vector<T> &t)
{
  stream<<t.GetTop();
  return stream;
}

ausserhalb der definion von vector ist vector& sinnlos - es gibt ja keine referenzen auf templates. wenn du dir ein wenig schreibaufwand sparen willst, kannst du die operatoren auch gleich in der friend deklaration definieren.

groovemaster

Ich würde dir empfehlen, dein index anders zu definieren. Mach daraus length oder lass index auf das nächste einzufügende Element zeigen.

getch();     //hier nach tastendruck, hängt sich programm auf, warum?

Nicht immer befindet sich ein Fehler dort, wo sich die Auswirkungen bemerkbar machen. Gehen wir also mal ein Stückchen zurück

cin>>v;

OK, schauen wir uns also mal den entsprechenden Operator dazu an

istream &operator >>(istream &stream,vector &t)  //der auch??
 {
 stream>>t.data[t.index];
 return stream;
 }

Was fällt auf? Genau, t.index ist nach der Konstruktion -1. Du greifst hier also auf ungültigen Speicher zu.

ok, funktioniert jetzt
danke

eine frage noch, wie kann ich die operatoren trotzdem ausserhalb der klasse machen? Oder getn das mit templates da nich?

Th

template<typename T>
ostream &operator <<(ostream &stream,vector<T> &t)   //so müssen die aussehen!
{ 
  stream<<t.GetTop(); // dies gibt aber nur den obersten Wert aus (Stack?)
  return stream; 
}

groovemaster

Th schrieb:

template<typename T>
ostream &operator <<(ostream &stream,vector<T> &t)   //so müssen die aussehen!

Das hat ja bereits camper geschrieben. Noch besser wäre es allerdings, wenn op << wie folgt deklariert wird

template<class T>
ostream& operator <<(ostream&, const vector<T>&)