如何从零开始学习C语言中的类与对象？
- 内容介绍
- 文章标签
- 相关推荐
本文共计3457个文字，预计阅读时间需要14分钟。
1. 面向过程与面向对象初步认识：面向过程关注算法和步骤，面向对象关注对象和交互。面向过程增加关注问题解决的过程和步骤，而面向对象关注对象的划分和事件交互。例如：外卖系统+面向过程。
1.面向过程和面向对象初步认识
面向过程更加关注解决问题的过程和步骤。
而面向对象关注的是对象，对一个事情拆分成不同的对象，靠对象之间的交互实现。
例如：外卖系统
面向过程：
上架→点餐→派单→送餐
注重过程步骤
面向对象： （更加贴近现实之间的业务逻辑交互）
骑手→商家←用户
注重对象和对象之间的交互
对面向对象编程方式的看法:
面向对象是面向过程更高阶的开发方式，是语言进化方向。在工程里面更加的使用广泛。
2.类的引入
struct 在c语言里面定义结构体，但是在c++里面升级成了类，在c++中如下定义都是合理的
struct Stack
{
//成员变量
int* a;
int top;
int capacity;
}
int main()
{
struct Stack st1;
Stack st2;
}
类里面定义的变量是成员变量，定义实现的函数是成员函数
下面简单实现一个类
#include<iostream>
struct Stack
{
//成员函数
void Init(int defaultCapacity =4)
{
(int*)a=(int*)malloc(sizeof(int)*capacity);
if(a==nullptr)
{
perror("malloc 申请空间失败");
return;
}
capacity=defaultCapacity;
top=0;
}
void Push(int x)
{
if(top==capacity)
{
//扩容
}
a[top++]=x;
}
void Destroy()
{
free(a);
a=nullptr;
top=capacity=0;
}
//成员变量
int* a;
int top;
int capacity;
}
int main()
{
struct Stack st1;
st1.Init(20);
Stack st2;
st2.Init();
st2.Push(1);
st2.Push(2);
st2.Push(3);
st2.Push(4);
st2.Destroy();
return 0;
}
上面结构体的定义，在c++中更喜欢用class来定义类。
3.类的定义
关键字：class
class Student
{
... //成员变量 成员方法
}; //一定要注意class和struct 定义的时候一样花括号后面要加分号
class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
类的两种定义方式：
- 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
- 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::
如图：
4.类的访问限定符及封装
4.1访问限定符说明：
- 1.pubic修饰的成员在类外可以直接被访问使用。
- 2.protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）
- 3.访问权限作用域从该访问限定符出现的位置开始直接到下一个访问限定符出现时为止
- 4.如果后面没有限定访问符，那么作用域就找}即类结束
- 5.class的默认访问权限为private，struct为public（因为struct要兼容c）
注意：访问限定符只能编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
class Student
{
public:
int Getage()
{
return _age;
}
string Getname()
{
return _name;
}
int Gethight()
{
return _hight;
}
string Getsex()
{
return _sex;
}
private:
//成员变量
int _age;
string _name;
int _hight;
string _sex;
};
C++中struct和class的区别是什么？
解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来
定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类
默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别
4.2封装
面向对象的三大特性：封装、继承、多态。
4.2.1什么是封装？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质是一种管理，对类进行管理，把类的变量、函数进行管理。让用户更加方便使用类。
理解：可以理解成我在用的电脑，电脑就是被封装好的类，电脑里面的cpu，精密仪器，就是被类管理好的变量、函数。
总结：
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来
隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。
5.类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::
作用域操作符指明成员属于哪个类域。
class Person
{
public:
char _name[20];
char _gender[3];
int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
cout << _name << " "<< _gender << " " << _age << endl;
}
作用域使用范围：我们可以在类外，通过 :: 指定访问类公共域内的变量和函数，不能访问private私有域内的变量和函数。
6.类的实例化
类类型创建对象过程，称为类的实例化。
理解：
1.类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没
有分配实际的内存空间来存储它；
2.一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
3.类可以理解为一个模型或者一个造房子的图纸。而对象是通过模型算出的数据或者通过图纸造出的房间、窗户等。实例化的东西。
代码实现实例化
7.类的对象大小的计算
7.1 如何计算类对象的大小
class A
{
public:
void PrintA()
{
cout<<_a<<endl;
}
private:
char _a;
};
问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算
一个类的大小？
类的对象包括里面可以访问的成员函数或者成员变量，和不可以访问的成员变量或者成员函数。
计算类的大小，需要用到内存对齐的知识，我们在计算的时候是跳过类里面的函数，不进行计算，只计算成员变量内存对齐之后的大小。
7.2计算实例
// 类中既有成员变量，又有成员函数
class A1 {
public:
void f1(){}
private:
int _a;
};
// 类中仅有成员函数
class A2 {
public:
void f2() {}
};
// 类中什么都没有---空类
class A3
{};
计算出 sizeof(A1):_____ (1) sizeof(A2)______(1) sizeof(A3)_________(1)
(空类或者类无成员变量的内存为1)
结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。
7.3 结构体内存对齐规则
- 第一个成员在与结构体偏移量为0的地址处。
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
- 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
- VS中默认的对齐数为8
- 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
- 5.当设置的内存对齐大小过小，那么类在机器上读取数据次数增加，时间增多，效率降低，但是空间利用率高。
- 6.当设置的内存对齐大小过大，那么类在机器上读取数据次数少，同样的读取速度快，效率高，但是空间出现浪费的问题。
- 7.那么我们如何设置这个内存对齐数，取决于机器读取的对齐数大小，选取合适的大小进行读取类的数据。
8.类成员函数的this指针
8.1 this指针的引出
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
Date d1, d2;
d1.Init(2022,1,11);
d2.Init(2022, 1, 12);
d1.Print();
d2.Print();
return 0;
}
- c++中是如何知道我调用d1.Print()和d2.Print(),分别打印出不同的内容呢？
我们通过查看反汇编看的出，调用的函数call命令地址是一样的，说明调用的函数是同一个函数，然后那么推断出是参数传递不同，那么在C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
8.2this指针的特性
this指针的类型：类类型 *const,那么this指针不能被成员函数赋值。
使用范围： 只在成员函数内部使用。
this指针存储的位置： this指针本质上是“成员函数”的形参，当d1.Print()调用成员函数的时候，对象的地址传给了成员函数的this形参，所以对象中不存储this指针，this指针是存放在栈里面，被编译器通过ecx寄存器自动进行传递。
对比：
这是我们写的，如下
void Print()
{
cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
这个编译帮我们传递的形参，真实的调用
void Print(Date* this)
{
cout <<this->_year<< "-" <<this->_month << "-"<< this->_day <<endl;
}
this指针可以为空？
#include<iostream>
#include<string>
using namespace std;
class person
{
public:
person()
{}
person(string a = "", int b = 12)
{
name = a;
age = b;
}
void test()
{
cout << "这是test" << endl;
}
void change()
{
cout << "这是change" << endl;
cout << name << endl;
}
~person()
{}
private:
string name;
int age;
};
//
void test()
{
person A("张三", 13);
person B("李四", 15);
person* p = NULL;
A.test();
A.change();
p->test();
p->change();
}
int main()
{
test();
}
- 当把空的this传入 test(NULL)时： 然后 test没有调用任何函数，所以执行函数。
- 当把空的this传入 change(NULL)时： 然后 change通过this指针调用this->name,而this是空的，所以出错了。
8.3 c++中stack的实现
typedef int DataType;
class Stack
{
public:
void Init()
{
_array = (DataType*)malloc(sizeof(DataType) * 3);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = 3;
_size = 0;
}
void Push(DataType data)
{
CheckCapacity();
_array[_size] = data;
_size++;
}
void Pop()
{
if (Empty())
return;
_size--;
}
DataType Top(){ return _array[_size - 1];}
int Empty() { return 0 == _size;}
int Size(){ return _size;}
void Destroy()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
void CheckCapacity()
{
if (_size == _capacity)
{
int newcapacity = _capacity * 2;
DataType* temp = (DataType*)realloc(_array, newcapacity *
sizeof(DataType));
if (temp == NULL)
{
perror("realloc申请空间失败!!!");
return;
}
_array = temp;
_capacity = newcapacity;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Pop();
s.Pop();
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Destroy();
return 0;
}
C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用。C++中把参数传递交给了编译器，不用程序员来维护，而c语言实现一个stack，在主函数里面调用函数需要自己主动维护参数的传递。
8.4 this指针的使用注意
#include<iostream>
using namespace std;
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
private:
int _a;
};
class B
{
public:
void Print()
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A* a=nullptr;
a->Print();
B* b=nullptr;
b->Print();
return 0;
}
运行发现，只有A这个类的Print函数被调用实现了，B这个类的函数出现了访问权限不够，非法访问。
原因解析：
b这个对象指针被赋成了nullptr那么在调用Print这个函数的时候隐式传递了*this这个指针，这个指针就是nullptr，那么函数里面传参进来 函数变成如下：
void Print(const A* this)
{
cout<<this->_a<<endl;
}
一个为nullptr的指针肯定访问不了类里面的私有成员，所以出现了非法访问，程序奔溃。
本文共计3457个文字，预计阅读时间需要14分钟。
1. 面向过程与面向对象初步认识：面向过程关注算法和步骤，面向对象关注对象和交互。面向过程增加关注问题解决的过程和步骤，而面向对象关注对象的划分和事件交互。例如：外卖系统+面向过程。
1.面向过程和面向对象初步认识
面向过程更加关注解决问题的过程和步骤。
而面向对象关注的是对象，对一个事情拆分成不同的对象，靠对象之间的交互实现。
例如：外卖系统
面向过程：
上架→点餐→派单→送餐
注重过程步骤
面向对象： （更加贴近现实之间的业务逻辑交互）
骑手→商家←用户
注重对象和对象之间的交互
对面向对象编程方式的看法:
面向对象是面向过程更高阶的开发方式，是语言进化方向。在工程里面更加的使用广泛。
2.类的引入
struct 在c语言里面定义结构体，但是在c++里面升级成了类，在c++中如下定义都是合理的
struct Stack
{
//成员变量
int* a;
int top;
int capacity;
}
int main()
{
struct Stack st1;
Stack st2;
}
类里面定义的变量是成员变量，定义实现的函数是成员函数
下面简单实现一个类
#include<iostream>
struct Stack
{
//成员函数
void Init(int defaultCapacity =4)
{
(int*)a=(int*)malloc(sizeof(int)*capacity);
if(a==nullptr)
{
perror("malloc 申请空间失败");
return;
}
capacity=defaultCapacity;
top=0;
}
void Push(int x)
{
if(top==capacity)
{
//扩容
}
a[top++]=x;
}
void Destroy()
{
free(a);
a=nullptr;
top=capacity=0;
}
//成员变量
int* a;
int top;
int capacity;
}
int main()
{
struct Stack st1;
st1.Init(20);
Stack st2;
st2.Init();
st2.Push(1);
st2.Push(2);
st2.Push(3);
st2.Push(4);
st2.Destroy();
return 0;
}
上面结构体的定义，在c++中更喜欢用class来定义类。
3.类的定义
关键字：class
class Student
{
... //成员变量 成员方法
}; //一定要注意class和struct 定义的时候一样花括号后面要加分号
class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
类的两种定义方式：
- 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
- 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::
如图：
4.类的访问限定符及封装
4.1访问限定符说明：
- 1.pubic修饰的成员在类外可以直接被访问使用。
- 2.protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）
- 3.访问权限作用域从该访问限定符出现的位置开始直接到下一个访问限定符出现时为止
- 4.如果后面没有限定访问符，那么作用域就找}即类结束
- 5.class的默认访问权限为private，struct为public（因为struct要兼容c）
注意：访问限定符只能编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
class Student
{
public:
int Getage()
{
return _age;
}
string Getname()
{
return _name;
}
int Gethight()
{
return _hight;
}
string Getsex()
{
return _sex;
}
private:
//成员变量
int _age;
string _name;
int _hight;
string _sex;
};
C++中struct和class的区别是什么？
解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来
定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类
默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别
4.2封装
面向对象的三大特性：封装、继承、多态。
4.2.1什么是封装？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质是一种管理，对类进行管理，把类的变量、函数进行管理。让用户更加方便使用类。
理解：可以理解成我在用的电脑，电脑就是被封装好的类，电脑里面的cpu，精密仪器，就是被类管理好的变量、函数。
总结：
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来
隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。
5.类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::
作用域操作符指明成员属于哪个类域。
class Person
{
public:
char _name[20];
char _gender[3];
int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
cout << _name << " "<< _gender << " " << _age << endl;
}
作用域使用范围：我们可以在类外，通过 :: 指定访问类公共域内的变量和函数，不能访问private私有域内的变量和函数。
6.类的实例化
类类型创建对象过程，称为类的实例化。
理解：
1.类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没
有分配实际的内存空间来存储它；
2.一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
3.类可以理解为一个模型或者一个造房子的图纸。而对象是通过模型算出的数据或者通过图纸造出的房间、窗户等。实例化的东西。
代码实现实例化
7.类的对象大小的计算
7.1 如何计算类对象的大小
class A
{
public:
void PrintA()
{
cout<<_a<<endl;
}
private:
char _a;
};
问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算
一个类的大小？
类的对象包括里面可以访问的成员函数或者成员变量，和不可以访问的成员变量或者成员函数。
计算类的大小，需要用到内存对齐的知识，我们在计算的时候是跳过类里面的函数，不进行计算，只计算成员变量内存对齐之后的大小。
7.2计算实例
// 类中既有成员变量，又有成员函数
class A1 {
public:
void f1(){}
private:
int _a;
};
// 类中仅有成员函数
class A2 {
public:
void f2() {}
};
// 类中什么都没有---空类
class A3
{};
计算出 sizeof(A1):_____ (1) sizeof(A2)______(1) sizeof(A3)_________(1)
(空类或者类无成员变量的内存为1)
结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。
7.3 结构体内存对齐规则
- 第一个成员在与结构体偏移量为0的地址处。
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
- 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
- VS中默认的对齐数为8
- 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
- 5.当设置的内存对齐大小过小，那么类在机器上读取数据次数增加，时间增多，效率降低，但是空间利用率高。
- 6.当设置的内存对齐大小过大，那么类在机器上读取数据次数少，同样的读取速度快，效率高，但是空间出现浪费的问题。
- 7.那么我们如何设置这个内存对齐数，取决于机器读取的对齐数大小，选取合适的大小进行读取类的数据。
8.类成员函数的this指针
8.1 this指针的引出
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
Date d1, d2;
d1.Init(2022,1,11);
d2.Init(2022, 1, 12);
d1.Print();
d2.Print();
return 0;
}
- c++中是如何知道我调用d1.Print()和d2.Print(),分别打印出不同的内容呢？
我们通过查看反汇编看的出，调用的函数call命令地址是一样的，说明调用的函数是同一个函数，然后那么推断出是参数传递不同，那么在C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
8.2this指针的特性
this指针的类型：类类型 *const,那么this指针不能被成员函数赋值。
使用范围： 只在成员函数内部使用。
this指针存储的位置： this指针本质上是“成员函数”的形参，当d1.Print()调用成员函数的时候，对象的地址传给了成员函数的this形参，所以对象中不存储this指针，this指针是存放在栈里面，被编译器通过ecx寄存器自动进行传递。
对比：
这是我们写的，如下
void Print()
{
cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
这个编译帮我们传递的形参，真实的调用
void Print(Date* this)
{
cout <<this->_year<< "-" <<this->_month << "-"<< this->_day <<endl;
}
this指针可以为空？
#include<iostream>
#include<string>
using namespace std;
class person
{
public:
person()
{}
person(string a = "", int b = 12)
{
name = a;
age = b;
}
void test()
{
cout << "这是test" << endl;
}
void change()
{
cout << "这是change" << endl;
cout << name << endl;
}
~person()
{}
private:
string name;
int age;
};
//
void test()
{
person A("张三", 13);
person B("李四", 15);
person* p = NULL;
A.test();
A.change();
p->test();
p->change();
}
int main()
{
test();
}
- 当把空的this传入 test(NULL)时： 然后 test没有调用任何函数，所以执行函数。
- 当把空的this传入 change(NULL)时： 然后 change通过this指针调用this->name,而this是空的，所以出错了。
8.3 c++中stack的实现
typedef int DataType;
class Stack
{
public:
void Init()
{
_array = (DataType*)malloc(sizeof(DataType) * 3);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = 3;
_size = 0;
}
void Push(DataType data)
{
CheckCapacity();
_array[_size] = data;
_size++;
}
void Pop()
{
if (Empty())
return;
_size--;
}
DataType Top(){ return _array[_size - 1];}
int Empty() { return 0 == _size;}
int Size(){ return _size;}
void Destroy()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
void CheckCapacity()
{
if (_size == _capacity)
{
int newcapacity = _capacity * 2;
DataType* temp = (DataType*)realloc(_array, newcapacity *
sizeof(DataType));
if (temp == NULL)
{
perror("realloc申请空间失败!!!");
return;
}
_array = temp;
_capacity = newcapacity;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Pop();
s.Pop();
printf("%d\n", s.Top());
printf("%d\n", s.Size());
s.Destroy();
return 0;
}
C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用。C++中把参数传递交给了编译器，不用程序员来维护，而c语言实现一个stack，在主函数里面调用函数需要自己主动维护参数的传递。
8.4 this指针的使用注意
#include<iostream>
using namespace std;
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
private:
int _a;
};
class B
{
public:
void Print()
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A* a=nullptr;
a->Print();
B* b=nullptr;
b->Print();
return 0;
}
运行发现，只有A这个类的Print函数被调用实现了，B这个类的函数出现了访问权限不够，非法访问。
原因解析：
b这个对象指针被赋成了nullptr那么在调用Print这个函数的时候隐式传递了*this这个指针，这个指针就是nullptr，那么函数里面传参进来 函数变成如下：
void Print(const A* this)
{
cout<<this->_a<<endl;
}
一个为nullptr的指针肯定访问不了类里面的私有成员，所以出现了非法访问，程序奔溃。