#ifndef BASE_CLASS_H
#define BASE_CLASS_H

#include <string>
#include "OtherClass.h"

using std::string;

class BaseClass
{
public:
    static int val;

    BaseClass();
    virtual ~BaseClass(); 
    
    virtual string getString() = 0;

private:
    
};

#endif

#include "BaseClass.h"

int BaseClass::val = 5;

BaseClass::BaseClass()
{
}

BaseClass::~BaseClass()
{
}

#ifndef CHILD_CLASS_H
#define CHILD_CLASS_H

#include "BaseClass.h"

class ChildClass : public BaseClass
{
public:
    ChildClass();

    string getString();
};

extern "C" BaseClass * create();

#endif

#include "ChildClass.h"

ChildClass::ChildClass(): BaseClass()
{
    OtherClass oc(4);
    oc.getValue();
}

string ChildClass::getString()
{
    return "child class";
}

BaseClass * create()
{
    return new ChildClass();
}

#ifndef OTHER_CLASS_H
#define OTHER_CLASS_H

class OtherClass
{
public:
    OtherClass(int value);
    int getValue();

private:
    int value;
};

#endif

#include "OtherClass.h"

OtherClass::OtherClass(int value)
{
    this->value = value;
}

int OtherClass::getValue()
{
    return value;
}

#include "BaseClass.h"

#include <iostream>
#include <dlfcn.h>

using std::cout;
using std::endl;

int main()
{
    typedef BaseClass * (*CreateFunc)();

    void *handle = dlopen("./libsltest.so.1.0", RTLD_NOW);
    if (handle)
    {
        cout << "loaded library" << endl;
        CreateFunc cf = (CreateFunc)dlsym(handle, "create");
        
        if (cf)
        {
            cout << "loaded create function" << endl;
            BaseClass *b = cf();
            cout << b->getString() << endl;
            dlclose(handle);

            cout << BaseClass::val << endl;
            cout << b->val << endl;
        }
        else
        {
            cout << "could not load create function" << endl;
        }
    }
    else
    {
        cout << "could not load library" << endl;
    }
    
    return 0;
}