A *a = new B()；详解

A、B类如下：

class A {
public:
	A() { cout << "调用A的构造函数" << endl; }
	virtual void hanshu() { cout << "调用A的虚函数" << endl; }
	void hanshua() { cout << "调用A的成员函数" <<  endl; }
	void hanshu_() { cout << "调用A的成员函数" << endl; }
};
class B: public A 
{
public:
	B() { cout << "调用B的构造函数" << endl; }
	void hanshu()override{ cout << "调用B的虚函数" << endl; }  //重写A的虚函数
	void hanshua() { cout << "调用B的成员函数" << endl; } //重定义A的成员函数
	void hanshub() { cout << "调用B的成员函数" << endl; }
};

A *a = new B();可以分为两步：①A *a;②a = new B();

第一步是对对象a的声明，声明a对象是指向A类的指针，则对象a可以使用类A的非虚函数，虚函数要根据运行时的类型去调用。

第二步是对对象a运行时类型的“绑定”，所以会调用B类的构造函数，且a调用虚函数时会调用B的虚函数。

总结：a可以调用类A中的非虚函数以及类B的虚函数和构造函数，不能调用类B除构造函数外的非虚函数。

其他一些小细节：

#include<iostream>
using namespace std;

class A {
public:
	A() { cout << "调用A的构造函数" << endl; }
	virtual void hanshu() { cout << "调用A的虚函数" << endl; }
	void hanshua() { cout << "调用A的成员函数" <<  endl; }
	void hanshu_() { cout << "调用A的成员函数" << endl; }
};
class B: public A 
{
public:
	B() { cout << "调用B的构造函数" << endl; }
	void hanshu()override{ cout << "调用B的虚函数" << endl; }  //重载A的虚函数
	void hanshua() { cout << "调用B的成员函数" << endl; } //重写A的成员函数
	void hanshub() { cout << "调用B的成员函数" << endl; }
};


int main() {
	A *a = new B();  //会先输出调用A的构造函数，再输出调用B的构造函数。
	cout << "-------------" << endl;
	a->hanshu();
	cout << "-------------" << endl;
	//虽然在B类中重定义了A类的函数，但对象a是A类的，所以调用的是A的函数。
	a->hanshua();   
	cout << "-------------" << endl ;
	//a->hanshub()   //报错，因为A类中没有这个函数。
	cout << endl;
	B b;
	cout << "-------------" << endl;
	//b是B类的，所以调用B类的虚函数.
	b.hanshu();
	cout << "-------------" << endl;
	//对象b是B类的，所以调用重定义后的函数
	b.hanshua();
	cout << "-------------" << endl;
	b.hanshub();
	cout << "-------------" << endl;	
	//调用继承下来的A类函数
	b.hanshu_();
	cout << "-------------" << endl;
	cout << endl;
	A a1;
	cout << "-------------" << endl;
	//a1是A类的，所以调用A类的虚函数
	a1.hanshu(); 


	return 0;
}

参考文章：A a= new B(); - JonthanJ - 博客园 (cnblogs.com)