ich habe ien Problem mit OO und Pointern.
Folgender Aufruf markiert durch "<---" liefert die Fehlermeldung: "Durch die Konvertierung gehen Qualifizierer verloren"

void test(const robustGeometry::BOEvent & boEv)
{

	 [b]robustGeometry::BOPointType *pType = &boEv.getPointType();<---	hier
	 robustGeometry::BOLine* line = &boEv.getLine();<---	hier[/b]
};

Hier ein Auszug aus dem h File:
class BOLine
	{
	public:
		BOLine(){};		
		BOLine( const double x1, const double y1, 
				const double x2, const double y2, 
				const BOOwnerType owner);
		~BOLine(void){};
		void setX1( const double x );	
		void setX2( const double x );
		void setY1( const double y );
		void setY2( const double y );
		void setOwner( const BOOwnerType owner );

		double getX1( ) const { return x1; };
		double getX2( ) const { return x2; }; 
		double getY1( ) const { return y1; };
		double getY2( ) const { return y2; }; 
		BOOwnerType getOwner( ) const { return owner; }; 

	};

	class BOEvent
	{
	public:
		BOEvent(){};
		BOEvent(const double x, const double y, const BOPointType pType)
		{ 
			setX( x );
			setY( y );
			setPointType( pType );
		};
		BOEvent(const double x, const double y, const BOPointType pType, const BOLine& line)
		{ 
			setX( x );
			setY( y );
			setPointType( pType );
			setLine( line );
		};

		~BOEvent(void){};

		void setX( const double x );	
		void setY( const double y );
		void setPointType( const BOPointType pointType );
		void setLine( const BOLine& line );
		double getX( ) const { return x; };
		double getY( ) const { return y; };		

		[b]BOLine& getLine( ){ return line; };  ---> Hier richtig declariert??[/b]		BOPointType getPointType( ) { return pointType; };

};

Ist die get Methode schon im h File falsch deklariert?
vielen Dank für eure Hilfe.

In deiner Funktoin oben rufst du genau diese Methoden aber auf einem Objekt auf, das als konstante (Referenz) deklariert wird. Zusammengenommen machst du mit einer Konstanten etwas, was sie (laut Methodendeklaration) nicht konstant lässt.

Drei Lösungsmöglichkeiten:

a) Die Methoden ändern nichts am Objekt (bei getBoType vermutlich der Fall), die Referenzen, die da zurückgegeben wurden dürfen dann nichts referenzieren, was zum Objekt gehört. Dann sollten die Methoden als const deklariert werden.

b) Die Referenzen verweisen auf Teile des Objekts (bei getLine vermutlich der Fall), dann ist es üblich, jeweils eine const und eine non-const Methode zu schreiben, die jeweils eine const-Referenz bzw. eine non-const-Referenz zurückgeben. Damit kann man auf const-Objekten nur lesend auf die Referenzen zugreifen, bei non-const-Objekten auch schreibend.

c) Die Methoden ändern das Objekt tatsächlich, dann darf test nicht auf einer const-Referenz aufgerufen werden und die Signatur von test muss entsprechend geändert werden.

ich wollte jetzt alle betrf Methoden const deklarieren.
Wie sieht das dann im c File aus?
getLine ist falsch, s.u. kommt der Fehler "error C2440: 'return': 'const robustGeometry::BOLine' kann nicht in 'robustGeometry::BOLine &' konvertiert werden Durch die Konvertierung gehen Qualifizierer verloren"
Nutze ich KOnstante als Rückgabe von getLine muss diese im Konstruktur initialisiert werden und ich möchte die nicht const Version aber behalten

class BOEvent
	{
	public:
		BOEvent(){};
		BOEvent(const double x, const double y, const BOPointType pType)
		{ 
			setX( x );
			setY( y );
			setPointType( pType );
		};
		BOEvent(const double x, const double y, const BOPointType pType, const BOLine& line)
		{ 
			setX( x );
			setY( y );
			setPointType( pType );
			setLine( line );
		};

		~BOEvent(void){};

		void setX( const double x );	
		void setY( const double y );
		void setPointType( const BOPointType pointType );
		void setLine( const BOLine& line );
		double getX( ) const { return x; };
		double getY( ) const { return y; };		

		BOLine& getLine( ){ return line; };
		BOPointType getPointType( ) { return pointType; };

		BOLine& getLine( ) const { return line; }; <---------
		BOPointType getPointType( )const { return pointType; };

		void Print(ostream& out)const;		

	private :
	  double x;
	  double y;
	  BOPointType pointType;
	  BOLine line;
	  //const BOPointType pointType_const;
	  //const BOLine line_const;
	};

getLine ist falsch, s.u. kommt der Fehler "error C2440: 'return': 'const robustGeometry::BOLine' kann nicht in 'robustGeometry::BOLine &' konvertiert werden Durch die Konvertierung gehen Qualifizierer verloren"

Hatte ich geschrieben: Die const-Methode muss eine const-Referenz zurückliefern.

Nutze ich KOnstante als Rückgabe von getLine muss diese im Konstruktur initialisiert werden

eine Referenz hat keinen Konstruktor, da ist nichts zu initialisieren.

und ich möchte die nicht const Version aber behalten

Hatte ich auch beschrieben - in dem fall musst du beide Versionen anbieten.

const  BOLine& getLine( ) const { return line; }; 
  BOLine& getLine( ) { return line; };

Der Compiler sucht sich immer die richtige Methode aus. Natürlich kannst du die Rückgabe von getLine() const auch nur an eine const-Referenz binden, während du die Rückgabe der non-const-Version auch an non-const Referenzen binden darfst.