std :: vector <double> destrucción lanza SIGABRT

Question

Tengo un std::vector<double> En que GDB muestra que contiene estos valores:

Wph <5 items>   vector<double> 
    [0] 10.750281685547618  double 
    [1] 0.0053087812248281997 double 
    [2] 4.2807534148705719e-08 double 
    [3] 5.7427427663508097e-07 double 
    [4] 0      double 

Tras la destrucción automática cuando la función está saliendo, se lanza un SIGABRT.

0 raise raise.c 64 0x7fffeec5ad05 
1 abort abort.c 92 0x7fffeec5eab6 
2 __libc_message libc_fatal.c 189 0x7fffeec93d7b 
3 malloc_printerr malloc.c 6283 0x7fffeec9fa8f 
4 _int_free malloc.c 4795 0x7fffeec9fa8f 
5 __libc_free malloc.c 3738 0x7fffeeca38e3 
6 __gnu_cxx::new_allocator<double>::deallocate new_allocator.h 95 0x457828  
7 std::_Vector_base<double, std::allocator<double> >::_M_deallocate stl_vector.h 146 0x45567e  
8 std::_Vector_base<double, std::allocator<double> >::~_Vector_base stl_vector.h 132 0x4542b3  
9 std::vector<double, std::allocator<double> >::~vector stl_vector.h 314 0x453a96 

¿Qué está pasando?

int data = 0; 
    vector<double> Wph; 
    Wph.resize(mydata.data.size()); 

    for (size_t t = 0; t < mydata.t.size(); t++) 
    { 
    double t0 = (PI/180.0) * mydata.t[i]; 

    for (size_t p = 0; p < mydata.p.size(); p++) 
    { 

     double _Wph = 5; //arbitrary math 
     Wph[data] = _Wph; 

     data++; 
    } 
    } 

struct mydata 
{ 
    vector<double> t, p; 
    vector<point> data; 
}; 

Answer 1

Por favor, asegúrese mydata.data.size() == mydata.t.size() * mydata.p.size().

Has asignado mydata.t.size() * mydata.p.size() valores en un vector con mydata.data.size() elementos. Eso es una escritura encuadernada de la matriz.

Quizás deberías probar vector::push_back() en su lugar. Es decir,

vector<double> Wph; 

for (size_t t = 0; t < mydata.t.size(); t++) 
{ 
    double t0 = (PI/180.0) * mydata.t[i]; 

    for (size_t p = 0; p < mydata.p.size(); p++) 
    { 
    double _Wph = 5; //arbitrary math 
    Wph.push_back(_Wph); 
    } 
} 

Answer 2

datos = 5, p = 2, t = 3

for (size_t t = 0; t < mydata.t.size(); t++) 
    { 
    double t0 = (PI/180.0) * mydata.t[i]; 

    for (size_t p = 0; p < mydata.p.size(); p++) 
    { 

     double _Wph = 5; //arbitrary math 
     Wph[data] = _Wph; 

     data++; 
    } 
    } 

tanto, usted tiene doble circuito. Y tiene 6 repeticiones ... para que la memoria esté corrupta en t == 2 yp == 1, porque intentará hacer Wph[5] = _Wph y el índice legal máximo para Wph si su tamaño == 5 es 4.

Answer 3

Estás haciendo que Wph sea demasiado pequeño, sospecho. No sabemos qué es mydata.data.size(), pero supongo que es demasiado pequeño.

A partir del código, parece que el tamaño correcto es

Wph.resize(mydata.p.size() * mydata.t.size()); 

Sin embargo, en C++ tratamos de escribir código defensiva así que los errores como que son más difíciles de hacer.

vector<double> Wph; 

    for (size_t t = 0; t < mydata.t.size(); t++) 
    { 
    double t0 = (PI/180.0) * mydata.t[t]; 

    for (size_t p = 0; p < mydata.p.size(); p++) 
    { 
     double _Wph = 5; //arbitrary math 
     Wph.push_back(_Wph); 
    } 
    } 

Si tiene que asignar previamente el tamaño, entonces por lo menos el cambio

 Wph[data] = _Wph; 

a

 Wph.at(data) = _Wph; 

al() funciona igual que [], salvo que en() comprueba que no ha pasado el final de la matriz y lanza una excepción.