How can I add reflection to a C application

Question

I d like to be able to introspect a C   class for its name  contents  i e  members and their types  etc  I m talking native C   here  not managed C    which has reflection  I realise C   supplies some limited information using RTTI  Which additional libraries  or other techniques  could supply this information

User · Answer

I would recommend using Qt   There is an open-source licence as well as a commercial licence

User · Answer

It looks like C   still does not have this feature  And C  11 postponed reflection too     Search some macros or make own  Qt also can help with reflection  if it can be used

User · Answer

If you declare a pointer to a function like this   int   func  int a  int b     You can assign a place in memory to that function like this  requires libdl and dlopen    include  lt dlfcn h gt   int main void        void  handle      char  func name    bla bla bla       handle   dlopen  foo so   RTLD LAZY         void      amp func    dlsym handle  func name       return func 1 2       To load a local symbol using indirection  you can use dlopen on the calling binary  argv 0     The only requirement for this  other than dlopen    libdl  and dlfcn h  is knowing the arguments and type of the function

User · Answer

What you need to do is have the preprocessor generate reflection data about the fields  This data can be stored as nested classes    First  to make it easier and cleaner to write it in the preprocessor we will use typed expression  A typed expression is just an expression that puts the type in parenthesis  So instead of writing int x you will write  int  x  Here are some handy macros to help with typed expressions    define REM        VA ARGS    define EAT          Retrieve the type  define TYPEOF x  DETAIL TYPEOF DETAIL TYPEOF PROBE x    define DETAIL TYPEOF      DETAIL TYPEOF HEAD   VA ARGS     define DETAIL TYPEOF HEAD x       REM x  define DETAIL TYPEOF PROBE         VA ARGS        Strip off the type  define STRIP x  EAT x    Show the type without parenthesis  define PAIR x  REM x   Next  we define a REFLECTABLE macro to generate the data about each field plus the field itself   This macro will be called like this   REFLECTABLE        const char    name       int  age     So using Boost PP we iterate over each argument and generate the data like this      A helper metafunction for adding const to a type template lt class M  class T gt  struct make const       typedef T type      template lt class M  class T gt  struct make const lt const M  T gt        typedef typename boost  add const lt T gt   type type        define REFLECTABLE        static const int fields n   BOOST PP VARIADIC SIZE   VA ARGS       friend struct reflector    template lt int N  class Self gt    struct field data       BOOST PP SEQ FOR EACH I REFLECT EACH  data  BOOST PP VARIADIC TO SEQ   VA ARGS       define REFLECT EACH r  data  i  x    PAIR x     template lt class Self gt    struct field data lt i  Self gt            Self  amp  self        field data Self  amp  self    self self                 typename make const lt Self  TYPEOF x  gt   type  amp  get                     return self STRIP x                typename boost  add const lt TYPEOF x  gt   type  amp  get   const                   return self STRIP x                const char   name   const                  return BOOST PP STRINGIZE STRIP x                     What this does is generate a constant fields n that is number of reflectable fields in the class  Then it specializes the field data for each field  It also friends the reflector class  this is so it can access the fields even when they are private   struct reflector         Get field data at index N     template lt int N  class T gt      static typename T  template field data lt N  T gt  get field data T amp  x                return typename T  template field data lt N  T gt  x                 Get the number of fields     template lt class T gt      struct fields               static const int n   T  fields n              Now to iterate over the fields we use the visitor pattern  We create an MPL range from 0 to the number of fields  and access the field data at that index  Then it passes the field data on to the user-provided visitor   struct field visitor       template lt class C  class Visitor  class I gt      void operator   C amp  c  Visitor v  I                v reflector  get field data lt I  value gt  c               template lt class C  class Visitor gt  void visit each C  amp  c  Visitor v        typedef boost  mpl  range c lt int 0 reflector  fields lt C gt   n gt  range      boost  mpl  for each lt range gt  boost  bind lt void gt  field visitor    boost  ref c   v   1        Now for the moment of truth we put it all together  Here is how we can define a Person class that is reflectable   struct Person       Person const char  name  int age                    name name           age age              private      REFLECTABLE                const char    name           int  age            Here is a generalized print fields function using the reflection data to iterate over the fields   struct print visitor       template lt class FieldData gt      void operator   FieldData f                std  cout  lt  lt  f name    lt  lt       lt  lt  f get    lt  lt  std  endl            template lt class T gt  void print fields T  amp  x        visit each x  print visitor         An example of using the print fields with the reflectable Person class   int main         Person p  Tom   82       print fields p       return 0      Which outputs   name Tom age 82   And voila  we have just implemented reflection in C    in under 100 lines of code

