C / C++ / MFC

ThreadInfo *pInfo = reinterpret_cast<threadinfo> (pParam);
ThreadInfo info = *pInfo;
delete pInfo;</threadinfo>

void CFredoDlg::OnDestroy()
{
	//delete threads;
	for(vector<handle>::size_type i = 0; i < threads.size(); i++)
	{
		threads.erase(threads.begin() + i);
	}

}</handle>

keret wrote:

But the 68B and 46B blocks are still there

keret wrote:

Now I will try to find a way to terminate the threads. If you have a solution for that, don't keep it!

InterlockedExchange(&letsExitNow, 1);

while (!letsExitNow && IsWindow(pInfo->hMonitoredWindow))

LONG letsExitNow;

extern LONG letsExitNow;

public:
LONG letsExitNow 

InterlockedExchange(&letsExitNow, 0);

extern LONG letsExitNow;

NeoAks007 wrote:

Now the problem is that I am not able to specify any return type since it depends upon the condition which is known at runtime. I tried to introduce template as:

N a v a n e e t h wrote:

You can return pointer to this abstract class instantiated with proper derived one.

class DummyBase {};

class B : public DummyBase{
      // Class Definitions
};
class C : public DummyBase{
      // Class Definitions
};

class A{
public:
      B obj1;
      C obj2;
      DummyBase* search(int condition)  //What do I specify return type???
      {
            if(condition==1)
                  return &obj1;
            if(condition==2)
                  return &obj2;
            if(condition==3)
                  return this;
      }
};

class Car{
public:
    virtual string SayName() = 0;
};

class Mercedez : public Car{
public:
    string SayName(){
	return "Mercedez";
    }
};

class Ferrari : public Car{
public:
    string SayName(){
	return "Ferrari";
    }
};

Car* CreateACar(string carType){
    if(carType == "Mercedez")
       return new Mercedez;
    else if(carType == "Ferrari")
       return new Ferrari;
}

Car* car = CreateACar("Mercedez");
std::cout << car->SayName();

class B and C are:<br />
<pre><code><br />
class DummyBase {};<br />
<br />
template <'class abc'><br />
class Base{<br />
public:<br />
      abc func1();<br />
};<br />
<br />
class B : public Base`<datatype1`>, DummyBase{<br />
      // Class Definitions<br />
};<br />
class C : public Base`<datatype2`>, DummyBase{<br />
      // Class Definitions<br />
};<br />
<br />
class A: public Base`<datatype3`>, DummyBase{<br />
public:<br />
      B obj1;<br />
      C obj2;<br />
      DummyBase* search(int condition)  //What do I specify return type???<br />
      {<br />
            if(condition==1)<br />
                  return &obj1;<br />
            if(condition==2)<br />
                  return &obj2;<br />
            if(condition==3)<br />
                  return this;<br />
      }<br />
};<br />
<br />
void main()<br />
{<br />
      DummyBase *ptr;<br />
      A objA;<br />
      int n;<br />
      cin>>n;<br />
      ptr = objA.search(n);<br />
      ptr->func1();                   //Error : Since DummyBase does not contain func1()<br />
}<br />

class DummyBase { virtual ~DummyBase() {} };

template <'class abc'>
class Base{
public:
      abc func1();
};

class B : public Base`<datatype1`>, DummyBase{
   virtual ~B() {}
      // Class Definitions
};
class C : public Base`<datatype2`>, DummyBase{
   virtual ~C() {}
      // Class Definitions
};

class A: public Base`<datatype3`>, DummyBase{
public:
      B obj1;
      C obj2;
      DummyBase* search(int condition)  //What do I specify return type???
      {
            if(condition==1)
                  return &obj1;
            if(condition==2)
                  return &obj2;
            if(condition==3)
                  return this;
      }
};

void main()
{
      DummyBase *ptr;
      A objA;
      int n;
      cin>>n;
      ptr = objA.search(n);
      if (B* bPtr = dynamic_cast<B*>(ptr))
      { bPtr->func1(); }
      if (C* bPtr = dynamic_cast<C*>(ptr))
      { bPtr->func1(); }
}

Stuart Dootson wrote:

Yeah, it sucks because you're taking so many decisions.

Stuart Dootson wrote:

But I've not really put sufficient thought into it to think of a better one.

Stuart Dootson wrote:

Possibly something like Boost.Variant or Boost.Any might make things nicer.

#include <iostream>
#include <boost/variant.hpp>

template <class abc>
class Base{
public:
   abc func1();
};

class B : public Base<int>{
public:
   virtual ~B() {}
      // Class Definitions
};
class C : public Base<float>{
public:
   virtual ~C() {}
      // Class Definitions
};

class A: public Base<char>{
public:
   B obj1;
   C obj2;
   boost::variant<A*, B*, C*> search(int condition)  //What do I specify return type???
   {
      if(condition==1)
         return &obj1;
      if(condition==2)
         return &obj2;
      if(condition==3)
         return this;
   }
};

int main(int, char**)
{
   A objA;
   int n;
   std::cin>>n;
   boost::variant<A*, B*, C*> v = objA.search(n);
   if (B* b = boost::get<B*>(v))
   {
      b->func1();
   }
   else if (C* c = boost::get<C*>(v))
   {
      c->func1();
   }
   return 0;
}

NeoAks007 wrote:

Is there no way to reduce coding at caller side??

Stuart Dootson wrote:

If you want to handle them n the same way, then why not make them the same?