std :: vector <double> distruzione getta SIGABRT

Question

Ho una std::vector<double> In cui GDB mostra contenente questi valori:

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 

Su distruzione automatico quando la funzione è uscita, si getta una 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 

Cosa sta succedendo?

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

Si prega di assicurarsi mydata.data.size() == mydata.t.size() * mydata.p.size().

È stato assegnato un valore mydata.t.size() * mydata.p.size() a un vettore con elementi mydata.data.size(). Questa è una scrittura legata agli array.

Forse dovresti provare vector::push_back() invece. Cioè,

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

dati = 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++; 
    } 
    } 

Quindi, avete doppio anello. E hai 6 iterate ... quindi la memoria corrotta sarà su t == 2 ep == 1, perché proveresti a fare Wph[5] = _Wph e il massimo indice legale per Wph se la sua dimensione == 5 è 4.

Answer 3

Lo stai facendo troppo piccolo, sospetto. Non sappiamo cosa sia mydata.data.size(), ma suppongo che sia troppo piccolo.

Dal codice, sembra che la dimensione corretta è

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

Tuttavia in C++ si cerca di scrivere codice in modo difensivo errori del genere sono più difficili da fare.

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); 
    } 
    } 

Se è necessario pre-allocare le dimensioni, allora almeno cambiamento

 Wph[data] = _Wph; 

a

 Wph.at(data) = _Wph; 

a() funziona allo stesso modo [], salvo che a() controlla di non aver superato la fine dell'array e genera un'eccezione.