variable - ¿Descarga la instalación en C++ como var_dump() en PHP?

var_export en php

Question

Cuando estaba en la universidad hice algo de C / C ++, pero en un futuro cercano estaba trabajando en PHP, y ahora deseo dedicar más tiempo al aprendizaje de C / C ++.

En PHP estaba usando print_r () o var_dump () para mostrar datos de estructuras o arreglos. ¿Tengo esa funcionalidad predeterminada en C, para ver qué tengo en una estructura o matriz?

Answer 1

C ++ en sí mismo no proporciona algo como var_dump, pero con bibliotecas como Boost.Fusion y ADAPT_STRUCT y ADAPT_ADT es fácil de hacer.

De hecho, como se indica en la otra respuesta, el compilador de C ++ no genera los metadatos necesarios para generar dicha salida. Sin embargo, es posible generar estos metadatos y usar un poco de metaprogramación de plantillas para usarlos.

De esa manera, he implementado aquí una adap_struct_printer, que puede imprimir std :: container, cualquier clase o estructura, boost :: variant y boost :: tuple.

Nueva solucion

Ahora puedes hacer fácilmente lo siguiente:

#include <iostream>
#include <pre/json/to_json.hpp>

struct customer {
  std::string name;
  size_t money_spent;
  std::vector<std::string> interests;
};

BOOST_FUSION_ADAPT_STRUCT(customer,
  name,
  money_spent,
  interests)

...

customer my_customer{
  "Mr. Dupond",
  1000,
  {"sport articles", "food", "tools"}
};

std::cout << pre::json::to_json(my_customer) << std::endl;

También puede invertir con esta biblioteca desde json para rellenar las estructuras de json.

La documentación está disponible aquí: http://daminetreg.github.io/lib-cpp-pre/html/namespacepre_1_1json.html#a4325d2cdd64a7e321303fd4428f298b9

Respuesta VIEJA

