ich soll in der Unterklasse "Unter" den Zuweisungsoperator so überarbeiten dass die Zuweisung *pb1 = *pb2 richtig funktioniert.

Bin echter Anfänger und habe so meine Schwiegrigkieten mit dem Überladenen von Operatoren. Deshalb waren alle meine bisherigen Ansätze für die Katz.
Hat vielleicht irgendwer eine Idee oder einen Ansatz mit dem ich es erneut versuchen kann?
Fettes Danke schon mal im Voraus

#include <iostream>

using namespace std; 

class Basis{
  protected: 
    int a ; 
  public: 
    Basis(): a(5){
    }
    virtual Basis& operator=(Basis &B){ 
      a = B.a;    
      return *this; 
    }  
}; 

class Unter: public Basis {
    int b; 
    public: 

    Unter(): b(10){
    }
    Unter& operator=(Unter &u){
       a = u.a; 
       b =u.b; 
    }
    void set_b(int b1){
       b = b1; 
    }
    int put_b(){
        return b; 
    }
    int sindwirbeidewirklichgleich(Unter &u){
      return ( a==u.a && b==u.b
    ); 
    }
};

 int main(){

 Unter U1, U2; 
 U2.set_b(27); 
 Basis *pb1;
 Basis *pb2; 
 pb1 = &U1; 
 pb2 = &U2; 
 *pb1 = *pb2;  

  if ( !U1.sindwirbeidewirklichgleich(U2)) {
    cout << "Es gilt: U1.put_b() = " << U1.put_b() << " und U2.put_b() = " << U2.put_b() << endl;  
    cout << "Sie sind mit der Aufgabe noch nicht fertig !" << endl; 
  }
  else
    cout << "all ok !" << endl; 

	system("Pause");
    return 0; 
}

class Basis {
   virtual void methode (Basis &);
};

class Derivat : public Basis
   void methode (Derivat &); // überschreibt nicht Basis::methode(Basis&), da die Signatur eine andere ist.
};

PS: Sagt dir das Konzept "const Correctness" etwas? Wenn du nicht vorhast, einen Wert zu ändern, solltest du ihn als 'const irgendwas&' übergeben.

Unter& operator=(const Unter &u){
a = u.a;
b =u.b;
}

class Unter
{
  ...
  Basis& operator=(Basis& other)
  {
    *this = dynamic_cast<Unter&>(other);
    return *this;
  }
};

Achtung: Das Programm wird dir um die Ohren fliegen, wenn du dort etwas übergibst, was kein echter Unter ist.

Der dynamic_cast dient dazu, quer durch die Vererbungshierarchie umzuwandeln. Der Aufruf versucht, 'other' als eine Unter-Referenz anzusehen. Wenn es wirklich ein Unter-Objekt referenziert, ist alles gut und der normale Zuweisungsoperator wird aufgerufen. Wenn du dort ein Basis-Objekt übergibst, fliegt dir eine bad_cast Exception entgegen.

In einer anderen Aufgabe habe ich ein ähnliches Problem:
Ich habe eine Klasse TextObjekt die einen Überladenen Zuweisungsoperator enthält, der soweit auch funktioniert:

TextObjekt TextObjekt::operator=(const TextObjekt &T){

      if(this == &T){
          return *this;        
      }
      else{
          fileName_out = "2_Verion_von" + T.fileName_out;
          fileName_in = T.fileName_in;
          text = T.text;
          return *this;
      }                 
}

Aber dann sollen wir eine Funktion schreiben die den Inhalt des Attributs vector<string> text umdreht:

TextObjekt umdrehen(TextObjekt &T){

           vector<string> TextBuffer;
           int i;
           i = text.size();
           while(i--){
               TextBuffer.at(i) =  text.at(i);
               cout << "Umgedreht: " << TextBuffer.at(i);          
           }                 
}

Jetzt habe ich das Problem, dass bei der Zuweisung in der main T2= umdrehen(T1); der Compiler meckert:

44 C:\Dev-Cpp\bin\10\blatt10_main_c_d_e.cpp no match for 'operator=' in 'T2 = umdrehen(((TextObjekt&)(&T1)))'

