ich beschäftige mich gerade ein bißchen mit C++ und habe echt keine Ahnung wieso mein Programm nicht funktioniert:

Haendler.h:

#ifndef HAENDLER_H_
#define HAENDLER_H_
#include <iostream>

#include "Car.h"

class Haendler {

public:
	Car* create();

private:
};

#endif /* HAENDLER_H_ */

Haendler.cpp

#include "Haendler.h"

Car* Haendler::create(){
	Car* temp = new Car();
	return temp;
}

Car.h:

#ifndef CAR_H_
#define CAR_H_
#include <iostream>
using namespace std;

class Haendler;

class Car {
public:
	friend class Haendler;
	void print();
private:
	Car();
};

#endif /* CAR_H_ */

Car.cpp:

#include "Car.h"

Car::Car(){
}

void Car::print(){
	cout<<"I'm a car"<<endl;
}

main.cpp:

#include <iostream>
#include "haendler.h"
using namespace std;

int main(int argc, char **argv) {

	Haendler *h = new Haendler();
	Car *c = h->create();
	c->print();

	return 0;
}

Also so wie ich das momentan stehen habe funktioniert Alles. Wenn ich aber statt der ganzen Klasse Haendler nur eine Methode davon als Friend deklarieren will klappt das nicht (friend Car* Haendler::create()), weil er die wohl nicht kennt. Habe es statt mit class Haendler auch mit #include "Haendler.h" versucht aber das klappt auch nicht. Kann mir da jemand auf die Sprünge helfen?

ciao, Simon.

class Car;
class Haendler
{
public:
    struct Creator{
        static Car* CreateCar();
    };
    Car* CreateCar();
};

class Car
{
public:
    friend struct Haendler::Creator;
private:
    Car(){}
};

Car* Haendler::Creator::CreateCar()
{
    return new Car;
}

Car* Haendler::CreateCar()
{
    return Creator::CreateCar();
}

int main()
{
    Haendler fritz;
    Car* brummi = fritz.CreateCar();
    return 0;
}

template <class X> class Typ;

template <class X = int> class Doof {
	X *doof;
	friend X* Typ<X>::getDoofTyp();
public:
	Doof(X *param);
	X* getdoof();
};

template <class X> Doof<X>::Doof(X *param) {
	doof = param;
}

template <class X> X* Doof<X>::getdoof() {
	return doof;
}

template <class X = int> class Typ {
	X *typ;
	Doof<X> *d;
public:
	Typ(X *param);
	X* getTyp();
	Doof<X>* getDoof();
	X* getDoofTyp();
};

template <class X> X* Typ<X>::getDoofTyp() {
	return this->getDoof()->doof;
}

template <class X> Typ<X>::Typ(X* param) {
	typ = param;
	d = new Doof<X>(param);
}

template <class X> X* Typ<X>::getTyp() {
	return typ;
}

template <class X> Doof<X>* Typ<X>::getDoof() {
	return d;
}

int main(int argc, char **argv) {

	Typ<> *t4 = new Typ<>(new int(4));
	cout << *t4->getTyp() << endl;
	cout << *t4->getDoofTyp() << endl;

	return 0;
}