User · Answer

I think you might find interesting the article  Using Templates for Reflection in C    by Dominic Filion  It is in section 1 4 of Game Programming Gems 5  Unfortunately I dont have my copy with me  but look for it because I think it explains what you are asking for

User · Answer

I would like to advertise the existence of the automatic introspection reflection toolkit  IDK   It uses a meta-compiler like Qt s and adds meta information directly into object files  It is claimed to be easy to use  No external dependencies  It even allows you to automatically reflect std  string and then use it in scripts  Please look at IDK

User · Answer

EDIT  CAMP is no more maintained   two forks are available     One is also called CAMP too  and is based on the same API  Ponder is a partial rewrite  and shall be preferred as it does not requires Boost   it s using C  11      CAMP is an MIT licensed library  formerly LGPL  that adds reflection to the C   language  It doesn t require a specific preprocessing step in the compilation  but the binding has to be made manually   The current Tegesoft library uses Boost  but there is also a fork using C  11 that no longer requires Boost

User · Answer

When I wanted reflection in C   I read this article and improved upon what I saw there   Sorry  no can has   I don t own the result   but you can certainly get what I had and go from there   I am currently researching  when I feel like it  methods to use inherit linearly to make the definition of reflectable types much easier   I ve gotten fairly far in it actually but I still have a ways to go   The changes in C  0x are very likely to be a lot of help in this area

User · Answer

The information does exist - but not in the format you need  and only if you export your classes  This works in Windows  I don t know about other platforms  Using the storage-class specifiers as in  for example   class   declspec export  MyClass   public      void Foo float x       This makes the compiler build the class definition data into the DLL Exe  But it s not in a format that you can readily use for reflection   At my company we built a library that interprets this metadata  and allows you to reflect a class without inserting extra macros etc  into the class itself  It allows functions to be called as follows   MyClass  instance ptr new MyClass  GetClass  MyClass  - gt GetFunction  Foo  - gt Invoke instance ptr 1 331     This effectively does   instance ptr- gt Foo 1 331     The Invoke this pointer      function has variable arguments  Obviously by calling a function in this way you re circumventing things like const-safety and so on  so these aspects are implemented as runtime checks   I m sure the syntax could be improved  and it only works on Win32 and Win64 so far  We ve found it really useful for having automatic GUI interfaces to classes  creating properties in C    streaming to and from XML and so on  and there s no need to derive from a specific base class  If there s enough demand maybe we could knock it into shape for release

User · Answer

