TOUGH: Trattare con i puntatori profondamente ramificate in C ++

Question

Lo definisco struttura:

struct s_molecule
{
  std::string res_name;
  std::vector<t_particle> my_particles;
  std::vector<t_bond> my_bonds;
  std::vector<t_angle> my_angles;
  std::vector<t_dihedral> my_dihedrals;

  s_molecule& operator=(const s_molecule &to_assign)
  {
    res_name = to_assign.res_name;
    my_particles = to_assign.my_particles;
    my_bonds = to_assign.my_bonds;
    my_angles = to_assign.my_angles;
    my_dihedrals = to_assign.my_dihedrals;
    return *this;
  }
};

e queste strutture:

typedef struct s_particle
{
  t_coordinates position;
  double charge;
  double mass;
  std::string name;
  std::vector<t_lj_param>::iterator my_particle_kind_iter;

  s_particle& operator=(const s_particle &to_assign)
  {
    position = to_assign.position;
    charge = to_assign.charge;
    mass = to_assign.mass;
    name = to_assign.name;
    my_particle_kind_iter = to_assign.my_particle_kind_iter;
    return *this;
  }
} t_particle;

struct s_bond
{
  t_particle * particle_1;
  t_particle * particle_2;
  std::vector<t_bond_param>::iterator my_bond_kind_iter;

  s_bond& operator=(const s_bond &to_assign)
  {
    particle_1 = to_assign.particle_1;
    particle_2 = to_assign.particle_2;
    my_bond_kind_iter = to_assign.my_bond_kind_iter;
    return *this;
  }
};

e poi nel mio codice ho tornare un puntatore ad un s_molecule (typedef per t_molecule, ma ancora).

Con questo puntatore posso ottenere questo codice al lavoro:

for  (unsigned int i = 0;
      i < current_molecule->my_particles.size();
      i++)
    {
      std::cout << "Particle " 
        << current_molecule->my_particles[i].name << std::endl
            << "Charge: " 
        << current_molecule->my_particles[i].charge << std::endl
        << "Mass: " 
        << current_molecule->my_particles[i].mass << std::endl
        << "Particle Kind Name: " 
        << (*current_molecule->my_particles[i].my_particle_kind_iter).atom_kind_name 
        << std::endl
        << "x: " << current_molecule->my_particles[i].position.x 
        << " y: " << current_molecule->my_particles[i].position.y
    #ifdef USE_3D_GEOM
        << "z: " << current_molecule->my_particles[i].position.z
    #endif
        << std::endl;
    }

Se sostituisco con:

for  (std::vector<t_particle>::iterator it = current_molecule->my_particles.begin();
      it !=current_molecule->my_particles.end();
      it++)
    {
      std::cout << "Particle " 
        << (*it).name << std::endl
            << "Charge: " 
        << (*it).charge << std::endl
        << "Mass: " 
        << (*it).mass << std::endl
        << "Particle Kind Name: " 
        << (*(*it).my_particle_kind_iter).atom_kind_name 
        << std::endl
        << "x: " << (*it).position.x 
        << " y: " << (*it).position.y
    #ifdef USE_3D_GEOM
        << "z: " << (*it).position.z
    #endif
        << std::endl;
    }

io ora ottenere segfaults brutte ...

Per non mettere troppo qui, ma sto anche ricevendo segfaults quando ho provato a fare questo:

std::cout << "Bond ATOMS : " 
          << (*current_molecule).my_bonds[0].particle_1->name
          << std::endl

Ancora una volta, current_molecule è un puntatore a una struttura s_molecule, che contiene array di strutture, che a loro volta hanno o direttamente o vars sono puntatori. Non riesco a ottenere questi strati multipli di riferimento indiretto al lavoro. Suggerimenti su fissazione di tali segfaults.

FYI Sto compilando su Linux CentOS 5.4 con g ++ e utilizzando un sistema di makefile personalizzato.

Answer 1

Ancora una volta, questo problema è stato risposto qui: problema strano puntatore in C ++ by DeadMG. Siamo spiacenti per il doppio post.

Answer 2

Grazie per il consiglio @sbi buona! Credo che tu abbia ragione - l'operatore di assegnamento è inutile e dovrebbe essere scartato

.

Ho seguito l'approccio di commentare fuori roba e sono molto confuso. In sostanza nella funzione che passa il puntatore al mio particolare molecola alla funzione principale per la stampa, posso vedere tutti i dati in quella molecola (obbligazioni, particelle, nome, ecc) perfettamente, la stampa con cout di.

Una volta lo passo alla principale come PTR, se uso che PTR con un iteratore ottengo un segmentation fault. In altre parole. Anche per qualche motivo i dati dei titoli (che posso stampare liberamente nel mio funct che ritorna il puntatore) segfaults anche se provo a stampare, anche se uso il [] per indicizzare il vettore di obbligazioni (che lavora per la particella vettore).

Ecco le migliori informazioni che posso dare per ora.

Answer 3

un ipotesi: Si sta utilizzando librerie condivise. Mi ricordo di aver difficoltà passando STL contenitori avanti e indietro attraverso i confini delle librerie condivise.

Answer 4

Jason (OP) è stato chiesto in un commento di David Rodríguez:

  

Stai tornando un puntatore a una variabile locale?

Jason rispose:

  

Non proprio un PTR ad una variabile di classe. La classe è molto in esistenza (che contiene la funzione che restituisce la molecola).

A meno che non si sta parlando di una variabile di classe vera (qualificato come static), il fatto che il class esiste non ha molto a che fare con esso. Le istanze di un esistere di classe, e potrebbero avere cessato di esistere, anche se hai appena chiamato una funzione su di loro.

In quanto tale, la domanda è:

• Fa istanza della classe che ha restituito il puntatore current_molecule esiste ancora?
• O è current_molecule qualificato come static, vale a dire essere una variabile di classe vero?

Se la risposta ad entrambe le domande è "no", sei in indefinito County.

A questo punto, diventa molto importante che si registra il codice sorgente che può essere utilizzato da noi qui in realtà riprodurre il problema; potrebbe benissimo trovarsi in origine non si sta mostrando noi.