Funktion eller klasse - noget er galdt

Jeg har ikke problemet:

#include <iostream>

class A
{
public:
  A() {}
};

class B
{
public:
   B(A&) {}
};

int main()
{
   B b(A());
}

Prøv at poste et komplet eksempel der demonstrerer fejlen.

Ok her er de filer jeg har:

//A.hpp
#include <string>
class B;

class A
{
	struct APimpl;
	APimpl* _aPimpl;
public:
	A(B& b);
	~A();

	void Func1();
	void Func2();
	void Func3(std::string file);
};

//B.hpp
class B
{
public:
	virtual ~B(){};
	virtual void Something() = 0;
	void BSpeciale();
};

//A.cpp
#include "A.hpp"
#include "B.hpp"

struct A::APimpl
{
	B* _b;
};

A::A(B& b) 
{
_aPimpl = new APimpl;
*_aPimpl->_b = b;
}

A::~A()
{
	delete _aPimpl;
}

void A::Func1()
{}

void A::Func2()
{}

void A::Func3(std::string file)
{}

//B.cpp
#include "B.hpp"

void B::BSpeciale()
{}

//Main.cpp
#include "A.hpp"
#include "B.hpp"


class MyB: public B
{
public:
	void Something(){}
};

int main()
{
	A myObject(MyB());
	myObject.Func1();
	myObject.Func2();
	myObject.Func3("Hej");

	return 0;
}

Håber det er til at finde rundt i.

Problemet er så vidt jeg kan se at constructoren til A forventer en reference til en B.
MyB() opretter et midlertidigt objekt af typen MyB, men du kan ikke binde en reference af typen B til dette midlertidige objekt.

Hvis du kikker på output af:

#include <iostream>
class A
{
public:
  A(int _i) : i(_i)
  {
     std::cout << "A::A" << std::endl;
  }
  ~A()
  {
     std::cout << "A::~A" << std::endl;
  }
  int i;
};

class B
{
public:
   B(const A& _a) : a(_a)
   {
     std::cout << "B::B" << std::endl;
   }
   ~B()
   {
     std::cout << "B::B" << std::endl;
   }
   const A& a;
};

int main()
{
   B b(A(1));
   std::cout << "Whatever: " << b.a.i << std::endl;
   std::cin.get();
}

Kan du også se hvorfor det ikke er nogen særlig smart konstruktion. Det midlertige objekt (i mit tilfælde af type A, i dit MyB) vil blive nedlagt igen så snart B's constructor afslutter, dvs. inden vi kan nå at gøre brug af det.

Ja det virker jo ikke særlig smart...
Men der må da være en måde at gøre det på. Det virker dumt at skulle lave et "temp"-objekt først. Og man kan da ikke undlade reference/pointer hvis klassen er abstrakt?
Findes der en måde hvorpå man kan skære "temp" væk?
Kan man fx (i konstruktoren) læse referencens data, og så bruge dette til at konstruere den private pointer (dette er vel heller ikke muligt da man ikke kender denne klasse på forhånd)? Er der andre metoder?

Der er andre der har det samme problem:
http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.19
På siden er der også et forslag til en løsning.

Ja, det virker fint.
Tak for det

ps. er der nogen tilfælde hvor det er gyldigt at skrive:

A a(B());
//brug a

Jeg har set følgende i en bog, men da dele af programmet manglede, er jeg ikke sikker på præcis hvad der sker:

class MyWorker: public GTAClient
{
//GTAClient er abstrakt, og denne klasse overskriver de //virtuelle funktioner
};

int main()
{
GenericTableAlgorithm a("Customer", MyWorker());
a.Process();
}

For at være mere præcis:
Jeg har en klasse hvis Konstruktør tager et argument af typen ImplementationDetails. ImplementationDetails er en abstrakt baseklasse, og indeholder de funktioner som min klasse så kalder (min klasse indeholder en pointer til et implementationDetails-objekt). Det er nødvendigt at min klasse ikke kender til ImplementationDetails arvende klasser. I dette er jeg kommet ud for to problemer:
Det første var det med at der var behov for en "temp", hvilket du har svaret på(dog se indlægget ovenfor). Det andet er hvordan jeg gemmer denne temporær, således at dens funktioner overskriver ImplementationDetails virtuelle funktioner. Da den jo kun er temporær hvordan gemmer jeg den så i min klasse?

Hvis du kikker på mit eksempel fra "23-10-06 22:49" kan du se at det virker hvis der er andre argumenter end objekter der der laves med default constructor. Det er det der sker med dit eksempel fra "24-10-06 21:08".

"Nogen" er nødt til at gemme objektet af typen ImplementationDetails indtil klassen der bruger det er færdig med det.
Hvis du igen kikker på mit eksempel fra "23-10-06 22:49" så er linien:
std::cout << "Whatever: " << b.a.i << std::endl;
Ugyldig, b.a eksisterer IKKE på det tidspunkt. a ophørte med at eksistere da b's constructor afslutttede.
Den lette metode er at lade klassen der bruger objektet slette det i sin destructor. For at det kan virke SKAL base klassen have en virtuel destructor:

#include <iostream>
class Base
{
public:
  virtual ~Base()
  {
     std::cout << "Base::~Base" << std::endl;
  }
  virtual void foo() = 0;
};

class B
{
public:
   B(Base* _base) : base(_base)
   {
     std::cout << "B::B" << std::endl;
   }
   void Do()
   {
      base->foo();
   }
   ~B()
   {
      delete base;
      std::cout << "B::~B" << std::endl;
   }
   Base* base;
};

class D : public Base
{
public:
   virtual void foo()
   {
      std::cout << "D::foo" << std::endl;
   }
};
int main()
{
   B b(new D());
   b.Do();
   std::cin.get();
}

Man kan indvende at det er grimt at lade en part oprette et objekt og en anden nedlægge det igen.
Man kan løse dette ved at bruge en "class factory":
http://damb.dk/classfactory.php

Ja, det virker fint.
Tak for hjælpen