testrtti.cpp

java 反射机制详解示例,实现类属性及方法修改

#include <stdio.h>
#include "reflect.h"

#ifndef USE_DEBUG_INFO
#include "typedecl.h"
#else
#include "bfdreflect.h"
#endif

class A { 
  public:
    int   a;
    char* b;
   private:
    unsigned short c;
    long l[10];
#ifndef USE_DEBUG_INFO    
   public:
    RTTI_DESCRIBE_STRUCT((RTTI_FIELD(a, 0), RTTI_PTR(b, 0), RTTI_FIELD(c, 0), RTTI_ARRAY(l, 0)));
#endif
}; 

class B { 
  public:
    A*  p;
    A   arr[4];
    A** parr;

    virtual void foo(); 
    char* echo(char* p); 
    int func(A* ap, int x, double* p);
#ifndef USE_DEBUG_INFO    

    RTTI_DESCRIBE_CLASS(B, (RTTI_PTR(p, 0), RTTI_ARRAY(arr, 0), RTTI_PTR_TO_PTR(parr, 0)), 
			(RTTI_PROC(foo, RTTI_MTH_VIRTUAL), RTTI_FUNC(echo, 0), RTTI_FUNC(func, 0)));
#endif
};

void B::foo() { 
    printf("B::foo()\n");
}

char* B::echo(char* p) { 
    printf("echo(%s)\n", p);
    return p;
}

int B::func(A* ap, int x, double* p) { 
    printf("func(ap=%p, x=%d, p=%p)\n", ap, x, p);
    return 0;
}


class C;


class D : public A, public B { 
    C* ptr;
    
  public:
    void f(C* p); 
    char const* hello(char const* s);
    void foo(); 

#ifndef USE_DEBUG_INFO    
    RTTI_DESCRIBE_CLASS(D, (RTTI_BASE_CLASS(A, 0), RTTI_BASE_CLASS(B, 0), 
			    RTTI_PTR(ptr, RTTI_FLD_PRIVATE)),
			(RTTI_PROC(f, 0), RTTI_PROC(foo, 0), RTTI_FUNC(hello, 0)));
#endif
};

void D::f(C* p) { 
    printf("f(%p)\n", p);
}
    
char const* D::hello(char const* s) { 
    puts(s);
    return s;
}

void D::foo() { 
    printf("D::foo()\n");
}


struct Point { 
    double x;
    float  y;
    
#ifndef USE_DEBUG_INFO
    RTTI_DESCRIBE_STRUCT((RTTI_FIELD(x, 0), RTTI_FIELD(y, 0)));
#endif
};

class C { 
   public:
    C();
    
    Point p;
    char* str;
    char const* cstr;

#ifndef USE_DEBUG_INFO
    RTTI_DESCRIBE_STRUCT((RTTI_FIELD(p, 0), RTTI_PTR(str, 0), RTTI_PTR(cstr, 0)));
#endif
};



C::C() {
    printf("C default constructor\n");
}
    



#ifndef USE_DEBUG_INFO
RTTI_REGISTER_STRUCT(A, 0);
RTTI_REGISTER_CLASS(B, 0);
RTTI_REGISTER_CLASS(C, 0);
RTTI_REGISTER_CLASS(Point, 0);
RTTI_REGISTER_CLASS(D, 0);
#endif

int main(int argc, char* argv[]) { 
    RTTIClassDescriptor* cls;
    char buf[1024];
    int i;

#ifdef USE_DEBUG_INFO
    RTTIRepository* repo = RTTIBfdRepository::getInstance();
    if (!repo->load(argv[0])) { 
      printf("Failed to read debug information\n");
      return 1;
    }
#else
    RTTIRepository* repo = RTTIRepository::getInstance();	
#endif

    for (cls = repo->getFirstClass(); cls != NULL; cls = cls->getNext()) { 
	printf("Class %s", cls->getName());
	int nBaseClasses = cls->getNumberOfBaseClasses();
	RTTIClassDescriptor** bases =  cls->getBaseClasses();
	int sep = ':';
	for (i = 0; i < nBaseClasses; i++) { 
	    printf("%c %s", sep, bases[i]->getName());
	    sep = ',';
	}
	printf("\n");
	RTTIFieldDescriptor** fd = cls->getFields();
	int nFields = cls->getNumberOfFields();
	for (i = 0; i < nFields; i++) { 
	    fd[i]->getType()->getTypeName(buf);
	    printf("\t%s \t%s; \t// offset %d, size %d\n", buf, fd[i]->getName(), 
		   fd[i]->getOffset(), fd[i]->getSize());
	}
	RTTIMethodDescriptor** md = cls->getMethods();
	int nMethods = cls->getNumberOfMethods();
	for (i = 0; i < nMethods; i++) { 
	    md[i]->getMethodDeclaration(buf);
	    printf("\t%s\n", buf);
	}
	printf("\n\n");
    }
    cls = repo->findClass("B");

    RTTIMethodDescriptor* mth = cls->findMethod("foo");
    void* params[5];
    B* b = new B();    
    mth->invoke(NULL, b, params); // should print B::foo

    D* d = new D();
#if defined(__GNUC__) && __GNUC_MAJOR__ >= 3
    mth->invoke(NULL, d, params); // should print D::foo
#endif
    mth = cls->findMethod("echo");
    char* p = "Hello World";
    params[0] = &p;
    char* q;
    mth->invoke(&q, b, params); // should print echo(Hello world)
    printf("Return '%s'\n", q);

    mth = cls->findMethod("func");
    A* ap = (A*)1;
    int x = 2;
    double* dp = (double*)3;
    params[0] = &ap;
    params[1] = &x;
    params[2] = &dp;
    mth->invoke(&x, b, params); // should print func(ap=1, x=2, p=3)
    printf("Return %d\n", x);   // Return 0
    
    cls = repo->findClass("C");
    C* cp = (C*)cls->newInstance();
    printf("cp=%p\n", cp);

    cls = repo->findClass("D");
    mth = cls->findMethod("f");
    params[0] = &cp;
    mth->invoke(NULL, d, params); // should print f(cp)   
    
    mth = cls->findMethod("hello");
    p = "Good bye";
    params[0] = &p;
    mth->invoke(&q, d, params); // should print "Good bye"
    printf("Return '%s'\n", q);

    // cleanup
    delete b;
    delete d;
    delete cp;

    return 0;
}