wieder mal probleme beim überladen (+)

[physikus]

kenner der dummköpfe schrieb:

Du sprichst schon wieder von einer globalen Funktion als Methode. Global definierte Operatoren sind in der Regel friends der Klasse auf der sie operieren.

so wirklich versteh ich das nicht. heißt das ich muss das auch mit dem friend machen?
was macht dieses friend eigentlich ???

Warum eröffnest du eigentlich für dein Thema wenn ich richtig gezählt habe drei Threads!?

weil es vll immer um verschiedene probleme geht?!?

[David_pb]

Aber immer das selbe Programm, oder?

Entweder du machst die Operatorfunktion global oder du schreibst astring::operator+ etcpp.

[physikus]

was heißt denn global machen??

[Gast]

physikus nicht böse gemeint, aber so wird das nie mit C++. Ich weiß nicht wie du schon zu Klassen und Operatoren-Überladung gekommen bist, ohne einfach Sachen wie global zu wissen.

Wahrscheinlich frickelst du dir alles zurecht und holst mal hier und da Infos/Tipps bis es funktioniert.

Ließ dir ein anständiges Tutorial oder Buch durch.
Empfehlung: http://www.cpp-tutor.de/cpp/intro/toc.htm

[BorisDieKlinge]

Global (mein C++ wissen bisher) heist das eine Funktion oder Variable ungebunden unabhängig auserhalb Klassen definiert werden, und so vom gesamten Code aus sichtbar und verwendbar sind.

//Globale Funktion
void Globfunk(){

};

class A{

void funk();
};

//klassen Member (gebunde Funktion an Klasse)
void A::funk(){

}

class B{

void funk();

}; 

//klassen Member (gebunde Funktion an Klasse)
void B::funk(){

}

[physikus]

OK, und welche vor bzw nachteile oder sinn und zweck hat es wenn ich das überladen von + global oder halt nicht global mache?

[David_pb]

Globale operator Funktionen erlauben, mit einigen Voraussetzungen, mehr Freiheit mit weniger Code!

class Integer
{
  Integer( int x )
  {}

  /* ... */
  Integer operator+( const Integer& ) const
  { /* ... */ }
};

int main()
{
  Integer x( 10 );
  Integer y;

  y = x + 10; // geht
  y = 10 + x; // geht nicht :)
}

Jetzt mit globalen Operator+:

class Integer
{
  Integer( int x )
  {}

  /* ... */
};

Integer operator+( const Integer&, const Integer& )
{ /* ... */ }

int main()
{
  Integer x( 10 );
  Integer y;

  y = x + 10; // geht
  y = 10 + x; // geht
}

[CStoll]

Vorteile für globale Funktion:

• der linke Operand muß kein Klassenobjekt sein (z.B. für die Stream-Opratoren >> und << - die müsstest du als Methoden der IO-Streams definieren und da kommst du nicht ran).
• auf den linken Operanden können implizite Typumwandlungen angewendet werden (z.B. "Hallo"+str1; funktioniert nicht mit Member-Operator)

Einziger Nachteil von globalen Operatoren ist, daß sie keinen Sonderzugriff auf private Daten haben - aber wenn man es richtig macht, brauchen sie den auch nicht:

class MyString
{
public:
  MyString operator +=(const MyString& other);
  ...
}

MyString operator+(const MyString& lhs,const MyString& rhs)
{
  MyString tmp=lhs;
  return tmp+=rhs;
}

[David_pb]

CStoll schrieb:

Einziger Nachteil von globalen Operatoren ist, daß sie keinen Sonderzugriff auf private Daten haben - aber wenn man es richtig macht, brauchen sie den auch nicht

Zur not kann man die Funktion mit der Klasse befreunden. Wobei das normal eher die letzte Alternative der möglichen Lösungen darstellen sollte.

[camper]

CStoll schrieb:

MyString operator+(const MyString& lhs,const MyString& rhs)
{
  MyString tmp=lhs;
  return tmp+=rhs;
}

