TOUGH: Der Umgang mit tief verschachtelt Zeiger in C ++

Question

Ich definiere diese Struktur:

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

und diese Strukturen:

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

und dann in meinem Code kehre ich einen Zeiger auf eine s_molecule (typedef'd zu t_molecule, aber immer noch).

Mit diesem Zeiger kann ich diesen Code an der Arbeit:

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

Wenn ich ersetzen Sie es mit:

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

ich jetzt böse segfaults ...

Nicht zu setzen viel hier, aber ich bin auch segfaults bekommen, als ich versuchte, dies zu tun:

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

Auch hier ist current_molecule ein Zeiger auf eine s_molecule Struktur, die Arrays von Strukturen enthält, die wiederum entweder direkt Vars oder sind Zeiger. Ich kann diese mehrere Schichten Indirektionsebene an die Arbeit. Vorschläge für diese segfaults fixieren.

FYI auf ich Kompilieren Linux Centos 5.4 mit g ++ und einem eigenen Make-Datei-System.

Answer 1

Auch hier wurde diese Frage beantwortet: Weird-Pointer Problem in C ++ von DeadMG. Sorry für den Doppelpost.

Answer 2

@sbi Danke für die guten Ratschläge! Ich glaube, Sie haben Recht - die Zuordnung überladenen Operator unnötig und sollte verschrottet werden

.

Ich habe den Ansatz der Kommentierung aus Sachen gefolgt und bin sehr verwirrt. Im Grunde genommen in der Funktion, die den Zeiger auf mein bestimmtes Molekül an der Hauptfunktion geht zu drucken, kann ich alle Daten in diesem Moleküle (Anleihen, Partikel, Namen, usw.) perfekt, Drucke mit cout sehen.

Wenn ich es auf die Haupt als ptr passieren, wenn ich das ptr mit einem Iterator verwenden erhalte ich eine segfault. Mit anderen Worten. Auch aus irgendeinem Grund die Bindungsdaten (die ich frei in meiner Funkt drucken können, dass die Renditen auf den Zeiger) auch Segfaults wenn ich versuche, es zu drucken, auch wenn ich die [] indizieren den Vektor von Anleihen verwenden (die für die Partikel arbeitet Vektor).

Das ist die besten Informationen, die ich jetzt geben kann.

Answer 3

Eine wilde Vermutung: Verwenden Sie gemeinsam genutzte Bibliotheken. Ich erinnere mich, Schwierigkeiten STL-Container hin und her über gemeinsam benutzte Bibliothek Grenzen übergeben.

Answer 4

Jason (OP) wurde in einem Kommentar von David Rodríguez fragt:

  

Sind Sie einen Zeiger auf eine lokale Variable Rückkehr?

Jason antwortete:

  

Nein, es ist ein ptr auf eine Klassenvariable. Die Klasse ist sehr viel in Existenz (es enthält die Funktion, dass kehrt das Molekül).

Es sei denn, Sie sprechen von einer echten Klassenvariable (qualifiziert als static), die Tatsache, dass die Klasse existiert nicht viel damit zu tun hat. Instanzen eine Klasse existiert, und sie könnten nicht mehr bestehen, auch wenn Sie nur eine Funktion auf sie beruft.

Als solche ist die Frage:

• Ist die Instanz von der Klasse, die die Zeiger current_molecule existiert noch zurück?
• Oder ist current_molecule als static qualifiziert, das heißt eine echte Klassenvariable zu sein?

Wenn die Antwort auf beiden Fragen lautet „nein“, sie ist in undefiniert County.

An diesem Punkt wird es sehr wichtig, dass Sie den Quellcode veröffentlichen, die hier von uns genutzt werden kann, um tatsächlich das Problem zu reproduzieren; es könnte auch in Quelle installiert werden Sie uns nicht zeigen.