C++ debug/print custom type with GDB : the case of nlohmann json libraryHow to inspect std::string in GDB with no source code?How to pass normal param as well as template param in a template function in C++?How do I get my IDE to provide the C++ libraries?Why can I not call reserve on a vector of const elements?Cannot get min_element to work in C++Linker error trying to embed v8LNK2019: unresolved external symbol in C++Valgrind complaining possible memory leak in std string's new operatorName mangling confusion in LLVMclang++ memory sanitizer reports use-of-uninitialized-valueDebug std containers with gdb not working

Why should universal income be universal?

Is it safe to use olive oil to clean the ear wax?

Problem with TransformedDistribution

Redundant comparison & "if" before assignment

Is there any references on the tensor product of presentable (1-)categories?

Lowest total scrabble score

Why Shazam when there is already Superman?

Why did the EU agree to delay the Brexit deadline?

Which one is correct as adjective “protruding” or “protruded”?

How could a planet have erratic days?

Closed-form expression for certain product

L1 and Ln cache: when are they written?

What should you do if you miss a job interview (deliberately)?

The screen of my macbook suddenly broken down how can I do to recover

Store Credit Card Information in Password Manager?

What is this called? Old film camera viewer?

Strong empirical falsification of quantum mechanics based on vacuum energy density

How much character growth crosses the line into breaking the character

How to explain what's wrong with this application of the chain rule?

Freedom of speech and where it applies

Is this toilet slogan correct usage of the English language?

Why is it that I can sometimes guess the next note?

How can "mimic phobia" be cured or prevented?

Are the IPv6 address space and IPv4 address space completely disjoint?



C++ debug/print custom type with GDB : the case of nlohmann json library


How to inspect std::string in GDB with no source code?How to pass normal param as well as template param in a template function in C++?How do I get my IDE to provide the C++ libraries?Why can I not call reserve on a vector of const elements?Cannot get min_element to work in C++Linker error trying to embed v8LNK2019: unresolved external symbol in C++Valgrind complaining possible memory leak in std string's new operatorName mangling confusion in LLVMclang++ memory sanitizer reports use-of-uninitialized-valueDebug std containers with gdb not working













10















I'm working on a project using nlohmann's json C++ implementation.



How can one easily explore nlohmann's JSON keys/vals in GDB ?



I tried to use this STL gdb wrapping since it provides helpers to explore STL structures that lohmann's JSON lib is using.
But I don't find it convenient.



Here is a simple use case:



json foo;
foo["flex"] = 0.2;
foo["awesome_str"] = "bleh";
foo["nested"] = "bar", "barz";


What I would like to have in GDB:



(gdb) p foo

"flex" : 0.2,
"awesome_str": "bleh",
"nested": etc.



Current behavior



(gdb) p foo
$1 =
m_type = nlohmann::detail::value_t::object,
m_value =
object = 0x129ccdd0,
array = 0x129ccdd0,
string = 0x129ccdd0,
boolean = 208,
number_integer = 312266192,
number_unsigned = 312266192,
number_float = 1.5427999782486669e-315


(gdb) p foo.at("flex")
Cannot evaluate function -- may be inlined // I suppose it depends on my compilation process. But I guess it does not invalidate the question.
(gdb) p *foo.m_value.object
$2 =
_M_t =
_M_impl =
<std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> =
<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = <No data fields>, <No data fields>,
<std::_Rb_tree_key_compare<std::less<void> >> =
_M_key_compare = <No data fields>
,
<std::_Rb_tree_header> =
_M_header =
_M_color = std::_S_red,
_M_parent = 0x4d72d0,
_M_left = 0x4d7210,
_M_right = 0x4d7270
,
_M_node_count = 5
, <No data fields>