So aber besser nicht. Hier hat der Compiler keine Chance, (N)RVO anzuwenden.

MyString operator+(const MyString& lhs,const MyString& rhs)
{
  MyString tmp=lhs;
  tmp+=rhs;
  return tmp;
}

ist günstiger.

[Gast]

camper schrieb:

CStoll schrieb:

MyString operator+(const MyString& lhs,const MyString& rhs)
{
  MyString tmp=lhs;
  return tmp+=rhs;
}

So aber besser nicht. Hier hat der Compiler keine Chance, (N)RVO anzuwenden.

Überhaupt keine ?

Und wie siehts bei dem hier aus:

MyString operator+(const MyString& lhs,const MyString& rhs)
{
  return MyString(tmp) += rhs;
}

[camper]

KasF schrieb:

Überhaupt keine ?

Und wie siehts bei dem hier aus:

MyString operator+(const MyString& lhs,const MyString& rhs)
{
  return MyString(tmp) += rhs;
}

Gleiches Problem. Der Rückgabewert wird aus dem Funktionsergebnis des += Operators konstruiert und dieses ist kein Objekt (wenn wir mal von einer fehlerfreien Definition von += mit einer Referenz als Rückgabewert ausgehen...).

Man könnte noch

MyString operator+(const MyString& lhs,const MyString& rhs)
{
  MyString tmp=lhs;
  return tmp+=rhs,tmp;
}

schreiben, aber das ist wohl kaum besser.

[physikus]

hmm... aber irgendwie funktioniert keines der angegebenen Beispiele.
Selbst wenn ich versuche

astring operator+(const astring& lhs,const astring& rhs) 
{ 
  //astring tmp=lhs; 
  //return tmp+=rhs;
	return lhs;
}

bringt er folgenden fehler

test.cpp(13) : error C2784: "std::_String_iterator<_Elem,_Traits,_Alloc> std::operator +(_String_iterator<_Elem,_Traits,_Alloc>::difference_type,std::_String_iterator<_Elem,_Traits,_Alloc>)": template-Argument für "std::_String_iterator<_Elem,_Traits,_Alloc>" konnte nicht von "astring" hergeleitet werden.

[CStoll]

Bist du sicher, daß genau dieser Operator aufgerufen wird? Wie sieht denn dein dazugehöriges Hauptprogramm aus?

@camper: Über die Feinheiten des NRVO habe ich mir bisher keinen Kopf gemacht.

[physikus]