Hier macht sich dann wieder mein mangelndes Wissen über die Überladung bemerkbar.

Was die Fehlermeldung angeht - zeig doch mal etwas mehr Code.

// textobject.h
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#ifndef _TEXTOBJECT_H_
#define _TEXTOBJECT_H_
using namespace std;

/*---------------------------------------------------------------------------*/
class TextObjekt{

      static int counter;   
      protected:
      vector<string> text;   //Inhalt der Datei
      string fileName_in;
      string fileName_out;     

      public:
      string write_mode;
      // Default Konstruktor 
      TextObjekt();         // Erzeugt leeses TextObjekt
      // Konstruktor
      TextObjekt(char* f_in_name, char* f_out_name);
      // Kopierkonstruktor
      TextObjekt(const TextObjekt &kopie);
      // Destruktor
      ~TextObjekt(); 
      // Methoden
      void print_datei(void);
      void set_in_datei(const char *name_in_datei);
      void set_out_datei(const char *name_out_datei);
      string put_string_i(int i);
      char put_char_zeile_spalte(int zeile, int spalte);
      void append_string(string new_string);
      //vector<string> put_text(void);
      void replace(string new_string, int i);
      // Ueberladen des Indexoperator
      string& operator[](int i);
      TextObjekt operator=(const TextObjekt &T);
      void print_alles(void);
      friend void umdrehen(TextObjekt &T);
};

int TextObjekt::counter = 0;

/*---------------------------------------------------------------------------*/

TextObjekt::TextObjekt(){

    fileName_in = "no_in_file";
    fileName_out = "no_out_file";
    text.clear();
    counter ++;
    cout << "**Defaultkonstruktor TextObjekt**: (" << counter << ")"<< endl;

}

TextObjekt::TextObjekt(char* f_in_name, char* f_out_name){

    text.clear();

    fileName_in = string(f_in_name);
    fileName_out = string(f_out_name);
    set_in_datei(f_in_name);
    //set_in_datei(fileName_in.c_str());

    counter ++;
    cout << "**Konstruktor TextObjekt**: (" << counter << ")"<< endl;                 
}

TextObjekt::TextObjekt(const TextObjekt &kopie){

    //fileName_in = kopie.fileName_in;
	//fileName_out = kopie.fileName_out;
    text = kopie.text;
    text.clear();
    fileName_out = "Kopie_von_" + kopie.fileName_out;
    fileName_in = kopie.fileName_in;
    counter ++;
    cout << "**Kopierkonstruktor TextObjekt**: (" << counter << ")" << endl;                 
}
TextObjekt::~TextObjekt(){

    if(strcmp(fileName_out.c_str(),"no_out_file") == true){
  		set_out_datei(fileName_out.c_str());
   	}
    counter --;
    cout << "**Destruktor TextObjekt**: (" << counter << ")" << endl;              
}
void TextObjekt::print_datei(void){

         for(int i=0; i<text.size(); i++){
             cout << text.at(i) << endl;  
         }
}
// Datei einlesen
void TextObjekt::set_in_datei(const char *name_in_datei){
    // Datei nur zum Lesen oeffnen

    ifstream fin;
    string buffer2;

    fileName_in = string(name_in_datei);  //string erzeugen
    text.clear(); // Loescht alle Elemente

    fin.open(fileName_in.c_str());     // formatiert den Dateinamen in ein Zeichenkette-Format
    if(!fin){ 
          cout << "Konnte Datei nicht oeffnen!" << endl; 
    }
    else {
         while(getline(fin, buffer2)){ // Inhalt einlesen
         text.push_back(buffer2);             
         }
    }
    fin.close();  
}
void TextObjekt::set_out_datei(const char *name_out_datei){
    //Datei zum Schreiben oeffnen
    fstream fout;
    fileName_out = string(name_out_datei);

    	if(write_mode != "out"){	
		ofstream foutapp(fileName_out.c_str(),ios::app);
		if(!foutapp){
	   		cout << "Feherhaft geoeffnete Datei" << endl;
		   return;
		}

		for(int i = 0 ; i < text.size() ; i++){
			foutapp << text.at(i)<<endl;
		}
		foutapp.close();
	}
	else{
		ofstream fout(fileName_out.c_str());
		if(!fout){
	   		cout << "Feherhaft geoeffnete Datei" << endl;
		   return;
		}

		for(int i = 0 ; i < text.size() ; i++){
			fout << text.at(i)<<endl;
		}
		fout.close();
	}

  	cout << "Datei gespeichert in: " << fileName_out << endl;

    /*fout.open(fileName_out.c_str());      // formatiert den Dateinamen in ein Zeichenkette-Format
    if(fout.good()){ 

         for(int i=0; i<text.size(); i++){
                 fout << text.at(i) << endl; // in Filestream speichern        
         }
         cout << "Datei gespeichert in Datei: " << fileName_out << endl;
         fout.close();
    }
    else {
         cout << "Konnte Datei nicht oeffnen!" << endl;             
    }*/
}

