Subclass as a dynamic library

[daylond]

I'm developing a robot control architecture, and am trying to maximize platform independence (robot hardware, not OS) by generating my individual behaviors as dynamic libraries. The individual behaviors are subclasses of the Leaf class, which is in turn a subclass of the Behavior class. I want to keep the Behavior and Leaf objects in the main program but generate the individual behaviors (e.g. Wander) in shared object files so I can load the specific behavior at run time. I want to access the generated objects through the superclass. That is, if included in the code, I would create the object using

Behavior * myBeh = new Wander;

. This works fine. When using dlopen, I use

void *hndl = dlopen(filename.c_str(), RTLD_LAZY);  // dynamically load the library, we'll try to handle errors later.
            if(hndl == NULL)
            {
                cerr << "File Boo Boo: " <<  dlerror() << endl;
                exit(-1);
            }
            cout << "loaded " << name << " behavior." << endl;
            create_t* create_type = (create_t*) dlsym(hndl, "maker");  // run maker function to generate instance
            if (!create_type)
            {
                cerr << "Symbol Boo Boo: " << dlerror() << '\n';
                exit(1);
            }
            beh = create_type();

I keep running into the "Symbol Boo Boo". I suspect the problem is in the creation of my library. The (pertinent) Wander code is

#include "Wander.h"
 
Wander::Wander()
{
    ...
}
 
Wander::~Wander()
{
    ...
}
 
Behavior * Wander::maker()
    {
        return new Wander;
    };
 

and the Wander.h file is

#ifndef _WANDER_H
#define _WANDER_H
 
#include <pthread.h>
#include <string>
 
#include "../../State.h"
#include "../Action.h"
#include "../Leaf.h"
 
using namespace std;
 
#define PI 3.14159265359
 
class Wander : public Leaf
{
private:
    pthread_mutex_t mutex;
    pthread_t behaviorthread;
 
    State* curr_state;
    Action* curr_action;
 
    int turnCounter;
    double velocity;
    double turnrate;
 
    void Lock();
    void Unlock();
 
    static void* DummyMain(void*);
 
public:
    Behavior * maker();
    Wander();
    virtual ~Wander();
 
    void StartThread();
    void StopThread();
 
    void Main();
 
    Action* updAction(State* curr_state);
    Action* genAction();
};
 
#endif
 

my Leaf.h file is:

#ifndef LEAF_H
#define LEAF_H
 
#include "Behavior.h"
#include "Action.h"
/**
 * A simple behavior, that is, one that is comprised of only a
 * single goal.
 */
class Leaf: public Behavior
{
public:
 
    virtual Behavior * maker()
    {
        return NULL;
    };
    Leaf(){}
    virtual ~Leaf()
    {}
 
    virtual Action* genAction()
    {
        return NULL ;
    }
    virtual void StartThread()
    {};
    virtual void StopThread()
    {};
};
#endif /* LEAF_H */
 

Finally, my Behavior.h file is

#ifndef _BEHAVIOR_H
#define _BEHAVIOR_H
 
#include    <vector>
#include <string>
 
#include    "Action.h"
 
using namespace std;
/**
 * Base class for the robot behaviors.
 */
class Behavior
{
protected:
    string name;
public:
    virtual Behavior * maker()
    {
        return NULL;
    };
    Behavior()
    {}
    virtual ~Behavior()
    {}
 
    /**
     * Generate an Action based on the current State.
     */
    virtual Action* genAction()
    {
        return NULL ;
    }
    virtual void StartThread()
    {}
    ;
    virtual void StopThread()
    {}
    ;
};
 
typedef Behavior * create_t();
 
#endif /* _BEHAVIOR_H */
 

any ideas?