c++多态性起作用的地方和delete析构总结

#include<iostream>
using namespace std;
/***************多态起作用的地方****
1）通过指针调用虚函数
2）通过引用调用虚函数
3）通过非静态成员函数，调用虚函数，下面用例就是为了验证这个，在成员函数中有一个this指针。
****************/
class A{
public:
	A(int a):a(a)
	{
		cout << "constructor A:" << a << endl;
		test1();
		test2();
	}
	void test1()
	{
		cout << "Class A:" << a << endl;
	}
	virtual void test2()
	{
		cout << "Class A virtual:" << a << endl;
	}
	void test3()
	{
		cout << "Class A test3" << endl;
		test2();
	}
protected :
	int a;
};
class B:public A{
public:
	B(int a):A(a)
	{
		cout << "constructor B:" << a << endl;
		test1();
		test2();
	}
	void test1()//隐藏
	{
		cout << "Class B:" << a << endl;
	}
	virtual void test2()//覆盖override
	{
		cout << "Class B virtual:" << a << endl;
	}
	//void test3()
	//{
		//cout << "Class B test3" << endl;
		//test2();
	//}
};
int main(int argc,char **argv)
{
	cout << "---------0--------" << endl;
	A a(10);
	cout << "---------1--------" << endl;
	B b(20);
	cout << "---------2--------" << endl;
	a.test3();
	b.test3();
	return 0;
}

   输出结果：

--------0--------
constructor A:10
Class A:10
Class A virtual:10
---------1--------
constructor A:20
Class A:20
Class A virtual:20
constructor B:20
Class B:20
Class B virtual:20
---------2--------
Class A test3
Class A virtual:10
Class A test3
Class B virtual:20

    总结：只有指针或者引用访问虚函数才会产生多态，而且我们调用delete时，也会调用this指针指向的析构函数，比如如下代码：

class Point{
public:
    Point(){
    }
    ~Point(){
        std::cout << "executing Point destructor" << std::endl;
    }
};
class Circle:public Point{
    Circle(){
    }
    ~Circle(){
        std::cout << "executing Circle destructor" << std::endl;
    }
};
int main(void)
{
    Point *p = new Circle();
    delete p;
    return 0;
}
输出：
executing Point destructor，只调用基类的析构函数，也就是this指针的类型是Point*，
没有发生多态，this就是静态类型。

 如果析构函数改为虚函数，则输出：

executing Circle destructor
executing Point destructor

       可以认为是一个基类对象的类型调用虚函数（析构函数）发生了多态，静态类型和动态类型不一致了，最终先调用派生类的析构函数。

        下面有个更有意思的代码，虽然析构函数不是虚函数，但由于destroy函数是虚函数，发生了多态，在运行时依据动态类型调用，所以此时的this是指向派生类，但具体代码如下：

class Point{
public:
    Point(){
    }
    ~Point(){
        std::cout << "executing Point destructor" << std::endl;
    }
    virtual void destory()
    {
        std::cout << "point delete this" << std::endl;
        delete this;//调用对象的析构函数（this->析构函数），然后再释放内存。
    }
};
class Circle:public Point{
    Circle(){
    }
    ~Circle(){
        std::cout << "executing Circle destructor" << std::endl;
    }
    void destory()
    {
        std::cout << "Circle delete this" << std::endl;
        delete this;
    }
};
int main(void)
{
    Point *p = new Circle();
    p->destroy();
    return 0;
}
输出：
Circle delete this
executing Circle destructor
executing Point destructor