class *a = new ?;

[feribiro]

Hi,

could you tell me please how it is possible to pass the type of a
class to a function as a parameter, and then initiate a new class of
that type?

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

void Main()
{
Create(B);
Create(C);
}

void Create(??? param)
{
A *a = new ??param??;
delete a;
}

Thank you very much

[SG]

You cannot do this dynamically like in other languages which keep
enough meta data about classes in memory for "reflection" (I'm
thinking of Java in this case) -- at least not without getting your
hands dirty (building registries, registering types, etc by yourself).

But you can do it easily at compile-time. In your case ("Create(B);")
you already know the type at compile-time (B)...

class A
{
public:
virtual ~A() {}
//...
};

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

template<typename T>
void Create()
{
A* a = new T;
delete a;
}

int main()
{
Create<B>();
Create<C>();
}

Note: The class A must have a virtual destructor because you invoke
delete with a pointer of type A* that points to a possibly derived
object. Inheritance must be public in your case. The main function's
name is all lower case and its return type is int.

Cheers,
SG

[Pascal J. Bourguignon]

SG <s.ges...@gmail.com> writes:

> On 28 Sep., 13:14, feribiro <ferib...@index.hu> wrote:
>> Hi,
>>
>> could you tell me please how it is possible to pass the type of a
>> class to a function as a parameter, and then initiate a new class of
>> that type?
>>
>> class A {...}
>> class B : public A {...}
>> class C : public A {...}
>>
>> void Main()
>> {
>>  Create(B);
>>  Create(C);
>> }
>>
>> void Create(??? param)
>> {
>>  A *a = new ??param??;
>>  delete a;
>> }
>>
>> Thank you very much
>
> You cannot do this dynamically like in other languages which keep
> enough meta data about classes in memory for "reflection" (I'm
> thinking of Java in this case) -- at least not without getting your
> hands dirty (building registries, registering types, etc by yourself).

Well this can be done easily enough with boost::lambda.
Or somewhat less easily by defining factory functions.

typedef A* (*factory)();
A* makeInstance_B(){ return new B(); }
A* makeInstance_C(){ return new C(); }

void Create(factory f){
A* a=f();
a->doSomething();
delete a;
}

Create(&makeInstance_B);
Create(&makeInstance_C);

--
__Pascal Bourguignon__

[feribiro]

Thank you guys!