int main() 
{
 astring str1 = "Hallo"; 
 astring str2 = " Welt";
 astring str3;
 cout << str1+str2  << endl<< endl;

 int länge1=str1.lenght();
 int länge2=str2.lenght();

 cout << str1 << endl << str2  << endl<< endl ;

[CStoll]

Und wo genau ist Zeile 13? (btw, hast du eigentlich einen Ausgabe-Operator für astring's definiert?)

[physikus]

// stringtest.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "string.h" 
#include <iostream>

//extern buchstabenliste *beginn1;
int main() 
{
 astring str1 = "Hallo"; 
 astring str2 = " Welt";
 astring str3;
 cout << str1+str2  << endl<< endl;

 int länge1=str1.lenght();

Hatte nicht alles kopiert.

[physikus]

hier nochmal die ausgabe

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

	while ((*temp).buchstabe!='#')			//
	{
		  s << (*temp).buchstabe; 
        temp=temp->next;
	}
	return s;
}

Den kompletten code hab ich aber auch schonmal gepostet.

[LordJaxom]

physikus schrieb:

Den kompletten code hab ich aber auch schonmal gepostet.

Inklusive aller in den folgenden zwei Seiten vorgeschlagenen Änderungen? Wie wärs wenn Du mal die Puzzlearbeit selbst machst und nicht uns die erledigen lässt. Also, poste doch einfach mal in einem Post zusammengefasst:

1. Allen relevanten Sourcecode
2. Die vollständige Fehlermeldung
3. Falls die Zeilennummern nicht übereinstimmen exakte Angaben worauf die Meldungen sich beziehen.

[physikus]

OK, hier die main

// stringtest.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "string.h" 
#include <iostream>

//extern buchstabenliste *beginn1;
int main() 
{
 astring str1 = "Hallo"; 
 astring str2 = " Welt";
 astring str3;
 cout << str1+str2  << endl<< endl;

 int länge1=str1.lenght();
 int länge2=str2.lenght();

 cout << str1 << endl << str2  << endl<< endl ;
 cout << "Die Laenge des ersten strings ist " << länge1 << " Zeichen" << endl<< endl;
 cout << "Die Laenge des zweiten strings ist " << länge2 << " Zeichen" << endl<< endl;

 return 0; 
}

include file

// stringtest.h: Master include File 

#ifndef STRINGTEST_H_INCLUDED_
#define STRINGTEST_H_INCLUDED_

#include <iostream>
#include "string.h"
using namespace std;
#endif // define STRINGTEST_H_INCLUDED_

Klasse

// string.h: Schnittstelle für die Klasse astring
#include <iostream>
using namespace std;

#pragma once
class astring 
{ 
struct buchstabenliste {
		char buchstabe;
		buchstabenliste *next;};

public:

astring ();														//Konstruktor

astring (const char* text );									//Konstruktor

~astring ();

int lenght();													// gibt die Länge aus

friend ostream& operator<<(ostream&,const astring& str);		//überladen <<

astring operator+(const astring& lhs,const astring& rhs);

private: 
int size;
buchstabenliste *beginn;										// beginn der struktur
};

und die methoden

// string.cpp: Implementierung der Klasse rational.
//
//////////////////////////////////////////////////////////////////////

#include "string.h" 

astring::astring()											  //Konstruktor ohne wert
{}
astring::astring(const char *s)								 //Konstruktor einlesen
{
	buchstabenliste *temp = new buchstabenliste;  
	beginn=temp;
	size=0;
	for (int i=0;s[i]!='\0';i++)
		{
		size++;
		(*temp).buchstabe=s[i];
		(*temp).next=new buchstabenliste;
		temp=temp->next;
		(*temp).buchstabe='#';
		}
}
astring::~astring()											   //Destruktor
{}
int astring::lenght()
{
	return size;
	return 0;
}

astring operator+(const astring& lhs,const astring& rhs);

{ 
  //astring tmp=lhs; 
  //return tmp+=rhs;
	return lhs;
}
/**/

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

	while ((*temp).buchstabe!='#')			//
	{
		  s << (*temp).buchstabe; 
        temp=temp->next;
	}
	return s;
}

so, das wärs, zeilenangaben stimmen alle. Hoffe ihr könnt damit was anfangen und jemand kann mir helfen. Die fehler wären dann

1>------ Erstellen gestartet: Projekt: stringtest, Konfiguration: Debug Win32 ------
1>Kompilieren...
1>string.cpp
1>e:\studium\2. semester\git ii\eigene software\stringtest\stringtest\string.h(24) : error C2804: Binärer Operator '+' hat zu viele Parameter
1>e:\studium\2. semester\git ii\eigene software\stringtest\stringtest\string.cpp(33) : error C2447: '{': Funktionskopf fehlt - Parameterliste im alten Stil?
1>stringtest.cpp
1>e:\studium\2. semester\git ii\eigene software\stringtest\stringtest\string.h(24) : error C2804: Binärer Operator '+' hat zu viele Parameter
1>e:\studium\2. semester\git ii\eigene software\stringtest\stringtest\stringtest.cpp(13) : error C2676: Binärer Operator '+': 'astring' definiert diesen Operator oder eine Konvertierung in einen für den vordefinierten Operator geeigneten Typ nicht
1>Code wird generiert...
1>Das Buildprotokoll wurde unter "file://e:\Studium\2. Semester\GIT II\Eigene Software\stringtest\stringtest\Debug\BuildLog.htm" gespeichert.
1>stringtest - 4 Fehler, 0 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

Compiler: Visual C++ 2005 Express