string TextObjekt::put_string_i(int i){

   	if(text.size() > i)   // genug Zeilen vorhanden?
         return text.at(i-1);
    else
	return "Zeile nicht vorhanden";
}
char TextObjekt::put_char_zeile_spalte(int zeile, int spalte){

	if(text.size() > zeile && text.at(zeile-1).size() > spalte && zeile >= 0 && spalte >= 0){
		return text.at(zeile-1).at(spalte-1);
	}

	cout << "exestiert nicht" << endl;
    return '\0';

}
// String anhaengen
void TextObjekt::append_string(string new_string){

     text.push_back(new_string); // new_string an text haengen 
}
void TextObjekt::replace(string new_string, int i){

    if(text.size() > i)   // genug Zeilen vorhanden?
         text[i-1]=new_string;
    else cout << "Zeile nicht vorhanden!" << endl;        
}
string& TextObjekt::operator[](int i){

      if((i>=0) && (i<text.size())){
          return text[i];          
      }
      else
      cout << "?" << endl;      
}
TextObjekt TextObjekt::operator=(const TextObjekt &T){

      if(this == &T){
          return *this;        
      }
      else{
          fileName_out = "2_Verion_von_" + T.fileName_out;
          fileName_in = T.fileName_in;
          text = T.text;
          return *this;
      }                 
}
void TextObjekt::print_alles(void){

     cout << "File_out_name: " << fileName_out << endl;
     cout << "File_in_name: " << fileName_in << endl;          
}

#endif

Und wie gesagt: in der umdrehen() fehlt eine return-Anweisung (oder soll der Compiler erraten, was er zurückgeben soll?).

int main(){

  int a = 0;  

	TextObjekt T1("kurzes_gedicht.txt","machmichnichtkaputt.txt"), T2; 

	// Ausgabe des Inhalts: 
	cout << endl << "Ausgabe T1 vor dem Aufruf der Funktion:" << endl << endl; 
	T1.print_datei(); 
	cout << endl << "Ausgabe T2 vor dem Aufruf der Funktion:" << endl << endl; 
	T2.print_datei(); 

	T1.set_out_datei("machmichnichtkaputt.txt"); 

	// umdrehen von T1: 
	T2= umdrehen(T1); 

    cin >> a; 

	cout << "Ende main ! " << endl; 

	return 0; 
}

Wenn ich also ein bischen nachdenke müsste ich doch so der Sache ein bischen näher kommen:

TextObjekt umdrehen(TextObjekt &T){

           int i;
           i = text.size();
           while(i--){
               text.at((text.size())-i) =  text.at(i);
               cout << "Umgedreht: " << text.at(i);          
           }
      return T;                 
}

TextObjekt umdrehen(TextObjekt &T)
{
    TextObjekt T2 = T;
    reverse(T2.text.begin(),T2.text.end());
    return T2;
}

Was die Funktion macht, kannst du selber herausfinden

44 C:\Dev-Cpp\bin\10\blatt10_main_c_d_e.cpp no match for 'operator=' in 'T2 = umdrehen(((TextObjekt&)(&T1)))'