TOUGH: Traiter avec des pointeurs profondément imbriquées dans C ++

Question

Je décris cette structure:

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

et ces structures:

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

puis dans mon code, je renvoie un pointeur sur un s_molecule (typedef à t_molecule, mais quand même).

En utilisant ce pointeur je peux obtenir ce code au travail:

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 je le remplace par:

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

Je reçois maintenant segfaults méchant ...

Ne pas mettre trop ici, mais je suis aussi obtenir segfaults quand j'ai essayé de le faire:

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

Encore une fois, current_molecule est un pointeur sur une structure de s_molecule, qui contient des tableaux de structures, qui à leur tour ont soit directement ou vars sont des pointeurs. Je ne peux pas obtenir ces multiples couches de indirection au travail. Suggestions sur la fixation de ces segfaults.

Pour votre information, je suis la compilation sur Linux CentOS 5.4 avec g ++ et en utilisant un système de Makefile personnalisé.

Answer 1

Encore une fois, cette question a été répondu ici: problème étrange pointeur en C ++ par DeadMG. Désolé pour le double post.

Answer 2

@sbi Merci pour les bons conseils! Je crois que vous avez raison - l'affectation opérateur surchargé est inutile et doit être mis au rebut

.

J'ai suivi l'approche de commenter des trucs et je suis très confus. En gros, dans la fonction qui passe le pointeur sur ma molécule particulière à la fonction principale d'imprimer, je peux voir toutes les données dans cette molécule (obligations, particules, nom, etc.) parfaitement, avec l'impression de Cout.

Une fois que je passe à la principale comme ptr, si j'utilise ce ptr avec un iterator je reçois une erreur de segmentation. En d'autres termes. En outre, pour une raison les données d'obligations (que je peux librement imprimer dans mon fonct qui retourne au pointeur) segfaults aussi si je tente d'imprimer, même si je l'utilise [] pour indexer le vecteur des obligations (qui travaille pour la particule vecteur).

C'est la meilleure information que je peux donner pour l'instant.

Answer 3

Une conjecture sauvage: Utilisez-vous des bibliothèques partagées. Je me souviens avoir des difficultés qui passe avant et en arrière STL-conteneurs à travers les frontières bibliothèque partagée.

Answer 4

Jason (OP) a demandé dans un commentaire de David Rodríguez:

  

Retournez-vous un pointeur vers une variable locale?

Jason répondit:

  

Non est un PTR à une variable de classe. La classe est très bien dans l'existence (il contient la fonction qui renvoie la molécule).

Sauf si vous parlez d'une véritable variable de classe (qualifiée static), le fait que le class EXISTE n'a pas grand-chose à voir avec cela. Les instances d'une exist de classe, et ils auraient pu cessé d'exister même si vous venez d'appeler une fonction sur eux.

En tant que tel, la question est:

• Est-ce que le exemple de la classe qui a renvoyé le pointeur current_molecule existe encore?
• Ou est-current_molecule qualifié static, à savoir être une vraie variable de classe?

Si la réponse aux deux questions est "non", vous êtes dans Undefined County.

À ce stade, il devient très important que vous le code postal source qui peut être utilisé par nous ici pour reproduire réellement le problème; il pourrait bien se trouver dans la source que vous ne nous montrez.