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.
// main.cpp
#include <iostream>
#include <dlfcn.h>
#include <stdio.h>
#include <unistd.h>
#include "commonClas s.h"
#include "sharedClas s.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 "commonClas s.h"
void commonClass::pr int() {
// I CAN'T see changes here without re-running the application
std::cout << "commonClas s: 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 "sharedClas s.h"
#include "commonClas s.h"
void sharedClass::pr int() {
commonClass cc;
// I CAN see changes here without re-running the application
std::cout << "sharedClas s: ";
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
