Operator = überladen

hallo

ich will den Operator = überladen. Und das ungefähr so:

char a; 
}; 
 //Nicht-Member Funktionen fuer Ein- und Ausgabe 
ostream& operator<<(ostream&,astring); 

// Arithmetische Nicht-Member Funktionen 
astring operator =(astring);

das ist die main

C/C++ Code: 
astring str = "Hallo";

und so ungefähr soll die methode aussehen

asting operator = (s) 
{ 
    struct buchstabenliste { 
    char buchstabe; 
    buchstabenliste *next;}; 

buchstabenliste *temp = new buchstabenliste;   
buchstabenliste *anfang=temp; 

for (int i=0;s[i]!='\0';i++) 
{ 
(*temp).buchstabe=s[i]; 
(*temp).next=new buchstabenliste; 

temp=temp->next; 
(*temp).buchstabe='#'; 
}

dann sagt er aber:
error C2801: "operator =" muss ein nicht statischer Member sein.

was heißt das

David_pb

Erstmal sieht die Signatur vom operator= folgendermaßen aus:

astring& operator=( const astring& );

Dann gehört der natürlich in die Klasse und nicht zuletzt ruft die Zeile

astring str = "Hallo";

nicht den operator= auf sondern einen entsprechenden Konstruktor. Wenn es keinen gibt, funktioniert das halt nicht.

und wie sollte der konstruktor aussehen?

David_pb

In deinem Fall wahrscheinlich so:

astring( const char* text )
{
  /* dein code */
}

ich glaube das was ich überladen will muss eigentlich in den konstruktor???

ich will einen string aus der main in eine solche liste einlesen.

also muss diese liste in den konstruktor??? richtig???

David_pb

class astring
{
public:
	astring( const astring& rhs )
	{}

	astring( const char* text )
	{}

	astring& operator=( const astring& rhs )
	{
		return *this;
	}
};

int main()
{
	astring str = "Hallo"; // ruft astring::astring( const char* ) auf
	astring str1( str ); // ruft astring::astring( const astring& ) auf
	str1 = str; // ruft astring::operator=( const astring& ) auf

	std::cin.get();
}

Je nachdem was deine Klasse können soll benötigst du halt diverse Mittel.

*D*Evil

class astring
{
    struct Item
    {
        char letter;
        Item* pNext;
        Item() : pNext(NULL), letter('#') {}
    } * m_pBegin;

public: 
    astring(const char* cpy)
    {
        m_pBegin = new Item;
        Item* pTmp = m_pBegin;
        for (std::size_t n = 0; std::strlen(cpy); ++n)
        {
            pTmp->letter = cpy[n];
            pTmp->pNext = new Item;
            pTmp = pTmp->pNext;
        }
    }
    ~astring()
    {
        Item* pTmp = m_pBegin;
        for (Item* pNext = pTmp->pNext; pNext; pTmp = pNext; pNext = pNext->pNext)
            delete pTmp;
    }
    std::size_t length() const
    {
        std::size_t len = 0;
        for (Item* pTmp = m_pBegin; pTmp; pTmp = pTmp->pNext) ++len;
        return len;
    }
};

... hab aber nicht kontrolliert ob es so stimmt!

danke danke...
so das einlesen in die liste funktioniert jetzt.
jetzt will ich den string aber wieder ausgeben:

int main() {
 astring str = "Hallo"; 
 cout << str << endl;

dazu muss ich jetzt wieder << überladen. in etwa so:

private: 

char a;
}; 
 //Nicht-Member Funktionen fuer Ein- und Ausgabe
ostream& operator<<(ostream&,astring);

und dann eine methode

ostream& operator << (ostream& s, astring  astr) 
{ 
}

und in diese methode müsste ich dann wieder eine solche schleife einbauen die mir die buchstaben einzeln wieder ausgibt und mit

return s

zurück gibt.

liege ich da richtig????

David_pb

std::ostream& operator<<( std::ostream& out, const astring& deinstring )
{
  // ausgabe
  return out;
}

So, überladen und in einer Schleife die Buchstaben ausgeben, genau.

aber um jetzt die liste durchzublättern brauch ich doch den anfangszeiger.

Aber der icht doch nur in dieser einlese methode gültig, oder nicht?

wie kann ich den denn in die ausgabemethode mit übernehmen???

*D*Evil

Hmm ... also den Code den ich dir gab halt den Anfangspunkt als Membervariable ... d.h. ist immer da solange das Objekt existiert.

bekomme aber immer folgenden fehler

error C2248: "astring::buchstabenliste": Kein Zugriff auf private struct, dessen Deklaration in der astring-Klasse erfolgte.

"astring::beginn": Kein Zugriff auf private Member, dessen Deklaration in der astring-Klasse erfolgte.

class astring 
{ 

	struct buchstabenliste {
		char buchstabe;
		buchstabenliste *next;}; 

		buchstabenliste *beginn;

public:

astring (const char* text );

private:

std::ostream& operator<<( std::ostream& s, const astring& str ) 
{  
	astring::buchstabenliste *temp= str.beginn;

	return s << 	(*temp).buchstabe;
}

*D*Evil

öhm ja normal? du bist ja auch nicht mehr innerhalb der Klasse? Du kannst die Struct, so wie se deklariert ist, nur in der Klasse nutzen und auch das begin ist private.

versteh ich nicht..

ich bin doch noch in der klasse, oder nicht?

wo muss ich das denn deklarieren damit ich noch in der klasse bin

*D*Evil

hmm

public:
    friend std::ostream &  operator << (std::ostream&, const astring&);

bei der Klasse hinzufügen ...

das hab ich mitlerweile so gemacht.
jetz sag ich in der methode:

ostream& operator<<( ostream& s, const astring& str )//ausgeben 
{  
	return s << str.beginn ;

dann kommt trotzdem immer noch folgendes

error C2248: "astring::beginn": Kein Zugriff auf private Member, dessen Deklaration in der astring-Klasse erfolgte.