C / C++ / MFC

Gjm wrote:

Will a destructor, with an empty body, deallocate the memory taken for the object when the object goes out of scope??

main ()
{
// memory for blah is allocated at beginning of main, and 

   abc  blah;   // blah's constructor called now.
   ;
   ;
// blah goes out of scope, so destructor is called, and the the memory it took up is release.
}

main ()
{
   abc *pBlah = new abc; // memory for an abc object is allocated, then constructor called
   ;
   ;
   delete pBlah; // object's constructor called now, then the memory taken is freed.
}

Tomas(cz) wrote:

if it is possible to create a new object of some type when i only have the object type_info

Tomas(cz) wrote:

I need to have a map that stores a pair and than a function that returns new object (all the objects are derived from one base class) according to the the id in the map.

#include <map>
#include <iostream>
#include <typeinfo>

struct base_class { virtual int GetID() = 0; };

struct A : public base_class { int GetID() { return 1; } };
struct B : public base_class { int GetID() { return 2; } };

typedef base_class* BasePtr;

typedef std::map<int, BasePtr (*)()> ObjectCreationMap;

template<class ObjectType>
base_class* CreateObject() { return new ObjectType(); }

base_class* GetObject(int id)
{
   static ObjectCreationMap myMap;
   if (myMap.empty())
   {
#define INSERT(ID, TYPE) myMap.insert(std::make_pair(ID, &CreateObject<TYPE>));
      INSERT(1, A)
      INSERT(2, B)
#undef INSERT
   }
   ObjectCreationMap::iterator iter = myMap.find(id);
   if( iter != myMap.end() )
   {
      return iter->second();
   }
}

int main()
{
   BasePtr x = GetObject(1);
   std::cout << x->GetID() << " " << typeid(*x).name() << std::endl;
   x = GetObject(2);
   std::cout << x->GetID() << " " << typeid(*x).name() << std::endl;
}

class SerializationMap
{
public:
	typedef Base_Object* objectPtr;
	static std::map <int,objectPtr (*)()> map; // don't know why it doesn't show <> - it is declared the same way like in the previous post
};

template<class OBJECT_TYPE>;
Base_Object* CreateObject()
{
	return new OBJECT_TYPE();
}

#define REGISTER_CLASS(ID,TYPE) SerializationMap::map.insert(std::make_pair(ID, &CreateObject<TYPE>));

base_object class

#include "SerializationMap.h"

class Base_Object
{
public:
        REGISTER_CLASS(1,Base_Object)
	Base_Object(void);
	~Base_Object(void);
	Base_Object(const Base_Object& obj);
	void operator =(const Base_Object& obj);
	int archive_version;

private:
	int serializationClassId;
};

Tomas(cz) wrote:

// don't know why it doesn't show <> - it is declared the same way like in the previous post

Tomas(cz) wrote:

template;

Tomas(cz) wrote:

REGISTER_CLASS(1,Base_Object)

alashara wrote:

not necessarily ms word

alashara wrote:

>Speaking of efficiency... why are *you* asking this question, rather than the programmer?
I am sure he would if he could.

SPropValue PropVal;<br />
PropVal.Value.lpszW = L"C:\\rahul";