im Zusammenhang mit einer pure virtual Function, die einen Vektor zurückliefert,
bin ich auf folgendes Problem gestoßen. Ich möchte einen
Vektor von Obst-Objekten zurückliefern, aber in einer Implementierung
habe ich einen Vektor von Äpfeln. Ich hab mal die Argumentation von Stroustrup
gelesen, dass man so etwas nicht casten kann, da ich sonst Bananen in den Apfel-
korb legen kann. Diese Argumentation finde ich auch ziemlich einleuchtend.
Wenn ich jetzt allerdings einen const std::vector<Obst>& zurückliefer, besteht
diese Gefahr ja nicht. Deswegen habe ich jetzt versucht, den std::vector
mit einem reinterpret_cast zu casten. Ich habe das jetzt etwas losgelöst von
meinem eigentlichen Problem versucht. Mir ist klar, dass in dem Code Speicher
nicht freigegeben wird, vector-Kopien erzeugt werden, etc. und in diesem
Fall durch ändern des Rückgabewertes auf Casten verzichtet werden kann.

#include <vector>
#include <iostream>

class A {
public:
	A(unsigned int i){
		this->i = i;
	}
	virtual ~A(){}
	unsigned int i;
};

class B : public A {
public:
	B(unsigned int i) : A(i) {
	}
	virtual ~B(){}
};

const std::vector<B*> getVector(){
	std::vector<B*> v;
	v.push_back(new B(1));
	v.push_back(new B(2));
	v.push_back(new B(3));
	return v;
}

const std::vector<B> getVectorB(){
	std::vector<B> v;
	v.push_back(B(4));
	v.push_back(B(5));
	v.push_back(B(6));
	return v;
}

int main(int argc, char *argv[]){
	const std::vector<B*> vec1 = getVector();
	const std::vector<A*>& vec2 = reinterpret_cast<const std::vector<A*>& >(vec1);
	for(std::vector<A*>::const_iterator it = vec2.begin(); it!=vec2.end(); ++it){
		std::cout << (*it)->i << std::endl;
	}
	const std::vector<B> vec1b = getVectorB();
	const std::vector<A>& vec2b = reinterpret_cast<const std::vector<A>& >(vec1b);
	for(std::vector<A>::const_iterator it = vec2b.begin(); it!=vec2b.end(); ++it){
		std::cout << (*it).i << std::endl;
	}
	return 0;
}

Funktioniert das reinterpret_cast in solchen Fällen immer? Mit welchen
negativen Effekten muss ich rechnen? In diesem Fall funktioniert es mit
meinem Compiler jedenfalls.

Vielen Dank für eure Hilfe,
CSpille

Funktioniert das reinterpret_cast in solchen Fällen immer? Mit welchen negativen Effekten muss ich rechnen? In diesem Fall funktioniert es mit
meinem Compiler jedenfalls.

1. Nein
2. Mit allem was durch fehlerhafte Daten etc. passieren kann
3. Glück

cu André

Gruß,
CSpille