Create object instance of different types

[f.f]

class A
{
....
};

class B : public A
{
....
};

class C : public A
{
....
};

T* createObject()
{
T* ptr = new T();
return ptr;
}

I wanna use createObject() to create object instance of either class B
or class C?
What approach should I use? Should I use template?

f.f

 

[Andre Kostur]

class A
{
...
};

class B : public A
{
...
};

class C : public A
{
...
};

T* createObject()
{
T* ptr = new T();
return ptr;
}

I wanna use createObject() to create object instance of either class B
or class C?
What approach should I use? Should I use template?

How does createObject know which of A, B, or C to create? Offhand I
don't see how a template makes it easier:

template<class T>
T * createObject()
{
return new T();
}

All this seems to do is obfuscate the code by hiding the use of "new",
since you'd have to specify the type to be created at the call site
anyway. Why not just use "new" whererever you're using "createObject"?

 

[red floyd]

class A
{
...
};

class B : public A
{
...
};

class C : public A
{
...
};

T* createObject()
{
T* ptr = new T();
return ptr;
}

I wanna use createObject() to create object instance of either class B
or class C?
What approach should I use? Should I use template?

You might want to google for "Factory Pattern"

 

[Sandip Shahane]

And if you have not already got the precise reference, foll. might just
be something you can do.
http://www.codeproject.com/cpp/SimpleDynCreate.asp

this is specially useful if u wanna add new derived classes in future.
also along with extensibility, some folks try to make the class and its
creator function registeration externally or thru macro as in

http://www.codeproject.com/cpp/ratkfactory.asp

sandip shahane

 

[f.f]

Thank you all. I will try the factory pattern.

f.fwrote: