L'appel de constructeur avec plusieurs arguments

J'ai

Triangle::Triangle()
{
    A = NULL;
    B = NULL;
    C = NULL;
}
Triangle::Triangle(Point& X,Point& Y, Point& Z)
{
    A = new Point;
    *A = X;
    B = new Point;
    *B = Y;
    C = new Point;
    *C = Z;
}

and 

istream& operator>>(istream& in, Triangle& T)
{
    Point X,Y,Z;
    in>>X>>Y>>Z;
    Triangle T(X,Y,Z);  
    return in;
}

Si le Point est d'une autre classe qui définit un point avec coordonates X et Y.
Je ne sais pas comment appeler le constructeur avec plusieurs arguments dans la fonction surchargée. Pouvez-vous m'aider?

Une raison quelconque vous êtes en utilisant des pointeurs pour la classe de points et de prendre les arguments du constructeur par des non-const de référence?
Vous ne devriez pas utiliser un constructeur dans cette fonction, pas si vous êtes de passage dans un Triangle par référence.

InformationsquelleAutor user2116010 | 2013-03-02

arguments c++constructor

3

C'est comment vous le faites:
```
Point px;
Point py;
Point pz;
Triangle trig(px, py, pz);
```
trig sera l'objet, qui est une instance de la classe Triangle et ci-dessus pourrait appeler le constructeur avec 3 points d'arguments.

Une autre façon est pour les pointeurs:
```
 Triangle *pTrig = new Triangle(pX, pY, pZ);
```
En outre, je pense que ce serait mieux:
```
Triangle::Triangle()
   : A(NULL), B(NULL), C(NULL)
{
}

Triangle::Triangle(const Point& X,const Point& Y, const Point& Z)
 : A(new Point(X)), B(new Point(Y)), C(new Point(Z))
{
}
```
En supposant que le Point est un constructeur de copie.

Vous voulez l'appeler à partir à l'intérieur de la operator>> fonction de mise à jour argument T, mais cela ne fonctionne pas, parce que vous ne pouvez pas appeler le constructeur sur quelque chose qui est déjà construit. Au lieu de cela, ce que vous avez besoin est de mettre en œuvre un opérateur d'affectation. Veuillez voir http://en.wikipedia.org/wiki/Assignment_operator_%28C%2B%2B%29 pour plus d'informations.

Ensuite, vous pouvez faire T = Triangle(X,Y,Z);

Pour mettre en œuvre l'opérateur d'affectation, vous pouvez le faire:
```
Triangle& Triangle::operator= (const Triangle& other)
{
    if (this != &other) //protect against invalid self-assignment
    {
        if (A != NULL) delete A;
        if (B != NULL) delete B;
        if (C != NULL) delete C;
        A = new Point(other.A);
        B = new Point(other.B);
        C = new Point(other.C);
    }
    return *this;
}
```
En supposant que le Point a copier les constructeurs. Pour mettre en œuvre la copie des constructeurs, veuillez consulter http://en.wikipedia.org/wiki/Copy_constructor

Un constructeur de copie ressemble à celui-ci, mais vous devez le faire pour le Point:
```
Triangle& Triangle::Triangle(const Triangle& other)
  : A(new Point(other.A)), B(new Point(other.B)), C(new Point(other.C))
{
}
}
```
- J'ai essayé et me donne une "redéfinition du paramètre formel "T""
- Ahh... je comprends maintenant... vous voulez l'appeler à l'intérieur de l'opérateur>> fonction. Non... cela ne fonctionne pas. Permettez-moi de mettre à jour ma réponse.
- Génial!!C'est de travail, et vous avez fait de l'opérateur d'affectation de la fonction de trop. Super! Merci beaucoup!
InformationsquelleAutor ruben2020
0

Les deux premiers constructeurs sont dérogations pour le constructeur par défaut. La troisième fonction est la surcharge d'opérateur qui les surcharges >> de l'opérateur. Vous avez juste besoin de créer un objet de la classe Triangle comme suit:
```
Triangle tr(x,y,z);
```
ou
```
Triangle* tr = new Triangle(x,y,z);
```
Où x, y et z sont des objets de la classe Point.

Par la façon dont, comme vous pouvez le voir dans votre surcharge d'opérateur (la troisième fonction), vous êtes déjà la création d'un objet de la classe Triangle (Triangle T(X,Y,Z);).
- Oui mais l'argument de la surcharge d'opérateur est le premier constructeur et ne pas passer les bonnes valeurs de X,Y et Z
InformationsquelleAutor Yasser Mohseni

Vous devez vous connecter pour publier un commentaire.