If you re looking for relatively simple C   reflection - I have collected from various sources macro   defines  and commented them out how they works  You can download header  files from here   https   github com tapika TestCppReflect blob master MacroHelpers h  set of defines  plus functionality on top of it   https   github com tapika TestCppReflect blob master CppReflect h https   github com tapika TestCppReflect blob master CppReflect cpp https   github com tapika TestCppReflect blob master TypeTraits h  Sample application resides in git repository as well  in here  https   github com tapika TestCppReflect   I ll partly copy it here with explanation    include  CppReflect h  using namespace std    class Person   public          Repack your code into REFLECTABLE macro  in   lt C   Type gt    lt Field name gt         form   like this       REFLECTABLE  Person           CString    name           int        age                void main void        Person p      p name   L Roger       p age   37              And here you can convert your class contents into xml form       CStringW xml   ToXML   amp p        CStringW errors       People ppl2          And here you convert from xml back to class       FromXml   amp ppl2  xml  errors        CStringA xml2   ToXML   amp ppl2        printf  xml2         REFLECTABLE define uses class name   field name with offsetof - to identify at which place in memory particular field is located  I have tried to pick up  NET terminology for as far as possible  but C   and C  are different  so it s not 1 to 1  Whole C   reflection model resides in TypeInfo and FieldInfo classes   I have used pugi xml parser to fetch demo code into xml and restore it back from xml   So output produced by demo code looks like this    lt  xml version  1 0  encoding  utf-8   gt   lt People groupName  Group1  gt       lt people gt           lt Person name  Roger  age  37    gt           lt Person name  Alice  age  27    gt           lt Person name  Cindy  age  17    gt       lt  people gt   lt  People gt    It s also possible to enable any 3-rd party class   structure support via TypeTraits class  and partial template specification - to define your own TypeTraitsT class  in similar manner to CString or int - see example code in  https   github com tapika TestCppReflect blob master TypeTraits h L195  This solution is applicable for Windows   Visual studio  It s possible to port it to other OS compilers  but haven t done that one   Ask me if you really like solution  I might be able to help you out   This solution is applicable for one shot serialization of one class with multiple subclasses   If you however are searching for mechanism to serialize class parts or even to control what functionality reflection calls produce  you could take a look on following solution   https   github com tapika cppscriptcore tree master SolutionProjectModel  More detailed information can be found from youtube video   C   Runtime Type Reflection https   youtu be TN8tJijkeFE  I m trying to explain bit deeper on how c   reflection will work   Sample code will look like for example this   https   github com tapika cppscriptcore blob master SolutionProjectModel testCppApp cpp  c General IntDir   LR  obj   ProjectName    Configuration    Platform      c General OutDir   LR  bin   Configuration    Platform      c General UseDebugLibraries   true  c General LinkIncremental   true  c CCpp Optimization   optimization Disabled  c Linker System SubSystem   subsystem Console  c Linker Debugging GenerateDebugInformation   debuginfo true    But each step here actually results in function call  Using C   properties with   declspec property get    put         which receives full information on C   Data Types  C   property names and class instance pointers  in form of path  and based on that information you can generate xml  json or even serialize that one over internet   Examples of such virtual callback functions can be found here   https   github com tapika cppscriptcore blob master SolutionProjectModel VCConfiguration cpp  See functions ReflectCopy  and virtual function   OnAfterSetProperty   But since topic is really advanced - I recommend to check through video first   If you have some improvement ideas  feel free to contact me

User · Answer

You need to look at what you are trying to do  and if RTTI will satisfy your requirements   I ve implemented my own pseudo-reflection for some very specific purposes   For example  I once wanted to be able to flexibly configure what a simulation would output   It required adding some boilerplate code to the classes that would be output   namespace     static bool b2   Filter  Filterable lt const MyObj gt   Register  MyObject        bool MyObj  BuildMap       Filterable lt const OutputDisease gt   AddAccess  time    amp MyObj  time     Filterable lt const OutputDisease gt   AddAccess  person    amp MyObj  id     return true      The first call adds this object to the filtering system  which calls the BuildMap   method to figure out what methods are available     Then  in the config file  you can do something like this   FILTER-OUTPUT-OBJECT   MyObject FILTER-OUTPUT-FILENAME file txt FILTER-CLAUSE-1        person    1773 FILTER-CLAUSE-2        time  gt  2000   Through some template magic involving boost  this gets translated into a series of method calls at run-time  when the config file is read   so it s fairly efficient   I wouldn t recommend doing this unless you really need to  but  when you do  you can do some really cool stuff

User · Answer

This question is a bit old now  don t know why I keep hitting old questions today  but I was thinking about BOOST FUSION ADAPT STRUCT which introduces compile-time reflection   It is up to you to map this to run-time reflection of course  and it won t be too easy  but it is possible in this direction  while it would not be in the reverse     I really think a macro to encapsulate the BOOST FUSION ADAPT STRUCT one could generate the necessary methods to get the runtime behavior

User · Answer

