C++复习

1. 友元函数
   1.     将一个非类的成员函数申明为类的友元函数，则该函数可以访问类的私有成员。
   2.     函数可以同时是一个类的成员函数和另一个类的友元函数。

      class myclass_1;
      class myclass_2;
      
      class myclass_1
      {
      public:
          myclass_1(int x):status_1(x) {};
          ~myclass_1() {};
          friend void classfriend(myclass_1 &c1, myclass_2 & c2);
      private:
          int status_1;
      };
      
      class myclass_2
      {
      public:
          myclass_2(int x):status_2(x) {};
          ~myclass_2() {};
          friend void classfriend(myclass_1 &c1, myclass_2 & c2);
      private:
          int status_2;
      };
      
      void classfriend(myclass_1 &c1, myclass_2 & c2)
      {
          printf("%d, %d\n", c1.status_1, c2.status_2);
      }
      

2. 复制构造函数

class myclass_1
{
public:
    myclass_1() {printf("构造函数\n");};
    ~myclass_1() {printf("析构函数\n");};
    myclass_1(const myclass_1 & mc) {printf("复制构造函数\n");};
    void print() {};
private:
    int status_1;
};

void func(myclass_1 c1)
{
    c1.print();
    return ;
}

      3. 操作符重载

class myclass_1
{
public:
    myclass_1() {printf("构造函数\n"); status_1 = 10; status_2 = 20;};
    ~myclass_1() {printf("析构函数\n");};
    myclass_1(const myclass_1 & mc) {printf("复制构造函数\n");};
    
    myclass_1 operator++(); 

    void print();
private:
    int status_1;
    int status_2;
};

myclass_1 myclass_1::operator++()
{

    this->status_1++;
    this->status_2++;
    
    return *this;
}

void myclass_1::print()
{

    printf("%d,%d\n", status_1, status_2);
    return ;
}

int main(int argc, char* argv[])
{

    myclass_1 cl;

    cl++;
    cl.print();

	return 0;
}

1. 继承
   1. 继承后成员的属性变化
   2. 虚继承
   3. 如果基类以虚方式被继承，那么在派生类中只有基类的一个副本，否则，将会有多个副本存在。

class base

{

public:

    int i;

};

class derived1: virtual public base
{
public:
    int j;
};

class derived2: virtual public base
{
public:
    int k;
};

class derived3: public derived1, public derived2
{
public:
    int sum;
};

5. 虚函数

  5.1 重新定义的虚函数在参数的类型和数量上必须相同。

  5.2 在定义虚函数的类中，虚函数必须声明为类的成员而不能是友员，但虚函数可以被声明为其它类的友员。

  5.3 析构函数可以是虚函数，但是构造函数则不可以。

class base
{
public:
    virtual void who(){printf("base\n");}
    int i;
};

class first_d: public base
{
public:
    void who(){printf("first\n");}
};

class second_d: public base
{
public:
    void who(){printf("second\n");}
};



int main(int argc, char* argv[])
{
    base *p;

    base base_obj;
    p = &base_obj;
    p->who();

    first_d first_obj;
    p = &first_obj;
    p->who();

    second_d second_obj;
    p = &second_obj;
    p->who();

	return 0;
}

6. 纯虚函数

    纯虚函数是指在基类中声明但是没有定义的虚函数。这将使得所有派生类中都必须有自己的虚函数的定义，不能使用在基类中定义的虚函数。

class base
{
public:
    virtual void who()=0;
    int i;
};

class first_d: public base
{
public:
    void who(){printf("first\n");}
};

class second_d: public base
{
public:
    void who(){printf("second\n");}
};

int main(int argc, char* argv[])
{
    base *p;

    first_d first_obj;
    p = &first_obj;
    p->who();

    second_d second_obj;
    p = &second_obj;
    p->who();

	return 0;
}