que - punteros en c++ ejercicios resueltos pdf

La forma correcta de inicializar las estructuras de C++

Question

Nuestro código implica una estructura POD (estructura de datos antigua simple) (es una estructura básica de c ++ que tiene otras estructuras y variables de POD que necesita inicializarse al principio).

Basado en lo que he read , parece que:

myStruct = (MyStruct*)calloc(1, sizeof(MyStruct));

debe inicializar todos los valores a cero, como lo hace:

myStruct = new MyStruct();

Sin embargo, cuando la estructura se inicializa de la segunda manera, Valgrind luego se queja de que "salto o movimiento condicional depende de valores sin inicializar" cuando se usan esas variables. ¿Está mi entendimiento defectuoso aquí, o es Valgrind arrojando falsos positivos?

Answer 1

Dado que se trata de una estructura POD, siempre podría establecerse en 0: esta podría ser la forma más fácil de inicializar los campos (suponiendo que sea apropiado).

Answer 2

Debe inicializar los miembros que tenga en su estructura, por ejemplo:

struct MyStruct {
private:
int someInt_;
float someFloat_;
public:
MyStruct(): someInt_(0), someFloat_(1.0) {} // Initializer list will set appropriate values
};

Answer 3

En C ++ las clases / estructuras son idénticas (en términos de inicialización).

Una estructura que no sea POD también puede tener un constructor para que pueda inicializar miembros.
Si su estructura es un POD, puede usar un inicializador.

struct C
{
int x;
int y;
};
C c = {0}; // Zero initialize POD

Alternativamente puede usar el constructor predeterminado.

C c = C(); // Zero initialize using default constructor
C* c = new C(); // Zero initialize a dynamically allocated object.
// Note the difference between the above and the initialize version of the constructor.
// Note: All above comments apply to POD structures.
C c; // members are random
C* c = new C; // members are random (more officially undefined).

Creo que valgrind se queja porque así es como C ++ solía funcionar. (No estoy exactamente seguro de cuándo C ++ se actualizó con la construcción predeterminada de cero inicialización). Su mejor opción es agregar un constructor que inicialice el objeto (las estructuras son constructores permitidos).

Como nota al margen:
Muchos principiantes intentan valorar init:

C c(); // Unfortunately this is not a variable declaration.
// The correct way to do this is:
C c = C();

Una búsqueda rápida de "Parálisis más irritante" proporcionará una mejor explicación que yo.

Answer 4

Escribo un código de prueba:

#include <string>
#include <iostream>
#include <stdio.h>
using namespace std;
struct sc {
int x;
string y;
int* z;
};
int main(int argc, char** argv)
{
int* r = new int[128];
for(int i = 0; i < 128; i++ ) {
r[i] = i+32;
}
cout << r[100] << endl;
delete r;
sc* a = new sc;
sc* aa = new sc[2];
sc* b = new sc();
sc* ba = new sc[2]();
cout << "az:" << a->z << endl;
cout << "bz:" << b->z << endl;
cout << "a:" << a->x << " y" << a->y << "end" << endl;
cout << "b:" << b->x << " y" << b->y << "end" <<endl;
cout << "aa:" << aa->x << " y" << aa->y << "end" <<endl;
cout << "ba:" << ba->x << " y" << ba->y << "end" <<endl;
}

g ++ compilar y ejecutar:

./a.out
132
az:0x2b0000002a
bz:0
a:854191480 yend
b:0 yend
aa:854190968 yend
ba:0 yend

Answer 5

Por lo que nos has dicho, parece ser un falso positivo en valgrind. La new sintaxis con () debe inicializar el valor del objeto, suponiendo que sea POD.

¿Es posible que alguna subparte de tu estructura no sea realmente POD y eso impida la inicialización esperada? ¿Puedes simplificar tu código en un ejemplo postable que aún marque el error valgrind?

Alternativamente, tal vez su compilador no inicializa valores de las estructuras de POD.

En cualquier caso, probablemente la solución más simple es escribir constructor (es) según sea necesario para la estructura / subparte.