The two reflection-like solutions I know of from my C   days are   1  Use RTTI  which will provide a bootstrap for you to build your reflection-like behaviour  if you are able to get all your classes to derive from an  object  base class  That class could provide some methods like GetMethod  GetBaseClass etc  As for how those methods work you will need to manually add some macros to decorate your types  which behind the scenes create metadata in the type to provide answers to GetMethods etc   2  Another option  if you have access to the compiler objects is to use the DIA SDK  If I remember correctly this lets you open pdbs  which should contain metadata for your C   types  It might be enough to do what you need  This page shows how you can get all base types of a class for example   Both these solution are a bit ugly though  There is nothing like a bit of C   to make you appreciate the luxuries of C    Good Luck

User · Answer

Ponder is a C   reflection library  in answer to this question  I considered the options and decided to make my own since I couldn t find one that ticked all my boxes    Although there are great answers to this question  I don t want to use tonnes of macros  or rely on Boost  Boost is a great library  but there are lots of small bespoke C  0x projects out that are simpler and have faster compile times  There are also advantages to being able to decorate a class externally  like wrapping a C   library that doesn t  yet   support C  11  It is fork of CAMP  using C  11  that no longer requires Boost

User · Answer

The RareCpp library makes for fairly easy and intuitive reflection - all field type information is designed to either be available in arrays or to feel like array access  It s written for C  17 and works with Visual Studios  g    and Clang  The library is header only  meaning you need only copy  quot Reflect h quot  into your project to use it  Reflected structs or classes need the REFLECT macro  where you supply the name of the class you re reflecting and the names of the fields  class FuelTank       public          float capacity          float currentLevel          float tickMarks 2        REFLECT FuelTank  capacity  currentLevel  tickMarks      That s all there is  no additional code is needed to setup reflection  Optionally you can supply superclasses  in the parenthesis of the first argument  and field annotations  in the parenthesis preceeding the field you want to annotate  to be able to traverse superclasses or add additional compile-time information to a field  such as Json  Ignore   Looping through fields can be as simple as    for   size t i 0  i lt FuelTank  Class  TotalFields  i         std  cout  lt  lt  FuelTank  Class  Fields i  name  lt  lt  std  endl   You can loop through an object instance to access field values  which you can read or modify  and field type information    FuelTank  Class  ForEachField fuelTank    amp   auto  amp  field  auto  amp  value        using Type   typename std  remove reference lt decltype value  gt   type      std  cout  lt  lt  TypeToStr lt Type gt     lt  lt   quot   quot   lt  lt  field name  lt  lt   quot    quot   lt  lt  value  lt  lt  std  endl        A JSON Library is built on top of RandomAccessReflection which auto identifies appropriate JSON output representations for reading or writing  and can recursively traverse any reflected fields  as well as arrays and STL containers  struct MyOtherObject   int myOtherInt  REFLECT MyOtherObject  myOtherInt     struct MyObject       int myInt      std  string myString      MyOtherObject myOtherObject      std  vector lt int gt  myIntCollection       REFLECT MyObject  myInt  myString  myOtherObject  myIntCollection      int main         MyObject myObject           std  cout  lt  lt   quot Enter MyObject  quot   lt  lt  std  endl      std  cin  gt  gt  Json  in myObject       std  cout  lt  lt  std  endl  lt  lt  std  endl  lt  lt   quot You entered  quot   lt  lt  std  endl      std  cout  lt  lt  Json  pretty myObject      The above could be ran like so    Enter MyObject       quot myInt quot   1337   quot myString quot    quot stringy quot    quot myIntCollection quot    2 4 6      quot myOtherObject quot          quot myOtherInt quot   9001         You entered       quot myInt quot   1337     quot myString quot    quot stringy quot      quot myOtherObject quot          quot myOtherInt quot   9001         quot myIntCollection quot     2  4  6      See also     Reflect Documentation Reflect Implementation More Usage Examples

User · Answer

