TOUGH: Tratar con punteros profundamente anidados en C ++

Question

defino esta estructura:

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

y estas estructuras:

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

y luego en mi código que devuelve un puntero a un s_molecule (typedef'd a t_molecule, pero aún así).

El uso de este puntero que puedo conseguir el código de trabajo:

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

Si sustituyo 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;
    }

Ahora recibo segfaults desagradables ...

No poner demasiado aquí, pero yo también estoy segfaults cuando traté de hacer esto:

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

Una vez más, current_molecule es un puntero a una estructura s_molecule, que contiene las matrices de estructuras, que a su vez, o bien tienen directamente vars o son punteros. No puedo conseguir estas múltiples capas de direccionamiento indirecto a trabajar. Sugerencias sobre la fijación de estos segfaults.

FYI Estoy compilando en Linux Centos 5.4 con g ++ y utiliza un sistema de archivo MAKE personalizado.

Answer 1

Una vez más, esta cuestión fue respondida aquí: tema extraño puntero en C ++ por DeadMG. Lo siento por el doble post.

Answer 2

Gracias por el consejo @sbi buena! Creo que tiene razón - el operador de asignación sobrecargado es innecesaria y debe ser desechado

.

He seguido el enfoque de la comentando cosas y estoy muy confundido. Básicamente en la función que pasa el puntero a mi molécula en particular a la función principal de imprimir, puedo ver todos los datos de esa molécula (bonos, partículas, nombre, etc.) a la perfección, la impresión con cout de.

Una vez lo paso a la principal como PTR, si uso que PTR con un iterador consigo una violación de segmento. En otras palabras. También por alguna razón los datos de bonos (que yo puedo imprimir libremente en mi func que vuelve al puntero) también segfaults si trato de imprimir, incluso si uso el [] para indexar el vector de bonos (que trabaja para la partícula vector).

Esa es la mejor información que puedo dar por ahora.

Answer 3

Una conjetura salvaje: ¿Está utilizando bibliotecas compartidas. Recuerdo haber tenido dificultades para pasar STL-contenedores de ida y vuelta a través de límites de bibliotecas compartidas.

Answer 4

Jason (OP) se le preguntó en un comentario de David Rodríguez:

  

¿Vuelve un puntero a una variable local?

Jason respondió:

  

No es un apuntador a una variable de clase. La clase está muy en existencia (que contiene la función que devuelve la molécula).

A menos que estés hablando de una variable de clase verdadera (calificado como static), el hecho de que el class existe no tiene mucho que ver con ello. Las instancias de un existir clase, y que podría haber dejado de existir, incluso si usted acaba de llamar una función en ellos.

Por lo tanto, la pregunta es:

• ¿El ejemplo de la clase que devuelve el puntero current_molecule todavía existe?
• O se current_molecule calificado como static, es decir, siendo un verdadero variable de clase?

Si la respuesta a ambas preguntas es "no", que está en el Condado Indefinido.

En este punto, se hace muy importante que publique el código fuente que puede ser utilizada por nosotros en realidad aquí para reproducir el problema; bien podría estar ubicado en fuente que no nos está mostrando.