Friend Methode

mikemodanoxxx

Hallo,

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.

Du kannst nur eine Klasse oder eine freistehende Funktion als friend deklarieren.

brotbernd

Workaround:

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;
}

mikemodanoxxx

Ok, vielen Dank. Wieso geht das ganze dann eigentlich bei Templates? Also wie genau fügt der Compiler die Templates dann zusammen, dass das hier doch funktioniert?

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;
}

Auch wenn das Problem schon gelöst zu sein scheint, frage ich mich wieso du eigenlich Haendler in der Car.h brauchst? Hab ich was übersehen oder so?

Vicious Falcon

War ja nur ein Beispiel, der Kontruktor von Car ist privat und somit sonst nicht zugänglich.