Reflection is essentially about what the compiler decided to leave as footprints in the code that the runtime code can query   C   is famous for not paying for what you don t use  because most people don t use want reflection  the C   compiler avoids the cost by not recording anything   So  C   doesn t provide reflection  and it isn t easy to  simulate  it yourself as general rule as other answers have noted   Under  other techniques   if you don t have a language with reflection  get a tool that can extract the information you want at compile time   Our DMS Software Reengineering Toolkit is generalized compiler technology parameterized by explicit langauge definitions  It has langauge definitions for C  C    Java  COBOL  PHP       For C  C    Java and COBOL versions  it provides complete access to parse trees  and symbol table information   That symbol table information includes the kind of data you are likely to want from  reflection    If you goal is to enumerate some set of fields or methods and do something with them  DMS can be used to transform the code according to what you find in the symbol tables in arbitrary ways

User · Answer

What are you trying to do with reflection   You can use the Boost type traits and typeof libraries as a limited form of compile-time reflection  That is  you can inspect and modify the basic properties of a type passed to a template

User · Answer

You can find another library here  http   www garret ru cppreflection docs reflect html It supports 2 ways  getting type information from debug information and let programmer to provide this information   I also interested in reflection for my project and found this library  i have not tried it yet  but tried other tools from this guy and i like how they work  -

User · Answer

There are two kinds of reflection swimming around    Inspection by iterating over members of a type  enumerating its methods and so on  This is not possible with C     Inspection by checking whether a class-type  class  struct  union  has a method or nested type  is derived from another particular type  This kind of thing is possible with C   using template-tricks  Use boost  type traits for many things  like checking whether a type is integral   For checking for the existance of a member function  use Is it possible to write a template to check for a function  39 s existence    For checking whether a certain nested type exists  use plain SFINAE       If you are rather looking for ways to accomplish 1   like looking how many methods a class has  or like getting the string representation of a class id  then i m afraid there is no Standard C   way of doing this  You have to use either   A Meta Compiler like the Qt Meta Object Compiler which translates your code adding additional meta informations  A Framework constisting of macros that allow you to add the required meta-informations  You would need to tell the framework all methods  the class-names  base-classes and everything it needs    C   is made with speed in mind  If you want high-level inspection  like C  or Java has  then I m afraid i have to tell you there is no way without some effort

User · Answer

There is another new library for reflection in C    called RTTR  Run Time Type Reflection  see also github    The interface is similar to reflection in C  and it works without any RTTI

User · Answer

EDIT  Updated broken link as of February  the 7th  2017   I think noone mentioned this   At CERN they use a full reflection system for C     CERN Reflex  It seems to work very well

User · Answer

And I would love a pony  but ponies aren t free   -p  http   en wikibooks org wiki C 2B 2B Programming RTTI is what you re going to get  Reflection like you re thinking about -- fully descriptive metadata available at runtime -- just doesn t exist for C   by default

User · Answer

Check out Classdesc http   classdesc sf net  It provides reflection in the form of class  descriptors   works with any standard C   compiler  yes it is known to work with Visual Studio as well as GCC   and does not require source code annotation  although some pragmas exist to handle tricky situations   It has been in development for more than a decade  and used in a number of industrial scale projects

User · Answer

You can achieve cool static reflection features for structs with BOOST HANA DEFINE STRUCT from the Boost  Hana library  Hana is quite versatile  not only for the usecase you have in mind but for a lot of template metaprogramming

User · Answer

even though reflection is not supported out-of-the-box in c    it is not too hard to implement  I ve encountered this great article  http   replicaisland blogspot co il 2010 11 building-reflective-object-system-in-c html  the article explains in great detail how you can implement a pretty simple and rudimentary reflection system  granted its not the most wholesome solution  and there are rough edges left to be sorted out but for my needs it was sufficient   the bottom line - reflection can pay off if done correctly  and it is completely feasible in c

User · Answer

