Objets et surcharge d'opérateur C++

Question

class object_1 
{ 
    public: 
    ... 

    friend ofstream& operator<<(ofstream &out, const object_1 &obj_1); 
    friend object_2; 

    private: 

    char *pCh_mem1; 
    char *pCh_mem2; 
    int *pInt_mem1; 
    int *pInt_mem2; 
}; 


class object_2 
{ 
public: 
... 
friend ofstream& operator<<(ofstream &out, const object_2 &obj_2); 
friend object_1; 
}; 

Le fichier d'implémentation d'Object1 est typique. Ctor, Dtor et quelques méthodes. Je n'ai pas publié les déclarations de méthode dans l'en-tête parce qu'elles ne sont pas pertinentes à mon problème.

Il est très important que je discute la vie des objets. C'est quelque chose que j'ai vraiment besoin de comprendre. Ce qui se passe, c'est que la fonction de surcharge de l'opérateur est invoquée quand j'appelle object_2 dans main. Alors la fonction de surcharge de l'opérateur est appelé:

ostream& operator<<(ostream& out, const object_2& obj_2) 
{ 
object1::display(out) //Calls method display in object1's I.F. 
return out; 
} 

nous sommes ici: Au sommet du fichier de mise en œuvre

void object_1::display(std::ostream &out) 
{ 
out << left << setw(28) << "Person" << setw(20) << "Place" ; 
out << right << setw(5) << "Thing" << setw(5) << "Idea" << endl; 

out << left << setw(28) << "----" << setw(20) << "--------" ; 
out << right << setw(5) << "----- " << setw(5) << "------" << endl; 
} 

est la bibliothèque iomanip. Donc setw (X) et tout est défini. Im obtenir 0 est tout à la console. Mon objet est-il hors de portée? Je le pense parce que quand je fais tout cela avant que j'en ai besoin, ça fonctionne bien. C'est-à-dire, quand j'appelle cette fonction là où ailleurs que dans le corps de l'opérateur, ça marche. Je pense que parce que l'objet est redéclaré:

ostream& operator<<(ostream& out, const object_2& obj_2); 

puis après imprimer la méthode de mise en forme que j'ai besoin d'imprimer les informations qui a été adoptée dans de principal au cteur du premier objet; object_1. Quand cela arrive, nous sommes dans la fonction de surcharge qui est similaire et c'est le même fichier d'implémentation. Im appeler les deux méthodes de la surcharge de la deuxième fonction de surcharge d'objets:

ostream& operator<<(ostream& out, const object_1& obj_1) 
{ 
out << obj_1.pCh_mem1 << obj_1.pCh_mem2; 
return out; 
} 

// principale Objet_2 obj_2 (4); Une fois que objc_2 est appelé comme ci-dessus, la surcharge de l'opérateur pour la classe de object2 sera alors appelée. Je ne peux pas utiliser l'un de mes membres privés parce que c'est une opération illégale. Je suppose que mes questions sont. Comment puis-je imprimer mes membres privés à partir de object1 dans la fonction de surcharge de l'opérateur de mon object2? static_cast's? J'ai un extrait aléatoire de la main, c'est compliqué et je ne peux pas le modifier. Ce que j'ai essayé de faire, comme vous voyez ci-dessus, appelle les autres méthodes d'objets, et obtient l'information de leur. Mais cette info est toute NULL !! Im sautant d'un I.F. à l'autre et c'est tout NULL !!

Answer 1

AFAICT, object_1 et object_2 sont des classes non apparentées (sauf qu'elles sont des amis). Donc, un object_2 n'a aucun état pertinent pour un object_1. Par conséquent, lorsque vous essayez d'imprimer un object_2 comme s'il s'agissait d'un object_1, cela ne peut pas fonctionner. Il est surprenant de constater que cet appel fonctionne à tous:

ostream& operator<<(ostream& out, const object_2& obj_2) 
{ 
object1::display(out) //Calls method display in object1's I.F. 
return out; 
} 

puisqu'il n'y a pas object_1 ici pour laquelle une méthode peut être appelée (mais alors, vous avez probablement ne veut pas dire que cela soit vrai code, car il manque un point-virgule aussi).

Ce que vous voulez réaliser n'est pas complètement clair. Peut-être que vous voulez object_2 hériter de object_1, de sorte que tout object_2 aura également les membres pCh_mem1 etc? Peut-être vous voulez qu'un membre de object_2 soit un objet de type object_1?

Answer 2

ostream& operator<<(ostream& out, const object_2& obj_2) 
{ 
    out << object_1[thatIndexThatIstoreditAt] 
    return out; 
} 

J'ai besoin d'écrire quelques rapports sur ce genre de choses. =)