share|improve this question




























    10















    I'm working on a project using nlohmann's json C++ implementation.



    How can one easily explore nlohmann's JSON keys/vals in GDB ?



    I tried to use this STL gdb wrapping since it provides helpers to explore STL structures that lohmann's JSON lib is using.
    But I don't find it convenient.



    Here is a simple use case:



    json foo;
    foo["flex"] = 0.2;
    foo["awesome_str"] = "bleh";
    foo["nested"] = "bar", "barz";


    What I would like to have in GDB:



    (gdb) p foo

    "flex" : 0.2,
    "awesome_str": "bleh",
    "nested": etc.



    Current behavior



    (gdb) p foo
    $1 =
    m_type = nlohmann::detail::value_t::object,
    m_value =
    object = 0x129ccdd0,
    array = 0x129ccdd0,
    string = 0x129ccdd0,
    boolean = 208,
    number_integer = 312266192,
    number_unsigned = 312266192,
    number_float = 1.5427999782486669e-315


    (gdb) p foo.at("flex")
    Cannot evaluate function -- may be inlined // I suppose it depends on my compilation process. But I guess it does not invalidate the question.
    (gdb) p *foo.m_value.object
    $2 =
    _M_t =
    _M_impl =
    <std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> =
    <__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = <No data fields>, <No data fields>,
    <std::_Rb_tree_key_compare<std::less<void> >> =
    _M_key_compare = <No data fields>
    ,
    <std::_Rb_tree_header> =
    _M_header =
    _M_color = std::_S_red,
    _M_parent = 0x4d72d0,
    _M_left = 0x4d7210,
    _M_right = 0x4d7270
    ,
    _M_node_count = 5
    , <No data fields>











    share|improve this question


























      10












      10








      10








      I'm working on a project using nlohmann's json C++ implementation.



      How can one easily explore nlohmann's JSON keys/vals in GDB ?



      I tried to use this STL gdb wrapping since it provides helpers to explore STL structures that lohmann's JSON lib is using.
      But I don't find it convenient.



      Here is a simple use case:



      json foo;
      foo["flex"] = 0.2;
      foo["awesome_str"] = "bleh";
      foo["nested"] = "bar", "barz";


      What I would like to have in GDB:



      (gdb) p foo

      "flex" : 0.2,
      "awesome_str": "bleh",
      "nested": etc.



      Current behavior



      (gdb) p foo
      $1 =
      m_type = nlohmann::detail::value_t::object,
      m_value =
      object = 0x129ccdd0,
      array = 0x129ccdd0,
      string = 0x129ccdd0,
      boolean = 208,
      number_integer = 312266192,
      number_unsigned = 312266192,
      number_float = 1.5427999782486669e-315


      (gdb) p foo.at("flex")
      Cannot evaluate function -- may be inlined // I suppose it depends on my compilation process. But I guess it does not invalidate the question.
      (gdb) p *foo.m_value.object
      $2 =
      _M_t =
      _M_impl =
      <std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> =
      <__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = <No data fields>, <No data fields>,
      <std::_Rb_tree_key_compare<std::less<void> >> =
      _M_key_compare = <No data fields>
      ,
      <std::_Rb_tree_header> =
      _M_header =
      _M_color = std::_S_red,
      _M_parent = 0x4d72d0,
      _M_left = 0x4d7210,
      _M_right = 0x4d7270
      ,
      _M_node_count = 5
      , <No data fields>











      share|improve this question
















      I'm working on a project using nlohmann's json C++ implementation.



      How can one easily explore nlohmann's JSON keys/vals in GDB ?



      I tried to use this STL gdb wrapping since it provides helpers to explore STL structures that lohmann's JSON lib is using.
      But I don't find it convenient.



      Here is a simple use case:



      json foo;
      foo["flex"] = 0.2;
      foo["awesome_str"] = "bleh";
      foo["nested"] = "bar", "barz";


      What I would like to have in GDB:



      (gdb) p foo

      "flex" : 0.2,
      "awesome_str": "bleh",
      "nested": etc.



      Current behavior



      (gdb) p foo
      $1 =
      m_type = nlohmann::detail::value_t::object,
      m_value =
      object = 0x129ccdd0,
      array = 0x129ccdd0,
      string = 0x129ccdd0,
      boolean = 208,
      number_integer = 312266192,
      number_unsigned = 312266192,
      number_float = 1.5427999782486669e-315


      (gdb) p foo.at("flex")
      Cannot evaluate function -- may be inlined // I suppose it depends on my compilation process. But I guess it does not invalidate the question.
      (gdb) p *foo.m_value.object
      $2 =
      _M_t =
      _M_impl =
      <std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> =
      <__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long, unsigned long long, double, std::allocator, nlohmann::adl_serializer> > > >> = <No data fields>, <No data fields>,
      <std::_Rb_tree_key_compare<std::less<void> >> =
      _M_key_compare = <No data fields>
      ,
      <std::_Rb_tree_header> =
      _M_header =
      _M_color = std::_S_red,
      _M_parent = 0x4d72d0,
      _M_left = 0x4d7210,
      _M_right = 0x4d7270
      ,
      _M_node_count = 5
      , <No data fields>








      c++ json gdb pretty-print nlohmann-json






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited 15 mins ago







      LoneWanderer

















      asked 6 hours ago









      LoneWandererLoneWanderer

      1,112825




      1,112825






















          1 Answer
          1






          active

          oldest

          votes


















          13














          I found my own answer reading further the GDB capabilities and stack overflow questions concerning print of std::string.



          Short path



          I simply defined a gdb command as follows:



          # this is a gdb script
          # can be loaded from gdb using
          # source my_script.txt (or. gdb or whatever you like)
          define pjson
          # use the lohmann's builtin dump method, ident 4 and use space separator
          printf "%sn", $arg0.dump(4, ' ', true).c_str()
          end
          # configure command helper (text displayed when typing 'help pjson' in gdb)
          document pjson
          Prints a lohmann's JSON C++ variable as a human-readable JSON string
          end


          Using it in gdb:



          (gdb) source my_custom_script.gdb
          (gdb) pjson foo

          "flex" : 0.2,
          "awesome_str": "bleh",
          "nested":
          "bar": "barz"





          Over the top



          The other way is to define a GDB pretty printer in python and make it tightly associated to your project (autoloading stuff activated). See this link for an in-depth approach.



          Basically, when in gdb you would type:



          (gdb) p foo


          and GDB will automagically test for foo's type and invoke the associated pretty printer if any. That would end-up in the same result. The main difference is that it is done using the well-known print command. The person debugging would not have to learn a new command (like the pjson defined in the short answer).



          Quoting:




          A pretty-printer consists of two parts: a lookup function to detect if the type is supported, and the printer itself.



          Here is an example showing how a std::string printer might be written. See Pretty Printing API, for details on the API this class must provide.




          class StdStringPrinter(object):
          "Print a std::string"

          def __init__(self, val):
          self.val = val

          def to_string(self):
          return self.val['_M_dataplus']['_M_p']

          def display_hint(self):
          return 'string'


          Still quoting for the sake of completness:




          And here is an example showing how a lookup function for the printer example above might be written.




          def str_lookup_function(val):
          lookup_tag = val.type.tag
          if lookup_tag == None:
          return None
          regex = re.compile("^std::basic_string<char,.*>$")
          if regex.match(lookup_tag):
          return StdStringPrinter(val)
          return None





          share|improve this answer

























          • That looks pretty useful. Unfortunately I am out of votes ATM.

            – πάντα ῥεῖ
            6 hours ago











          Your Answer






          StackExchange.ifUsing("editor", function ()
          StackExchange.using("externalEditor", function ()
          StackExchange.using("snippets", function ()
          StackExchange.snippets.init();
          );
          );
          , "code-snippets");

          StackExchange.ready(function()
          var channelOptions =
          tags: "".split(" "),
          id: "1"
          ;
          initTagRenderer("".split(" "), "".split(" "), channelOptions);

          StackExchange.using("externalEditor", function()
          // Have to fire editor after snippets, if snippets enabled
          if (StackExchange.settings.snippets.snippetsEnabled)
          StackExchange.using("snippets", function()
          createEditor();
          );

          else
          createEditor();

          );

          function createEditor()
          StackExchange.prepareEditor(
          heartbeatType: 'answer',
          autoActivateHeartbeat: false,
          convertImagesToLinks: true,
          noModals: true,
          showLowRepImageUploadWarning: true,
          reputationToPostImages: 10,
          bindNavPrevention: true,
          postfix: "",
          imageUploader:
          brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
          contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
          allowUrls: true
          ,
          onDemand: true,
          discardSelector: ".discard-answer"
          ,immediatelyShowMarkdownHelp:true
          );



          );













          draft saved

          draft discarded


















          StackExchange.ready(
          function ()
          StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55316620%2fc-debug-print-custom-type-with-gdb-the-case-of-nlohmann-json-library%23new-answer', 'question_page');

          );

          Post as a guest















          Required, but never shown

























          1 Answer
          1






          active

          oldest

          votes








          1 Answer
          1






          active

          oldest

          votes









          active

          oldest

          votes






          active

          oldest

          votes









          13














          I found my own answer reading further the GDB capabilities and stack overflow questions concerning print of std::string.



          Short path



          I simply defined a gdb command as follows:



          # this is a gdb script
          # can be loaded from gdb using
          # source my_script.txt (or. gdb or whatever you like)
          define pjson
          # use the lohmann's builtin dump method, ident 4 and use space separator
          printf "%sn", $arg0.dump(4, ' ', true).c_str()
          end
          # configure command helper (text displayed when typing 'help pjson' in gdb)
          document pjson
          Prints a lohmann's JSON C++ variable as a human-readable JSON string
          end


          Using it in gdb:



          (gdb) source my_custom_script.gdb
          (gdb) pjson foo

          "flex" : 0.2,
          "awesome_str": "bleh",
          "nested":
          "bar": "barz"





          Over the top



          The other way is to define a GDB pretty printer in python and make it tightly associated to your project (autoloading stuff activated). See this link for an in-depth approach.



          Basically, when in gdb you would type:



          (gdb) p foo


          and GDB will automagically test for foo's type and invoke the associated pretty printer if any. That would end-up in the same result. The main difference is that it is done using the well-known print command. The person debugging would not have to learn a new command (like the pjson defined in the short answer).



          Quoting:




          A pretty-printer consists of two parts: a lookup function to detect if the type is supported, and the printer itself.



          Here is an example showing how a std::string printer might be written. See Pretty Printing API, for details on the API this class must provide.




          class StdStringPrinter(object):
          "Print a std::string"

          def __init__(self, val):
          self.val = val

          def to_string(self):
          return self.val['_M_dataplus']['_M_p']

          def display_hint(self):
          return 'string'


          Still quoting for the sake of completness:




          And here is an example showing how a lookup function for the printer example above might be written.




          def str_lookup_function(val):
          lookup_tag = val.type.tag
          if lookup_tag == None:
          return None
          regex = re.compile("^std::basic_string<char,.*>$")
          if regex.match(lookup_tag):
          return StdStringPrinter(val)
          return None





          share|improve this answer

























          • That looks pretty useful. Unfortunately I am out of votes ATM.

            – πάντα ῥεῖ
            6 hours ago
















          13














          I found my own answer reading further the GDB capabilities and stack overflow questions concerning print of std::string.



          Short path



          I simply defined a gdb command as follows:



          # this is a gdb script
          # can be loaded from gdb using
          # source my_script.txt (or. gdb or whatever you like)
          define pjson
          # use the lohmann's builtin dump method, ident 4 and use space separator
          printf "%sn", $arg0.dump(4, ' ', true).c_str()
          end
          # configure command helper (text displayed when typing 'help pjson' in gdb)
          document pjson
          Prints a lohmann's JSON C++ variable as a human-readable JSON string
          end


          Using it in gdb:



          (gdb) source my_custom_script.gdb
          (gdb) pjson foo

          "flex" : 0.2,
          "awesome_str": "bleh",
          "nested":
          "bar": "barz"





          Over the top



          The other way is to define a GDB pretty printer in python and make it tightly associated to your project (autoloading stuff activated). See this link for an in-depth approach.



          Basically, when in gdb you would type:



          (gdb) p foo


          and GDB will automagically test for foo's type and invoke the associated pretty printer if any. That would end-up in the same result. The main difference is that it is done using the well-known print command. The person debugging would not have to learn a new command (like the pjson defined in the short answer).



          Quoting:




          A pretty-printer consists of two parts: a lookup function to detect if the type is supported, and the printer itself.



          Here is an example showing how a std::string printer might be written. See Pretty Printing API, for details on the API this class must provide.




          class StdStringPrinter(object):
          "Print a std::string"

          def __init__(self, val):
          self.val = val

          def to_string(self):
          return self.val['_M_dataplus']['_M_p']

          def display_hint(self):
          return 'string'


          Still quoting for the sake of completness:




          And here is an example showing how a lookup function for the printer example above might be written.




          def str_lookup_function(val):
          lookup_tag = val.type.tag
          if lookup_tag == None:
          return None
          regex = re.compile("^std::basic_string<char,.*>$")
          if regex.match(lookup_tag):
          return StdStringPrinter(val)
          return None





          share|improve this answer

























          • That looks pretty useful. Unfortunately I am out of votes ATM.

            – πάντα ῥεῖ
            6 hours ago














          13












          13








          13







          I found my own answer reading further the GDB capabilities and stack overflow questions concerning print of std::string.



          Short path



          I simply defined a gdb command as follows:



          # this is a gdb script
          # can be loaded from gdb using
          # source my_script.txt (or. gdb or whatever you like)
          define pjson
          # use the lohmann's builtin dump method, ident 4 and use space separator
          printf "%sn", $arg0.dump(4, ' ', true).c_str()
          end
          # configure command helper (text displayed when typing 'help pjson' in gdb)
          document pjson
          Prints a lohmann's JSON C++ variable as a human-readable JSON string
          end


          Using it in gdb:



          (gdb) source my_custom_script.gdb
          (gdb) pjson foo

          "flex" : 0.2,
          "awesome_str": "bleh",
          "nested":
          "bar": "barz"





          Over the top



          The other way is to define a GDB pretty printer in python and make it tightly associated to your project (autoloading stuff activated). See this link for an in-depth approach.



          Basically, when in gdb you would type:



          (gdb) p foo


          and GDB will automagically test for foo's type and invoke the associated pretty printer if any. That would end-up in the same result. The main difference is that it is done using the well-known print command. The person debugging would not have to learn a new command (like the pjson defined in the short answer).



          Quoting:




          A pretty-printer consists of two parts: a lookup function to detect if the type is supported, and the printer itself.



          Here is an example showing how a std::string printer might be written. See Pretty Printing API, for details on the API this class must provide.




          class StdStringPrinter(object):
          "Print a std::string"

          def __init__(self, val):
          self.val = val

          def to_string(self):
          return self.val['_M_dataplus']['_M_p']

          def display_hint(self):
          return 'string'


          Still quoting for the sake of completness:




          And here is an example showing how a lookup function for the printer example above might be written.




          def str_lookup_function(val):
          lookup_tag = val.type.tag
          if lookup_tag == None:
          return None
          regex = re.compile("^std::basic_string<char,.*>$")
          if regex.match(lookup_tag):
          return StdStringPrinter(val)
          return None





          share|improve this answer















          I found my own answer reading further the GDB capabilities and stack overflow questions concerning print of std::string.



          Short path



          I simply defined a gdb command as follows:



          # this is a gdb script
          # can be loaded from gdb using
          # source my_script.txt (or. gdb or whatever you like)
          define pjson
          # use the lohmann's builtin dump method, ident 4 and use space separator
          printf "%sn", $arg0.dump(4, ' ', true).c_str()
          end
          # configure command helper (text displayed when typing 'help pjson' in gdb)
          document pjson
          Prints a lohmann's JSON C++ variable as a human-readable JSON string
          end


          Using it in gdb:



          (gdb) source my_custom_script.gdb
          (gdb) pjson foo

          "flex" : 0.2,
          "awesome_str": "bleh",
          "nested":
          "bar": "barz"





          Over the top



          The other way is to define a GDB pretty printer in python and make it tightly associated to your project (autoloading stuff activated). See this link for an in-depth approach.



          Basically, when in gdb you would type:



          (gdb) p foo


          and GDB will automagically test for foo's type and invoke the associated pretty printer if any. That would end-up in the same result. The main difference is that it is done using the well-known print command. The person debugging would not have to learn a new command (like the pjson defined in the short answer).



          Quoting:




          A pretty-printer consists of two parts: a lookup function to detect if the type is supported, and the printer itself.



          Here is an example showing how a std::string printer might be written. See Pretty Printing API, for details on the API this class must provide.




          class StdStringPrinter(object):
          "Print a std::string"

          def __init__(self, val):
          self.val = val

          def to_string(self):
          return self.val['_M_dataplus']['_M_p']

          def display_hint(self):
          return 'string'


          Still quoting for the sake of completness:




          And here is an example showing how a lookup function for the printer example above might be written.




          def str_lookup_function(val):
          lookup_tag = val.type.tag
          if lookup_tag == None:
          return None
          regex = re.compile("^std::basic_string<char,.*>$")
          if regex.match(lookup_tag):
          return StdStringPrinter(val)
          return None






          share|improve this answer














          share|improve this answer



          share|improve this answer








          edited 8 mins ago

























          answered 6 hours ago









          LoneWandererLoneWanderer

          1,112825




          1,112825












          • That looks pretty useful. Unfortunately I am out of votes ATM.

            – πάντα ῥεῖ
            6 hours ago


















          • That looks pretty useful. Unfortunately I am out of votes ATM.

            – πάντα ῥεῖ
            6 hours ago

















          That looks pretty useful. Unfortunately I am out of votes ATM.

          – πάντα ῥεῖ
          6 hours ago






          That looks pretty useful. Unfortunately I am out of votes ATM.

          – πάντα ῥεῖ
          6 hours ago




















          draft saved

          draft discarded
















































          Thanks for contributing an answer to Stack Overflow!


          • Please be sure to answer the question. Provide details and share your research!

          But avoid


          • Asking for help, clarification, or responding to other answers.

          • Making statements based on opinion; back them up with references or personal experience.

          To learn more, see our tips on writing great answers.




          draft saved


          draft discarded














          StackExchange.ready(
          function ()
          StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55316620%2fc-debug-print-custom-type-with-gdb-the-case-of-nlohmann-json-library%23new-answer', 'question_page');

          );

          Post as a guest















          Required, but never shown





















































          Required, but never shown














          Required, but never shown












          Required, but never shown







          Required, but never shown

































          Required, but never shown














          Required, but never shown












          Required, but never shown







          Required, but never shown







          Popular posts from this blog

          Are there any AGPL-style licences that require source code modifications to be public? Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?Force derivative works to be publicAre there any GPL like licenses for Apple App Store?Do you violate the GPL if you provide source code that cannot be compiled?GPL - is it distribution to use libraries in an appliance loaned to customers?Distributing App for free which uses GPL'ed codeModifications of server software under GPL, with web/CLI interfaceDoes using an AGPLv3-licensed library prevent me from dual-licensing my own source code?Can I publish only select code under GPLv3 from a private project?Is there published precedent regarding the scope of covered work that uses AGPL software?If MIT licensed code links to GPL licensed code what should be the license of the resulting binary program?If I use a public API endpoint that has its source code licensed under AGPL in my app, do I need to disclose my source?

          2013 GY136 Descoberta | Órbita | Referências Menu de navegação«List Of Centaurs and Scattered-Disk Objects»«List of Known Trans-Neptunian Objects»

          Metrô de Los Teques Índice Linhas | Estações | Ver também | Referências Ligações externas | Menu de navegação«INSTITUCIÓN»«Mapa de rutas»originalMetrô de Los TequesC.A. Metro Los Teques |Alcaldía de Guaicaipuro – Sitio OficialGobernacion de Mirandaeeeeeee