Reflection is not supported by C   out of the box  This is sad because it makes defensive testing a pain  There are several approaches to doing reflection   use the debug information  non portable   Sprinkle your code with macro s templates or some other source approach  looks ugly  Modify a compiler such as clang gcc to produce a database  Use Qt moc approach Boost Reflect Precise and Flat Reflection  The first link looks the most promising  uses mod s to clang   the second discusses a number of techniques  the third is a different approach using gcc   http   www donw org rfl   https   bitbucket org dwilliamson clreflect  https   root cern ch how how-use-reflex   There is now a working group for C   reflection  See the news for C  14   CERN   https   root cern ch blog status-reflection-c  Edit 13 08 17  Since the  original post there have been a number of potential advancements on the reflection  The following provides more detail and a discussion on the various techniques and status   Static Reflection in a Nutshell Static Reflection A design for static reflection  However it does not look promising on a standardised reflections approach in C   in the near future unless there is a lot more interest from the community in support for reflection in C    The following details the current status based on feedback from the last C   standards meeting   Reflections on the reflection proposals  Edit 13 12 2017 Reflection looks to be moving towards C   20 or more probably a TSR  Movement is however slow   Mirror Mirror standard proposal Mirror paper Herb Sutter - meta programming including reflection  Edit 15 09 2018 A draft TS has been sent out to the national bodies for ballot  The text can be found here  https   github com cplusplus reflection-ts Edit 11 07 2019 The reflection TS is feature complete and is out for comment and vote over the summer  2019   The meta-template programing approach is to be replaced with a simplier compile time code approach  not reflected in the TS    Draft TS as of 2019-06-17  Edit 10 02 2020 There is a request to support the reflection TS in Visual Studio here   https   developercommunity visualstudio com idea 826632 implement-the-c-reflection-ts html  Talk on the TS by the author David Sankel   http   cppnow org history 2019 talks   https   www youtube com watch v VMuML6vLSus amp feature youtu be   Edit 17 March 2020 Progress on reflection is being made  A report from  2020-02 Prague ISO C   Committee Trip Report  can be found here   https   www reddit com r cpp comments f47x4o 202002 prague iso c committee trip report c20 is   Details on what is being considered for C  23 can be found here  includes short section on Reflection    http   www open-std org jtc1 sc22 wg21 docs papers 2019 p0592r4 html  Edit 4th June 2020 A new framework has been released by Jeff Preshing called  Plywood  that contains a mechanism for runtime reflection  More details can be found here   https   preshing com 20200526 a-new-cross-platform-open-source-cpp-framework   The tools and approach look to be the most polished and easiest to use so far  Edit July 12 2020 Clang experimental reflection fork   https   github com lock3 meta wiki Interesting reflection library that uses clang tooling library to extract information for simple reflection with no need to add macro s  https   github com chakaz reflang Edit Feb 24 2021 Some additional clang tooling approaches   https   github com Celtoys clReflect https   github com mlomb MetaCPP

User · Answer

I did something like what you re after once  and while it s possible to get some level of reflection and access to higher-level features  the maintenance headache might not be worth it   My system was used to keep the UI classes completely separated from the business logic through delegation akin to Objective-C s concept of message passing and forwarding   The way to do it is to create some base class that is capable of mapping symbols  I used a string pool but you could do it with enums if you prefer speed and compile-time error handling over total flexibility  to function pointers  actually not pure function pointers  but something similar to what Boost has with Boost Function--which I didn t have access to at the time    You can do the same thing for your member variables as long as you have some common base class capable of representing any value   The entire system was an unabashed ripoff of Key-Value Coding and Delegation  with a few side effects that were perhaps worth the sheer amount of time necessary to get every class that used the system to match all of its methods and members up with legal calls   1   Any class could call any method on any other class without having to include headers or write fake base classes so the interface could be predefined for the compiler  and 2   The getters and setters of the member variables were easy to make thread-safe because changing or accessing their values was always done through 2 methods in the base class of all objects   It also led to the possibility of doing some really weird things that otherwise aren t easy in C     For example I could create an Array object that contained arbitrary items of any type  including itself  and create new arrays dynamically by passing a message to all array items and collecting the return values  similar to map in Lisp    Another was the implementation of key-value observing  whereby I was able to set up the UI to respond immediately to changes in the members of backend classes instead of constantly polling the data or unnecessarily redrawing the display   Maybe more interesting to you is the fact that you can also dump all methods and members defined for a class  and in string form no less   Downsides to the system that might discourage you from bothering   adding all of the messages and key-values is extremely tedious  it s slower than without any reflection  you ll grow to hate seeing boost  static pointer cast and boost  dynamic pointer cast all over your codebase with a violent passion  the limitations of the strongly-typed system are still there  you re really just hiding them a bit so it isn t as obvious   Typos in your strings are also not a fun or easy to discover surprise   As to how to implement something like this   just use shared and weak pointers to some common base  mine was very imaginatively called  Object   and derive for all the types you want to use   I d recommend installing Boost Function instead of doing it the way I did  which was with some custom crap and a ton of ugly macros to wrap the function pointer calls   Since everything is mapped  inspecting objects is just a matter of iterating through all of the keys   Since my classes were essentially as close to a direct ripoff of Cocoa as possible using only C    if you want something like that then I d suggest using the Cocoa documentation as a blueprint

