a dynamic object implementation in c++
C++ C Objective-C
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.



Dynamic object are useful, especially in rapid prototyping, non-performance critical situations, and situations in which data/functions -bags are needed (non schema specific data). Also when serializing and deserializing dynamic objects can be a very valuable asset.

Dynamic programming languages inherently support this. e.g.

var obj = {};
obj.a = 'asd';
obj.b = {};
obj.b.c = 3;
obj.d = function(i,j){ return i+j;}

C# Also supports dynamic objects utilizing the dynamic keyword:

dynamic obj = new ExpandoObject();
obj.a = "asd";
obj.b = new ExpandObject();
obj.b.c = 3;
obj.d = (int i, int j)=>i+j;

I tried as to stay close to c#'s dynamic objects when trying to implement them for c++. Of course I could not alter the language so I have to use the indexer operator operator[](const std::string &)

My syntax is as follows:

DynamicObject obj;
obj["a"] = "asd";
obj["b"] = DynamicObject();
obj["b"]["c"] = 3;
obj["d"] = [](int i, int j){return i+j;};

Here is a working example of what you can do:

#include <core.dynamic.h>
#include <assert.h>

int main(){
      // dynamic object can be a fundamental type
      dynamic::DynamicObject uut = 33;
      assert(33 == (int)uut);

    // dynamic object can be a complex type
    dynamic::DynamicObject uut = std::string("hello");
    assert("hello" == (std::string)uut);
    // dynamic object can be reassigned
    dynamic::DynamicObject uut = 33;
    assert(33 == (int)uut);
    uut = std::string("hello");
    assert("hello" == (std::string)uut);
    //dynamic object can be a functor
    dynamic::DynamicObject uut = [](int i, int j){return i + j; };
    int result = uut(3, 4);
    assert(result == 7);

    // dynamic object can be an expando object
    dynamic::DynamicObject uut;
    uut["prop1"] = 33;
    uut["prop2"] = std::string("hello");
    uut["prop3"]["prop31"] = 5;
    uut["prop4"] = [](int i, int j){return i + j; };
    int prop1 = uut["prop1"];
    std::string prop2 = uut["prop2"];
    int prop31 = uut["prop3"]["prop31"];
    int result = uut["prop4"](5, 6);
    std::function<int(int, int)> prop4 = uut["prop4"];
    auto result2 = prop4(3, 4);

    assert(prop1 == 33);
    assert(prop2 == "hello");
    assert(prop31 == 5);
    assert(result == 11);
    assert(result2 == 7);

    // you can create a custom dynamic object implementation:
    class MyImp : public dynamic::DynamicObjectImplementationBase{
      virtual bool tryMemberGet(const get_member_context & context, result_type & result)override
        if (context.name == "prop1"){
          result = 44;
          return true;
        if (context.name == "prop2"){
          result = std::string("asd");
          return true;

        return false;
    // initialization is still a bit complex 
    dynamic::DynamicObject uut = 
    int a = uut["prop1"];
    std::string b = uut["prop2"];

    assert(a == 44);
    assert(b == "asd");




  • Functors with multiple overloads of operator() cannot be used as members or values (the is_callable<> and func_traits<> type traits would need to be specialized for the corresonding type.) This is especially sad, because no compiler independent version for std::bind return functors are usable.
  • Method modifiers except nonconst and const are not implemented.

Since c++ is statically typed working around it can be hard at times, however it is possible thanks to operator overloading. Especially operator(), operator[], operator T() are usefull to allow dynamic objects.