El único requisito es que llame a BOOST_FUSION_ADAPT_STRUCT / BOOST_FUSION_ADAPT_ADT en sus clases (consulte http://www.boost.org/doc/libs/1_57_0/libs/fusion/doc/html/fusion/adapted.html )

De modo que este ejemplo:

#include <iostream>

#include <swissarmyknife/boost/fusion/adapted_struct_printer.hpp>

#include <boost/fusion/include/define_struct.hpp>
#include <boost/variant.hpp>
#include <boost/tuple/tuple.hpp>


namespace bla {

  struct someclass {
     int i = 12;
     int j = 15;
  };

  using boost::fusion::detail::operator <<;
}

BOOST_FUSION_ADAPT_STRUCT(bla::someclass,
  (int, i)
  (int, j)
)

BOOST_FUSION_DEFINE_STRUCT((bla), innerbim,
    (std::string, mystring)
    )

BOOST_FUSION_DEFINE_STRUCT((bla), bimbim,
    (int, boom)
    (int, bam)
    (bla::innerbim, my_inner_bim)
    )


typedef boost::variant<int, double, bla::innerbim> myvariant_t;
typedef boost::tuple<std::string, int, bla::innerbim, myvariant_t> my_tuple_t;


BOOST_FUSION_DEFINE_STRUCT((bla), blabla,
    (bla::bimbim, bim)
    (int, i)
    (int, j)
    (std::vector<double>, list)
    (std::list<bla::bimbim>, list_of_bimbim)
    (my_tuple_t, mytuple)
    (myvariant_t, myvariant)
    )

int main(int argc, char** argv) {
  using namespace swak;

  bla::blabla instance{
    {22, 12, bla::innerbim{"COOL"} }, 
    23,
    43, 
    {2.00, 39.07, 24.05},
    { 
      {24, 9, bla::innerbim{"FEEL GOOD"} },
      {26, 14, bla::innerbim{"SO BAD"} },
    },
    {"Hey that''s not an int", 1, bla::innerbim{"hello"}, 12},
    bla::innerbim("I''m in the variant")
  };
  std::cout << instance << std::endl;

  bla::someclass otherinstance{};
  std::cout << "Other instance : " << otherinstance << std::endl;

  return 0;
}

Imprime lo siguiente:

{
    bim :
        {
            boom : 22,
            bam : 12,
            my_inner_bim :
                {
                    mystring : COOL,
                }
        }
    i : 23,
    j : 43,
    list : [2, 39.07, 24.05],
    list_of_bimbim : [    
        {
            boom : 24,
            bam : 9,
            my_inner_bim :
                {
                    mystring : FEEL GOOD,
                }
        }
    ,     
        {
            boom : 26,
            bam : 14,
            my_inner_bim :
                {
                    mystring : SO BAD,
                }
        }
    ],
    mytuple :
        {
            0 (Ss) : Hey that''s not an int,
            1 (i) : 1,
            2 (N3bla8innerbimE) :
                {
                    mystring : hello,
                }
            3 (N5boost7variantIidN3bla8innerbimENS_6detail7variant5void_ES5_S5_S5_S5_S5_S5_S5_S5_S5_S5_S5_S5_S5_S5_S5_S5_EE) : 

                {
                    12}
        }
    myvariant : 

        {

            {
                mystring : I''m in the variant,
            }
        }
}

Other instance :     
    {
        i : 12,
        j : 15,
    }

Estoy mejorando la implementación para obtenerla en algún momento como una posible nueva característica de boost fusion, pero ya se puede utilizar como se muestra allí:

https://github.com/daminetreg/lib-cpp-swissarmyknife/blob/feature/adapted_struct_printer_improved/test/adapted_struct_printer.cpp

Answer 2

En el artículo de microsoft tenemos alguna solución:

vector :: push_back

https://msdn.microsoft.com/pt-br/library/7fthz5xd.aspx

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";
    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

y el llamado para esto:

cout << "vector data: " << endl;
print_collection(v);

Answer 3

Es posible, pero se requeriría mucho trabajo si se habilitaran los símbolos de depuración y se deshabilitaran todas las optimizaciones. También sería lento y quizás no muy confiable [* 1].

Cualquier cosa que pueda hacer un depurador podría ser replicada por una función dump () que causa un punto de interrupción, y se desconecta la información.

Algunos depuradores pueden automatizarse, por lo que tal vez la función de volcado se escriba en el depurador.

* 1, por ejemplo, los depuradores a veces se bloquean al tratar con algunos puntos de interrupción. por ejemplo, el programa debería tener un punto de interrupción y detener todos los subprocesos antes de intentar volcar datos. Por ejemplo, los programas que necesitan lidiar con interrupciones en tiempo real probablemente no funcionen. Por ejemplo, el depurador debe ser lo suficientemente confiable para enfrentar muchos puntos de interrupción y no presentar otros problemas.

Answer 4

No, no hay. Use un depurador como ddd , por ejemplo. La mayoría de los IDEs tienen uno integrado.

Answer 5

No, tiene que hacer su propio rollo usando uno de la familia de funciones de salida de cout o C style printf para las estructuras de datos definidas por el usuario. De manera similar, para las matrices, (excepto las cadenas de estilo C), tendrá que recorrer todos los elementos e imprimir cada uno.

Answer 6

No hay tal funcionalidad en C ++. Por supuesto, puedes escribir tus propias funciones Dump (). La razón por la cual una característica de este tipo no puede proporcionarse generalmente es que el proceso de compilación en C ++ elimina los metadatos del objeto necesarios para estructurar la salida del volcado. Por supuesto, puede mostrar los contenidos de la estructura en un depurador, donde dichos metadatos se mantienen en la información de depuración.

Por cierto, ¿estás preguntando por C o C ++? Los dos idiomas son bastante diferentes, tanto en características como en enfoque, aunque ninguno tiene var_dump () o similar.