User · Answer

Reflection in C   is very useful  in cases there you need to run some method for each member For example  serialization  hashing  compare   I came with generic solution  with very simple syntax   struct S1       ENUMERATE MEMBERS str i       std  string str      int i     struct S2       ENUMERATE MEMBERS s1 i2       S1 s1      int i2       Where ENUMERATE MEMBERS is a macro  which is described later UPDATE    Assume we have defined serialization function for int and std  string like this   void EnumerateWith BinaryWriter  amp  writer  int val          store integer     writer WriteBuffer  amp val  sizeof int      void EnumerateWith BinaryWriter  amp  writer  std  string val          store string     writer WriteBuffer val c str    val size         And we have generic function near the  secret macro      template lt typename TWriter  typename T gt  auto EnumerateWith TWriter  amp  amp  writer  T  amp  amp  val  - gt  is enumerable t lt T gt        val EnumerateWith write     method generated by ENUMERATE MEMBERS macro     Now you can write  S1 s1  S2 s2         BinaryWriter writer  serialized bin     EnumerateWith writer  s1     this will call EnumerateWith for all members of S1 EnumerateWith writer  s2     this will call EnumerateWith for all members of S2 and S2  s1  recursively    So having ENUMERATE MEMBERS macro in struct definition  you can build serialization  compare  hashing  and other stuffs without touching original type  the only requirement is to implement  EnumerateWith  method for each type  which is not enumerable  per enumerator like BinaryWriter   Usually you will have to implement 10-20  simple  types to support any type in your project   This macro should have zero-overhead to struct creation destruction in run-time  and the code of T EnumerateWith   should be generated on-demand  which can be achieved by making it template-inline function  so the only overhead in all the story is to add ENUMERATE MEMBERS m1 m2 m3     to each struct  while implementing specific method per member type is a must in any solution  so I do not assume it as overhead   UPDATE   There is very simple implementation of ENUMERATE MEMBERS macro however it could be a little be extended to support inheritance from enumerable struct    define ENUMERATE MEMBERS        template lt typename TEnumerator gt  inline void EnumerateWith TEnumerator  amp  enumerator  const   EnumerateWithHelper enumerator    VA ARGS         template lt typename TEnumerator gt  inline void EnumerateWith TEnumerator  amp  enumerator    EnumerateWithHelper enumerator    VA ARGS           EnumerateWithHelper template lt typename TEnumerator  typename    T gt  inline void EnumerateWithHelper TEnumerator  amp  enumerator  T  amp    v          int x        EnumerateWith enumerator  v   1               Generic EnumerateWith template lt typename TEnumerator  typename T gt  auto EnumerateWith TEnumerator  amp  enumerator  T  amp  val  - gt  std  void t lt decltype val EnumerateWith enumerator   gt        val EnumerateWith enumerator       And you do not need any 3rd party library for these 15 lines of code

[c++] How can I add reflection to a C++ application?

Examples related to c++

Examples related to reflection

Examples related to templates

Examples related to sfinae