Shared object linking problem

[izhar . wallach]

Hi,
I'm trying to write an application which have a component that I like
to modify without restarting it.
Thus, I was thinking of using a shared object for that component.
However, in the example below, I haven't figured out a way to modify
commonClass.cpp (for example, the print() method) and be able to see
the changes without rerunning  the application. I can see changes made
directly in sharedClass.cpp, though. Is there a way to see changes in
commonClass.cpp without restarting the application?

Thanks,
Izhar.
(I have posted it at comp.lang.c++ before).

// main.cpp
#include <iostream>
#include <dlfcn.h>
#include <stdio.h>
#include <unistd.h>
#include "commonClass.h"
#include "sharedClass.h"

sharedClass* sharedClass_SO = NULL;
int main() {
  while( true ) {
    commonClass cc;
    cc.print();
    void *handle = dlopen ( "sharedClass.so", RTLD_NOW );
    if( handle == NULL ) {
      std::cerr << dlerror() << std::endl;
      exit( -1 );
    }
    sharedClass_SO->print();
    delete sharedClass_SO;
    dlclose( handle );
    int x;
    std::cin >> x;
  }
  return 0;

}

// commonClass.h
#ifndef _COMMON_CLASS_H_
#define _COMMON_CLASS_H_
class commonClass {
  public:
    commonClass(){};
    void print();
};

#endif

//commonClass.cpp
#include <iostream>
#include "commonClass.h"

void commonClass::print() {
    // I CAN'T see changes here without re-running the application
    std::cout << "commonClass: XXXXXX" << std::endl;

}

// sharedClass.h
#ifndef _SHARED_CLASS_H_
#define _SHARED_CLASS_H_
class sharedClass {
  public:
    sharedClass(){};
    virtual ~sharedClass() {};
    virtual void print();

};

extern sharedClass* sharedClass_SO;
#endif

// sharedClass.cpp
#include <iostream>
#include "sharedClass.h"
#include "commonClass.h"

void sharedClass::print() {
  commonClass cc;
  // I CAN see changes here without re-running the application
  std::cout << "sharedClass: ";
  cc.print();

}

extern "C" {
  sharedClass* maker() {
    return new sharedClass();
  }
  class proxy {
    public:
      proxy() {
        sharedClass_SO = maker();
      }
  };
  proxy p;

}

// Makefile
all: main sharedClass.so

commonClass.o: commonClass.cpp
        g++ -Wall -c commonClass.cpp
sharedClass.o: sharedClass.cpp commonClass.o
        g++ -Wall -c sharedClass.cpp
sharedClass.so: sharedClass.o
        g++ sharedClass.o -shared -o sharedClass.so
main.o: main.cpp
        g++ -rdynamic -Wall -c main.cpp

main: main.o commonClass.o
        g++ -rdynamic main.o commonClass.o -ldl -o main

clean:
        /bin/rm -f main *.o *.so