C++基础学习-1

友元函数：

在函数名之前加上friend关键字：

对class的不同成员存在3个层次的内部保护：public， protected 和 private。在成员为 protected 和 private的情况下，它们不能够被从所在的class以外的部分引用。为了实现允许一个外部函数访问class的private 和 protected 成员，我们必须在class内部用关键字friend来声明该外部函数的原型，以指定允许该函数共享class的成员。

  #include <iostream.h>
    
    class CRectangle {
        int width, height;
      public:
        void set_values (int, int);
        int area (void) {return (width * height);}
        friend CRectangle duplicate (CRectangle);
    };
    
    void CRectangle::set_values (int a, int b) {
        width = a;
        height = b;
    }
    
    CRectangle duplicate (CRectangle rectparam) {
        CRectangle rectres;
        rectres.width = rectparam.width*2;
        rectres.height = rectparam.height*2;
        return (rectres);
    }
    
    int main () {
        CRectangle rect, rectb;
        rect.set_values (2,3);
        rectb = duplicate (rect);
        cout << rectb.area();
    }
			

友元类 (Friend classes)

就像我们可以定义一个friend 函数，我们也可以定义一个class是另一个的friend，以便允许第二个class访问第一个class的 protected 和 private 成员。

// friend class
    #include <iostream.h>
    
    class CSquare;

    class CRectangle {
        int width, height;
      public:
        int area (void) {return (width * height);}
        void convert (CSquare a);
    };
    
    Class CSquare {
      private:
        int side;
      public:
        void set_side (int a){side=a;}
        friend class CRectangle;
    };
    
    void CRectangle::convert (CSquare a) {
        width = a.side;
        height = a.side;
    }
    
    int main () {
        CSquare sqr;
        CRectangle rect;
        sqr.set_side(4);
        rect.convert(sqr);
        cout << rect.area();
        return 0;
    }

虚拟成员(Virtual members)

关键字virtual 的作用就是在当使用基类的指针的时候，使子类中与基类同名的成员在适当的时候被调用

如果想在基类中定义一个成员留待子类中进行细化，我们必须在它前面加关键字virtual ，以便可以使用指针对指向相应的对象进行操作。

#include <iostream.h>
class CPolygon {
    protected:
        int width, height;
    public:
        void set_values (int a, int b)  {
            width=a;
            height=b;
        }
        virtual int area (void) { return (0); }
};
class CRectangle: public CPolygon {
    public:
        int area (void) { return (width * height); }
};
class CTriangle: public CPolygon {
    public:
        int area (void) {
            return (width * height / 2);
        }
};
int main () {
    CRectangle rect;
    CTriangle trgl;
    CPolygon poly;
    CPolygon * ppoly1 = ▭
    CPolygon * ppoly2 = &trgl;
    CPolygon * ppoly3 = &poly;
    ppoly1->set_values (4,5);
    ppoly2->set_values (4,5);
    ppoly3->set_values (4,5);
    cout << ppoly1->area() << endl;
    cout << ppoly2->area() << endl;
    cout << ppoly3->area() << endl;
    return 0;
}

现在这三个类(CPolygon, CRectangle 和 CTriangle) 都有同样的成员：width, height, set_values() 和 area()。

area() 被定义为virtual 是因为它后来在子类中被细化了。你可以做一个试验，如果在代码种去掉这个关键字(virtual)，然后再执行这个程序，三个多边形的面积计算结果都将是 0 而不是20,10,0。这是因为没有了关键字virtual ，程序执行不再根据实际对象的不用而调用相应area() 函数(即分别为CRectangle::area(), CTriangle::area() 和 CPolygon::area())，取而代之，程序将全部调用CPolygon::area()，因为这些调用是通过CPolygon类型的指针进行的。

抽象基类(Abstract base classes)

在一个抽象类（abstract base class）中，我们可以对函数不定义，而简单得在函数声明后面写 =0 (等于0)。

类CPolygon 可以写成这样：

// abstract class CPolygon

class CPolygon {
    protected:
        int width, height;
    public:
        void set_values (int a, int b) {
            width=a;
            height=b;
        }
        virtual int area (void) =0;
};

我们是如何在virtual int area (void)加　=0 来代替函数的具体实现的。这种函数被称为纯虚拟函数（pure virtual function），而所有包含纯虚拟函数的类被称为抽象基类(abstract base classes)。

抽象基类的最大不同是它不能够有实例(对象)，但我们可以定义指向它的指针。

因此，像这样的声明：

CPolygon poly;是不合法的。

然而，指针：

CPolygon * ppoly1;
CPolygon * ppoly2

是完全合法的

父类指针可以指向子类对象，在父类中this指针可以使用父类的所有方法而不需要管是哪个子类。