[Analyse approfondie C ++ et résumé d'apprentissage] 28 amis

[Analyse approfondie C ++ du résumé de l'apprentissage] 27 amis

Auteur CodeAllen , veuillez indiquer la source

---

1. Quel est le concept
d'ami?

• Les amis sont une relation en C ++
• L'amitié se produit entre les fonctions et les classes ou entre les classes et les classes
• L' amitié est un seul article ne peut pas livrer
  
  l'utilisation de 2 amis
• Déclarer des amis avec le mot-clé ami dans la classe
• Les amis d'une classe peuvent être d'autres classes ou des fonctions spécifiques
• Les amis ne font pas partie de la classe
• Les amis ne sont pas limités par le niveau d'accès dans la classe
• Les amis peuvent accéder directement à tous les membres d'une classe spécifique

3. syntaxe ami
de déclarer une fonction ou une classe dans la classe avec mot - clé ami

utilisation dans un ami

#include <stdio.h>
#include <math.h>

class Point
{
    double x;
    double y;
public:
    Point(double x, double y)
    {
        this->x = x;
        this->y = y;
    }
    
    double getX()
    {
        return x;
    }
    
    double getY()
    {
        return y;
    }
       
    friend double func(Point& p1, Point& p2);
};

double func(Point& p1, Point& p2)
{
    double ret = 0;
    
    ret = (p2.y - p1.y) * (p2.y - p1.y) +
          (p2.x - p1.x) * (p2.x - p1.x);
          
    ret = sqrt(ret);
    
    return ret;
}

int main()
{
    Point p1(1, 2);
    Point p2(10, 20);
    
    printf("p1(%f, %f)\n", p1.getX(), p1.getY());
    printf("p2(%f, %f)\n", p2.getX(), p2.getY());
    printf("|(p1, p2)| = %f\n", func(p1, p2));
    
    
    return 0;
}

4. Embarras des amis

• Youyuan est né pour prendre en compte l'efficacité du langage C
• Youyuan détruit directement l'encapsulation de l'objet
• L'efficacité de Youyuan dans les produits réels ne vaut pas les gains
• Youyuan a été progressivement abandonné dans l'ingénierie logicielle moderne (car les caractéristiques de l'emballage sont détruites)

5. Questions nécessitant une attention

• Les amis ne sont pas transitifs
• Les amis d'une classe peuvent être des fonctions membres d'autres classes
• Les amis d'une classe peuvent être une classe complète
  • Toutes les fonctions membres sont des amis
    

Analyse approfondie des amis

#include <stdio.h>

class ClassC
{
    const char* n;
public:
    ClassC(const char* n)
    {
        this->n = n;
    }
    
    friend class ClassB;
};

class ClassB
{
    const char* n;
public:
    ClassB(const char* n)
    {
        this->n = n;
    }
    
    void getClassCName(ClassC& c)
    {
        printf("c.n = %s\n", c.n);
    }
    
    friend class ClassA;
};

class ClassA
{
    const char* n;
public:
    ClassA(const char* n)
    {
        this->n = n;
    }
    
    void getClassBName(ClassB& b)
    {
        printf("b.n = %s\n", b.n);
    }
    /*
    void getClassCName(ClassC& c)
    {
        printf("c.n = %s\n", c.n);
    }
    */
};

int main()
{
    ClassA A("A");
    ClassB B("B");
    ClassC C("C");
    
    A.getClassBName(B);
    B.getClassCName(C);
    
    return 0;
}

Résumé Les
amis sont nés pour prendre en compte l'efficacité du langage C. Les
amis détruisent directement l'encapsulation orientée objet. Les
amis n'ont pas de transitivité. Les
amis d'une classe peuvent être membres d'autres classes
. Classe de