dynamically instantiate a class

[Sumit Nagpal]

Hi All,

My application reads a 'Class' name (as a string) from a file at Run time.
Can i create an instance this Class ?

Thanks
Sumit

[Sumit Nagpal]

Yeah but if I do extern 'C' for that particular symbol, there wont be
any name mangling problem.

Thanks
Sumit Nagpal
Gianni Mariani wrote:

Sumit Nagpal wrote:

I certainly have to go for FACTORY method but in my case I need
something more...
I think 'dlsym' should work for me !

Warning ... try to steer away from dlsym. This reqyures you to know
what the mangling convention is - this is not portable.

Austria C++ (Shameless plug) has a solution for you and it works with
DLL's or DSO's.

Below is an example.
-------------- test code ------------------

#include "interface. h"

#include "at_factory .h"

using namespace at;
#include <iostream>
#include <dlfcn.h>
void Test( Interface * ptr )
{
if ( ! ptr )
{
std::cout << "There is no ptr\n";
return;
}

std::cout << "Thingy() = " << ptr->Thingy() << "\n";
std::cout << "Thingy1() = " << ptr->Thingy1() << "\n";
std::cout << "Thingy2() = " << ptr->Thingy2() << "\n";

bool is_del = false;

ptr->MarkPtr( & is_del );

delete ptr;

std::cout << ( is_del ? "Deleted" : "Not Deleted" ) << "\n";

}
void testfactory()
{
Interface * ptr =
FactoryRegister < Interface, DKy, Creator1P< Interface, DKy,
const char * > >
::Get().Create( "ImplementorKEY " )( "contructor param" );

Test( ptr );

ptr =
FactoryRegister < Interface, DKy, Creator2P< Interface, DKy,
const char *, const char * > >
::Get().Create( "ImplementorKEY " )( "contructor param1",
"contructor param2" );

Test( ptr );
}

void loaddso()
{
if ( ! dlopen( "xxx_dso.so ", RTLD_LAZY ) )
{
std::cerr << "dlopen error is: " << dlerror();
}
}

int main()
{

/* output should be :
There is no ptr
There is no ptr
*/

testfactory();

// load the objects ...
loaddso();

/*output should now be :
Thingy() = contructor param
Thingy1() =
Thingy2() =
Deleted
Thingy() = contructor param1
Thingy1() = contructor param2
Thingy2() =
Deleted
*/

testfactory();

}

------------------- interface.h -------------------------

class Interface
{

public:

virtual const char * Thingy() = 0;
virtual const char * Thingy1() = 0;
virtual const char * Thingy2() = 0;

bool * mark_del;

Interface()
: mark_del( 0 )
{
}

virtual ~Interface()
{
if ( mark_del )
{
* mark_del = true;
}
}

void MarkPtr( bool * i_mark_del )
{
mark_del = i_mark_del;
}

virtual int ContructParamCo unt() = 0;

};
--------------- implementation code ---- xxx_dso.cpp ----------

#include "interface. h"

#include "at_factory .h"

using namespace at;
class Implementor
: public Interface
{

public:

virtual const char * Thingy()
{
return m_str;
}

virtual const char * Thingy1()
{
return m_str2;
}

virtual const char * Thingy2()
{
return m_str3;
}

Implementor( const char * str, const char * str2, const char *
str3 )
: m_str( str ),
m_str2( str2 ),
m_str3( str3 ),
contruction_par ameter_count( 3 )
{
}

Implementor( const char * str, const char * str2 )
: m_str( str ),
m_str2( str2 ),
m_str3( "" ),
contruction_par ameter_count( 2 )
{
}

Implementor( const char * str )
: m_str( str ),
m_str2( "" ),
m_str3( "" ),
contruction_par ameter_count( 1 )
{
}

Implementor()
: m_str( "" ),
m_str2( "" ),
m_str3( "" ),
contruction_par ameter_count( 0 )
{
}

virtual int ContructParamCo unt()
{
return contruction_par ameter_count;
}

int contruction_par ameter_count;

const char * m_str;
const char * m_str2;
const char * m_str3;
};
AT_MakeFactory0 P( "ImplementorKEY ", Implementor, Interface, DKy );
AT_MakeFactory1 P( "ImplementorKEY ", Implementor, Interface, DKy, const
char * );
AT_MakeFactory2 P( "ImplementorKEY ", Implementor, Interface, DKy, const
char *, const char * );
AT_MakeFactory3 P( "ImplementorKEY ", Implementor, Interface, DKy, const
char *, const char *, const char * );

[Sumit Nagpal]

You are right but I was talking about the situations where I'll have
multiple unkown plugins.
Now I have the solution for it 'dlsym' which will allow me to
instantiate all plugin classes with all plugin.so having 'Create' functions.

Thanks
Sumit
Karl Heinz Buchegger wrote:

Sumit Nagpal wrote:

Perhaps I didnt ask my question in properly.

Say, I write some code in core.so and some other person writes plugin.so
& plugin.txt
plugin.txt has a string "MyClass"
plugin.so has the definition of MyClass

While writing core.so I dont know anything about MyClass.

Right.

I would do it this way:
All your plugins contain one class, which represents the plugin.
All those classes are derived from a common base class. All the
core knows about is a collection of pointers to those in order
to route commands to them.
So how then is the real plugin object created?
Simple: Each plugin.so has a function 'Create' which creates
the real plugin object and returns a pointer to it. And the
plugin.so knows about its real class.