pointer to pointer to heap

[slomoman]

I'm not sure about this:

Does this work?

classA::classA(){
  classA1 pa1 = new classA1;
  classA2 pa2 = new classA2(pa1);
}

classA2::classA2(classA1* p){
  m_pa1 = p; //Member-Variable
}

Later, I create a Thread that gets a pointer to m_pa1 and uses this pointer even after pa2 is destroyed.

threadFunctionBla(..){
  classA2* pa2 = //get out of parameter//;
  classA1* pa1 = pa2->m_pa1;
  //do somwthing.
  //classA2 is detroyed now by another Thread
  pa1->doSomething(); //does this work? I get strange results.

i now it's confusing. if anybody sees any errors or wants to show a btter way, i'd be glad.

[gjs368]

classA2* pa2 = //get out of parameter//;
  classA1* pa1 = pa2->m_pa1;
  //do somwthing.
  //classA2 is detroyed now by another Thread
  pa1->doSomething(); //does this work? I get strange results

This is very hard to follow. You use the same names for the variables in the definition for ClassA and threadFunctionBla(..).
If i am following correctly, you seem to say that the pa2 variable in threadFunctionBla(..) really ends up pointing to an invalid address because of the statement:

//classA2 is detroyed now by another Thread

If this is the case, the call:

pa1->doSomething(); //does this work?

can't "work" properly, since pa2->m_pa1 is also now an invalid address. (classA1* pa1 = pa2->m_pa1)

[Rabelo]

A simple way to work around this is using semaphores, setting a global variable indicating if the object is already destroyed or not.

the following code is an exemple of this thecnic (not tested)

:	
	
class A1
{
  ...
  int * Semaphore;
  A1(int * PSemaphore);
  ~A1();
  ...
}

A1::A1(int* PSemafhore):Semaphore(PSemaphore)
{
  ...
 *Semaphore = 1 ;    //--- Semaphore sinalizes if A1 is alive.
  ...
};

A1::~A1()
{
   *Semaphore = 0;    //--- A1 is destroyed....
}

class A2
{
   ...
   int * A1Alive;
   A2(int* PA1Alive);   // on construction A1 recieves the  semaphore
   ...
   inline bool CheckA1Alive() { return *A1Alive == true;};

   public:
  
  void UseA1();
}

A2::A2(int * PA1Alive):A1Alive(PA1Alive){}; 
 
void A2::UseA1()
{

  if (CheckA1Alive)
  {
     // work with A1...
  }
  else
  {
     // A1 is destroyed, nothing to do...
  }
}

main()
{
  int Semaphore = 0;
	
  A1(&Semaphore);  
	
  ...

  A2(&Semaphore);  // A2 needs to get ride of the semaphore
  A2.UseA1();	
  ...

:



[Bassman]

can't "work" properly, since pa2->m_pa1 is also now an invalid address.

Not neccessarily true.

Dereferencing pa2 will naturally fail, but:

classA1* pA1 = pA2->m_pA1;
delete pA2;
pA1->DoSomething();

can work fine, provided the destructor for classA2 doesn't explicitly delete m_pA1.

Regards,
Bassman

[slomoman]

thx bassmann.
no, classA2 does not delete m_pA1. But it may set
m_pA1 = 0;
Would this be a problem

[Bassman]

No, as long as you call

pA1 = pA2->m_pA1;

before

pA2->m_pA1 = 0;

executes (obviously). Setting the pointer to 0 or even to another valid value won't delete the object that it points to.

Regards,
Bassman