rtti

I've recently posted a question in this forum asking for any advice regarding missing RTTI information in a DXE2 executable. That post was a stripped down version of my actual case. RRUZ came to the rescue, and so the stripped down version was quickly resolved. The original problem, though, is still standing, and so I'm posting it in full now. "Main": program MissingRTTI; {$APPTYPE CONSOLE} uses System.SysUtils, RTTI, MyUnit in 'MyUnit.pas', RTTIUtil in 'RTTIUtil.pas'; var RHelp: TRttiHelper; begin RHelp := TRttiHelper.Create(); if (RHelp.IsTypeFound('MyUnit.TMyClass')) then WriteLn('TMyClass

We can use the SuperObject library to invoke methods of a certain object by its name and giving its parameters as a json string using the SOInvoker method like in this answer I'd like to know how do I send a created object as a parameter. I tried to send it like LObjectList := TObjectList.Create; LSuperRttiCtx := TSuperRttiContext.Create; LSuperObjectParameter := LObjectList.ToJson(LSuperRttiCtx); SOInvoke(MyInstantiatedObject, 'MyMethod', LSuperObjectParameter); but inside MyMethod the LObjectList reference is lost. What am I doing wrong? The superobject library can be downloaded here It will

What are the memory/performance overheads of enabling RTTI in a C++ program? Can anyone please throw some light between the internal implementation of RTTI mechanism and the relevant overheads? I do understand how to use RTTI through typeid and dynamic_cast , what I am trying to know is the internal implementation details of how the run time keeps track of this information and how it is an overhead? Enabling RTTI typically brings only a small overhead. The usual implementation carries a pointer to the type information structure in the vtable of an object. Since the vtable must be constructed

How to simulate C# typeof-command behavior in C++? C# example: public static PluginNodeList GetPlugins (Type type) { ... } Call: PluginManager.GetPlugins (typeof(IPlugin)) How to implement this using C++? Maybe QT or Boost libraries provide a solution? What about the case if you want to implement .GetPlugins(...) in a way that it loads those kinds of objects from a file (.so or .dll)? You could use a dynamic_cast to test types as shown below: IPlugin* iPluginPtr = NULL; iPluginPtr = dynamic_cast<IPlugin*>(somePluginPtr); if (iPluginPtr) { // Cast succeeded } else { // Cast failed } This

Can anybody tell me how to activate RTTI in c++ when working on unix. I heard that it can be disabled and enabled. on my unix environment,how could i check whether RTTI is enabled or disabled? I am using the aCC compiler on HPUX. Are you using g++ or some other compiler? In g++ RTTI is enabled by default IIRC, and you can disable it with -fno-rtti . To test whether it is active or not use dynamic_cast or typeid UPDATE I believe that HPUX's aCC / aC++ also has RTTI on by default, and I am unaware of a way to disable it. Check your man pages . gcc has it on by default. Check if typeid(foo).name(

We often hear/read that one should avoid dynamic casting. I was wondering what would be 'good use' examples of it, according to you? Edit: Yes, I'm aware of that other thread : it is indeed when reading one of the first answers there that I asked my question! Mark Ransom This recent thread gives an example of where it comes in handy. There is a base Shape class and classes Circle and Rectangle derived from it. In testing for equality, it is obvious that a Circle cannot be equal to a Rectangle and it would be a disaster to try to compare them. While iterating through a collection of pointers to

Although I'm doubtful, I'm curious as to whether it's possible to extract primitive-type template parameters from an existing type, perhaps using RTTI. For example: typedef std::bitset<16> WordSet; Would it be possible to extract the number 16 in the above code without hard-coding it elsewhere? Compiler specific implementations are welcome, though I'm particularly interested in g++ . It's not possible. The usual way you do it is this: template<int N> struct foo { static const int value = N; }; and for types template<typename T> struct foo { typedef T type; }; You can access it then as foo<39>: