第八章--多态

红：一级标题  粉：二级标题  蓝：关键点

1.运算符重载

两个对象(某些数值)相加

例子：

complex complex::operator + (complex c2)

{

return complex(real +c2.real ,image+c2.image)

}

对象:c3= c1+c2  

complex::operator=c1

+=+

(complex c2)=c2

调用上面的方法real、image是c1的，参数complex c2是c2的

用处：

复数相加、对象相加等。

2.声明对象

complex c() //无new的对象只能在方法执行是存在

complex c(1, 2) //直接调用complex的此构造函数。

complex c //对象c调用默认的构造函数

3.this

类里的this是指针 *this是对象

4.友元函数和友元类

参考：http://www.cppblog.com/twzheng/articles/21020.html

book: p137

例子：.h文件

friend float fDist(Point &a, Point &b) 

.cpp

float fDist(Point &a, Point &b)

{

a.xxx; b.xxx

//如果fDist(Point a, Point b)调用时把对象拷贝给a、b。&是a、b指向的地址和()fDist(c, d)c、d一样

}

用处

1.不属于任何类

2.编码规范数据成员private、成员函数public

3.要访问类的private成员，用友元函数

友元类

一个类可以访问另一个类的private成员时，声明为友元类

使用友元类时注意：
(1) 友元关系不能被继承。 
(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明 

5.多态一

对：

void fun(parent *p){}

fun(child *c)

错：

void fun(child *p){}

fun(parent *c)

原因：

父类的引用指向子类成元，如果某个方法只有children有p将无法调用。

6.虚函数

BO：

void display(){std::cout <<"BO, World!\n";};

输出：

BO, World!

BO, World!

BO, World!

virtual void display(){std::cout <<"BO, World!\n";};

输出：

BO, World!

B1, World!

D1, World!

virtual:动态指定

7.虚析构函数

没有虚构造函数

~Base(){cout <<"Base World!\n";}

输出

Base World!

virtual ~Base(){cout <<"Base World!\n";}

Derived World!

Base World!

关键代码

Base *b = newDerived();

void fun(Base *ptr)   //ptr指向的不是virtual方法都调用Base里的方法

8.纯虚函数

1.声明 virtual void fun()=0; 不用给实现

2.有纯虚函数的类是抽象类(不能实例化一般作为其他类的父类)

3.抽像类声明指针或引用

6.代码

#include <iostream>
using namespace std;

class BO
{
public:
    void display(){std::cout << "BO, World!\n";};
};
class B1 : public BO
{
public:
    void display(){std::cout << "B1, World!\n";};
    void displayB1(){std::cout << "displayB1, World!\n";};
};
class D1 : public B1
{
public:
    void display(){std::cout << "D1, World!\n";};
};

void fun(BO *ptr)
{
    ptr->display();  //方法必须是BO类有的
    //调用ptr->displayB1(); 出错
}

int main(int argc, const char * argv[])
{
    BO bo, *p;
    B1 b1;
    D1 d1;
    
    p = &bo;
    fun(p);
    p = &b1;
    fun(p);
    p = &d1;
    fun(p);
    
    return 0;
}

7.代码

#include <iostream>
using namespace std;

class Base
{
public:
    //~Base(){cout << "Base World!\n";}
    virtual ~Base(){cout << "Base World!\n";}
};
class Derived : public Base
{
public:
    Derived();
    ~Derived();
};

Derived::Derived(){}
Derived::~Derived()
{
    cout << "Derived World!\n";
}

void fun(Base *ptr)
{
    delete ptr;
}

int main(int argc, const char * argv[])
{
    Base *b = new Derived();
    fun(b);
    
    return 0;
}