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

If infinitesimal transformations commute why dont the generators of the Lorentz group commute?

L1 and Ln cache: when are they written?

Is it better practice to read straight from sheet music rather than memorize it?

How much character growth crosses the line into breaking the character

Symbol used to indicate indivisibility

Can I sign legal documents with a smiley face?

What should you do when eye contact makes your subordinate uncomfortable?

Pre-mixing cryogenic fuels and using only one fuel tank

How to follow the Halacha?

Is this toilet slogan correct usage of the English language?

Has any country ever had 2 former presidents in jail simultaneously?

Not using 's' for he/she/it

How should I respond when I lied about my education and the company finds out through background check?

When were female captains banned from Starfleet?

Redundant comparison & "if" before assignment

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

What does routing an IP address mean?

Problem with TransformedDistribution

How do you make your own symbol when Detexify fails?

Is the U.S. Code copyrighted by the Government?

Does a 'pending' US visa application constitute a denial?

On a tidally locked planet, would time be quantized?

Did arcade monitors have same pixel aspect ratio as TV sets?

A social experiment. What is the worst that can happen?



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 9 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

          名間水力發電廠 目录 沿革 設施 鄰近設施 註釋 外部連結 导航菜单23°50′10″N 120°42′41″E / 23.83611°N 120.71139°E / 23.83611; 120.7113923°50′10″N 120°42′41″E / 23.83611°N 120.71139°E / 23.83611; 120.71139計畫概要原始内容臺灣第一座BOT 模式開發的水力發電廠-名間水力電廠名間水力發電廠 水利署首件BOT案原始内容《小檔案》名間電廠 首座BOT水力發電廠原始内容名間電廠BOT - 經濟部水利署中區水資源局

          Prove that NP is closed under karp reduction?Space(n) not closed under Karp reductions - what about NTime(n)?Class P is closed under rotation?Prove or disprove that $NL$ is closed under polynomial many-one reductions$mathbfNC_2$ is closed under log-space reductionOn Karp reductionwhen can I know if a class (complexity) is closed under reduction (cook/karp)Check if class $PSPACE$ is closed under polyonomially space reductionIs NPSPACE also closed under polynomial-time reduction and under log-space reduction?Prove PSPACE is closed under complement?Prove PSPACE is closed under union?

          Is my guitar’s action too high? Announcing the arrival of Valued Associate #679: Cesar Manara Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern)Strings too stiff on a recently purchased acoustic guitar | Cort AD880CEIs the action of my guitar really high?Μy little finger is too weak to play guitarWith guitar, how long should I give my fingers to strengthen / callous?When playing a fret the guitar sounds mutedPlaying (Barre) chords up the guitar neckI think my guitar strings are wound too tight and I can't play barre chordsF barre chord on an SG guitarHow to find to the right strings of a barre chord by feel?High action on higher fret on my steel acoustic guitar