【C++基础】笔记3——类与对象1
类与对象
C++面向对象的三大特性：封装，继承，多态
封装
意义：将属性和行为作为一个整体，表现生活中的事务，将属性和行为加以权限控制
语法：class 类名{ 访问权限: 属性/行为 };
const double PI = 3.14; //圆周率
class Circle {
public:
//属性
int m_r; //半径
//行为（用函数）
double calZC() { //计算周长
return 2 * PI * m_r;
}
};
int main()
{
//通过圆类，创建具体的圆（对象）
Circle c1;
//给圆对象的属性进行赋值
c1.m_r = 10;
cout << "圆c1的周长" << c1.calZC() << endl;
}
实例化：通过一个类创建一个对象的过程
class Student {
public:
//类中的属性和行为，统称为成员
//属性 = 成员属性 = 成员变量 行为 = 成员函数 = 成员方法
string m_Name;
int m_ID;
void setName(string name) { //给姓名赋值
m_Name = name;
}
void setID(int ID) {
m_ID = ID;
}
void showStudent() { //打印学生信息
cout << "姓名：" << m_Name << " 学号：" << m_ID << endl;
}
};
int main()
{
Student s1;
s1.setName("费沁源");
s1.setID(1);
s1.showStudent();
}
访问权限：
1.公共权限 public
成员在类内可以访问，类外也可以访问
待补充（继承）
2.保护权限 protected
成员在类内可以访问，类外不可以访问
子类可以访问父类的保护内容
3.私有权限 private
成员在类内可以访问，类外不可以访问
子类不可以访问父类的私有内容
struct和class的区别
struct默认权限为共有； class默认权限为私有
（struct也可以包含成员函数，可以继承，可以实现多态）
class可用于定义模板参数，struct不可以
将成员属性设置为私有
优点：
1.可以自己控制读写权限
2.可以检测数据的有效性
class Person {
private:
string m_Name; //姓名 可读可写
char m_Sex; //性别 可读
int m_Age; //年龄 可读可写（对写入进行限制）
string m_Lover; //伴侣 可写
public:
void setName(string name) { //设置姓名
m_Name = name;
}
string getName() { //获取姓名
return m_Name;
}
int getAge() { //获取年龄
m_Age = -1; //初始化为-1
return m_Age;
}
void setAge(int age) { //设置年龄，可检验数值的有效性
if (age < 0 || age > 150) {
cout << "数据无效" << endl;
return;
}
m_Age = age;
}
void setLover(string lover) { //设置伴侣
m_Lover = lover;
}
};
对象的初始化和清理
C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置
C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。
- 构造函数:主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
- 析构函数:主要作用在于对象销毁前系统自动调用，执行一些清理工作
构造函数
语法：类名(){ }
1.构造函数没有返回值，也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次
析构函数
语法：~类名(){ }
1.构造函数没有返回值，也不写void
2.函数名称与类名相同,在名称前加上~
3.构造函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次
构造函数的分类及调用
两种分类方式：
按参数分：有参构造 和 无参构造（默认构造）
按类型分：普通构造 和 拷贝构造
//有参构造
Person() {
cout << "Person 无参构造函数调用" << endl;
}
//无参构造（默认构造）
Person(int a) {
age = a;
cout << "Person 有参构造函数调用" << endl;
}
//拷贝构造函数
Person(const Person &p) { //复制一个一模一样的，不能改变本体，所以使用const
age = p.age;
cout << "Person 拷贝构造函数调用" << endl;
}
三种调用方式：
括号法 显示法 隐式转换法
//括号法
//调用默认构造函数时不要加“（）“
//编译器会将 Person p1(); 当作函数声明，不会认为在创建对象
Person p1; //默认构造函数调用
Person p2(10); //有参构造函数调用
Person p3(p2); //拷贝构造函数调用
//显示法
Person p1; //默认构造函数调用
Person p2 = Person(10); //有参构造函数调用
Person p3 = Person(p2); //拷贝构造函数调用
Person(10); //匿名对象，47行代码中，p2为它的名字
//特点：当前行执行结束后，系统会立即回收匿名对象
//不要利用拷贝构造函数初始化匿名对象
Person(p3); //错误
//编译器会认为Person(p3) == Person p3;看作一个对象的声明，
//隐式转换法
Person p4 = 10; //相当于写了 Person p4 = Person(10); 有参构造
Person p5 = p4; //拷贝构造
拷贝构造函数调用时机
1.使用一个已经创建完毕的对象来初始化一个新对象
void test1()
{
Person p1(20);
Person p2(p1);
cout << "p2的年龄" << endl;
}
2.值传递的方式给函数参数传值
void func(Person p) //值传递的本质：会拷贝出一个临时的副本
{ //等于Person p = p; 拷贝构造函数的隐式写法
}
void test2()
{
Person p;
func(p);
}
3.值方式返回局部对象
Person func2()
{
Person p3;
cout << (int*)&p3 << endl;
return p3;
}
void test3()
{
Person p = func2();
cout << (int*)&p << endl;
}
构造函数调用规则
默认情况下，C++编译器至少给一个类添加3个函数
- 1.默认构造函数（无参，函数体为空）
- 2.默认析构函数（无参，函数体为空）
- 3.默认拷贝构造函数，对属性进行值拷贝
- 4.赋值运算符operator=，对属性进行值拷贝
构造函数调用规则：
- 如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数，C++不会再提供其他构造函数
深拷贝与浅拷贝
- 浅拷贝：简单的赋值拷贝操作
- 深拷贝：在堆区重新申请空间，进行拷贝操作
class Person {
public:
Person() {
cout << "Person 默认构造函数调用" << endl;
}
Person(int age, int height) {
m_Age = age;
m_Height = new int(height); //用指针接收堆区的数据
cout << "Person 有参构造函数调用" << endl;
}
~Person() {
//析构函数的作用：将堆区开辟的数据做释放操作
if (m_Height != NULL) {
delete m_Height;
m_Height = NULL; //防止野指针，进行置空
}
cout << "Person 析构函数的调用" << endl;
}
int m_Age;
int *m_Height; //身高
};
void test1()
{
Person p1(18, 160);
cout << "p1的年龄为：" << p1.m_Age << "p1的身高为：" << *p1.m_Height << endl;
Person p2(p1);
cout << "p2的年龄为：" << p1.m_Age << "p2的身高为：" << *p1.m_Height << endl;
}
浅拷贝带来的问题：堆区内存的重复释放
浅拷贝是逐个字节完全复制，所以p2.m_Height的地址和p1.m_Height一样，当p2被释放时，执行析构函数，对p2.m_Height进行释放，当p1被释放时，执行析构函数，会对0x0011再次进行释放，从而导致错误
深拷贝：
//自己写拷贝构造函数 解决浅拷贝带来的问题
Person(const Person &p) {
cout << "Person拷贝函数的调用" << endl;
m_Age = p.m_Age;
//深拷贝操作
m_Height = new int(*p.m_Height);
}
初始化列表
C++提供了初始化列表语法，用来初始化属性
语法：构造函数 () : 属性1(值1)属性2(值2)…{}
Person(int age, int score) :m_Age(age), m_Score(score) {
}
类对象作为类成员
C++中的成员可以是另一个类的对象，称为成员对象
class A{};
class B{
A a;
};
当其它类的成员作为本类成员，构造时先构造类对象，再构造自身；析构的顺序与构造相反
class Phone {
public:
string m_PName;
Phone(string pName) {
m_PName = pName;
cout << "Phone 构造函数调用" << endl;
}
~Phone() {
cout << "Phone 析构函数调用" << endl;
}
};
class Person {
public:
string m_Name;
Phone m_Phone;
Person(string name, string pname) :m_Name(name), m_Phone(pname) {
cout << "Person 构造函数调用" << endl;
}
~Person() {
cout << "Person 析构函数调用" << endl;
}
};
静态成员
静态成员就是在静态成员变量和静态成员函数前加上static关键字
- 静态成员变量
所有对象共享一份数据
在编译阶段分配内存
类内声明，类外初始化 - 静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
静态成员函数也有访问权限(public,private)
static 成员变量属于类，不属于某个具体的对象，即使创建多个对象，也只为 静态成员变量分配一份内存，所有对象使用的都是这份内存中的数据。当某个对象修改了静态成员变量，也会影响到其他对象。
C++对象模型和this指针
成员变量和成员函数分开存储
在C++中，类内的成员变量和成员函数是分开存储的
只有非静态成员变量才属于类的对象上
p占1个字节
空对象占用内存空间为1
C++编译器会给每个空对象分配1字节的空间，为了区分空对象占内存的位置
每个空对象也应该有一个独一无二的内存地址
class Person {
};
void test()
{
Person p;
cout << "size of p = " << sizeof(p) << endl;
}
p占4个字节
class Person {
int m_A; //非静态成员变量，属于类的对象上
static int m_B; //静态成员变量（类内声明，类外初始化），不属于类的对象上
void func() { //非静态成员函数，不属于类的对象上
}
static void func1() { //静态成员函数，不属于类的对象上
}
};
void test()
{
Person p;
cout << "size of p = " << sizeof(p) << endl;
}
this指针
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
问题：这块代码如何区分哪个对象在调用自己
C++提供特殊的对象指针this，解决上述问题
this指针指向被调用的成员函数所属的对象（谁调用this，this指向谁）
this指针是隐含每一个非静态成员函数内的一种指针（不需要传数据）
this指针不需要定义，直接使用即可
this指针的用途:
当形参和成员变量同名时，可用this指针来区分
在类的非静态成员函数中返回对象本身，可使用return *this
解决名称冲突
此时p1的年龄18不能够成功输出
class Person {
public:
int age;
Person(int age) { //编译器会认为三个age是同一个age，与成员属性age无关
age = age;
}
};
//解决名称冲突
void test0()
{
Person p1(18);
cout << "p1的年龄为：" << p1.age << endl;
}
利用this解决名称冲突问题
此时this指向的age与成员属性age一致
p1的年龄18可以正常输出
class Person {
public:
int age;
Person(int age) {
this->age = age;
}
};
返回对象本身用*this
class Person {
public:
int age;
Person(int age) { //编译器会认为9-10行中的三个age是同一个age，与7行的成员属性age无关
this->age = age;
}
Person& PersonAddAge(Person &p) { //用引用返回
this->age += p.age;
//this指向p3的指针，而*this指向的就是p2这个对象本体
return *this;
}
};
//返回对象本身用*this
void test1()
{
Person p2(10);
Person p3(10);
//链式编程思想
p3.PersonAddAge(p2).PersonAddAge(p2).PersonAddAge(p2);
cout << "p3 age = " << p3.age << endl;
}
空指针访问成员函数
C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性
class Person {
public:
void showClassName() {
cout << "this is Person class" << endl;
}
void showPersonAge() {
cout << "age = " << m_Age << endl;
}
int m_Age;
};
void test0()
{
Person *p = NULL;
p->showClassName(); //可以正常调用
p->showPersonAge(); //不可以正常调用
}
其中，showPersonAge函数实际上加上了this指针
void showPersonAge() {
cout << "age = " << this->m_Age << endl;
}
报错的原因是传入的为NULL指针，只要加入判断就可以避免
void showPersonAge() {
if (this->m_Age == NULL) {
return;
}
cout << "age = " << m_Age << endl;
}
const修饰成员函数
常函数
成员函数后加const关键字
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改
class Person {
public:
int m_A;
mutable int m_B; //特殊变量，即使在常函数中，也可以修改
//this指针的本质是指针常量，指针的指向不可以修改
//const Person * const this
//在成员函数后面加上const，修饰的是this指向，让指针指向的值也不可以修改
void func() const {
m_A = 100; //错误 等同于 this->m_A = 100;
m_B = 100; //正确 等同于 this->m_B = 100;
}
void func2() {
m_A = 10;
m_B = 10;
}
};
常对象
声明对象前加const称为常对象
常对象只能调用常函数
void test0()
{
const Person p; //在对象前加const，变为常对象
p.m_A = 100; //错误
p.m_B = 100; //正确
//常对象只能调用常函数
//常对象不可以调用普通成员函数，因为普通成员函数可以修改属性
p.func(); //错误
p.func2(); //正确
}
友元
在程序里，有些私有属性，想让类外的一些函数或者类进行访问，需要用到友元技术（客厅public卧室private和好朋友friend）
友元的目的就是让一个函数或者类，访问另一个类中的私有成员
友元的关键字：friend
友元的三种实现：
1.全局函数做友元
class Building {
//goodFriend全局函数是building类的友元，可以访问Building中私有成员
//只要写在类的最上面就行
friend void goodFriend(Building *building);
public:
string m_Livingroom; //客厅
private:
string m_Bedroom; //卧室
public:
Building() {
m_Livingroom = "客厅";
m_Bedroom = "卧室";
}
};
//全局函数
void goodFriend(Building *building)
{
cout << "好朋友全局函数，正在访问：" << building->m_Livingroom << endl;
cout << "好朋友全局函数，正在访问：" << building->m_Bedroom << endl;
}
void test0()
{
Building b;
goodFriend(&b);
}
2.类做友元
class Building; //类声明
class GoodFriend {
public:
Building *building;
GoodFriend();
void visit(); //参观函数，访问Building中的属性
};
class Building {
friend class GoodFriend;
public:
string m_Livingroom; //客厅
private:
string m_Bedroom; //卧室
public:
Building();
};
//类外写成员函数
Building::Building()
{
m_Livingroom = "客厅";
m_Bedroom = "卧室";
}
GoodFriend::GoodFriend()
{
//创建建筑物对象
building = new Building;
}
void GoodFriend::visit()
{
cout << "好朋友全局函数，正在访问：" << building->m_Livingroom << endl;
cout << "好朋友全局函数，正在访问：" << building->m_Bedroom << endl;
}
void test0()
{
GoodFriend gf;
gf.visit();
}
3.成员函数做友元
class Building;
class GoodFriend {
public:
GoodFriend();
void visit(); //让visit函数可以访问Building中私有成员
void visit2(); //visit2函数不可以
Building *building;
};
class Building {
//GoodFriend类下的visit函数作为本类的好朋友，可以访问私有的成员
friend void GoodFriend::visit();
public:
string m_Livingroom; //客厅
private:
string m_Bedroom; //卧室
public:
Building();
};
GoodFriend::GoodFriend()
{
building = new Building;
}
void GoodFriend::visit()
{
cout << "visit函数正在访问：" << building->m_Livingroom << endl;
cout << "visit函数正在访问：" << building->m_Bedroom << endl;
}
void GoodFriend::visit2()
{
cout << "visit函数正在访问：" << building->m_Livingroom << endl;
}
Building::Building()
{
m_Livingroom = "客厅";
m_Bedroom = "卧室";
}
void test0()
{
GoodFriend g;
g.visit();
g.visit2();
}
运算符重载
对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
加号运算符重载 +
作用：实现两个自定义数据类型相加的运算
成员函数重载
class Person {
public:
int m_A;
int m_B;
//成员函数重载+号
//本质：Person p3 = p1.operator+(p2);
Person operator+ (Person &p) {
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
};
全局函数重载
//全局函数重载+号
//本质：Person p3 = operator+(p1, p2);
Person operator+ (Person &p1, Person &p2)
{
Person temp;
temp.m_A = p1.m_A + p2.m_A;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
//运算符重载也可以函数重载
Person operator+ (Person &p1, int i)
{
Person temp;
temp.m_A = p1.m_A + i;
temp.m_B = p1.m_B + i;
return temp;
}
注意：
1.对于内置的数据类型的表达式的运算符是不可能改变的
2.不要滥用运算符重载
左移运算符重载 <<
作用：可以输出自定义的数据类型
同常不会用成员函数重载左移运算符，因为cout在左侧
//operator<<(cout) 简化版本：p << cout;
void operator<< (cout){}
只能利用全局函数左移运算符
void operator<<(ostream &cout, Person &p) //本质:operator<<(cout, p) 简化为cout << p;
{ //ostream 输出流,cout只能有一个,所以用引用的方式
cout << "m_A = " << p.m_A << "m_B = " << p.m_B;
}
void test0()
{
Person p;
cout << p;
}
如果使用上述方法进行左移运算符重载，不能进行“追加”
cout << p; //正确
cout << p << endl; //错误
这种“追加”的思想是链式编程的思想，返回值应该和cout一致
ostream & operator<<(ostream &cout, Person &p) //本质:operator<<(cout, p) 简化为cout << p;
{ //ostream 输出流,cout只能有一个,所以用引用的方式
cout << "m_A = " << p.m_A << "m_B = " << p.m_B;
return cout;
}
递增运算符重载++
不能用编译器提供的赋值（类似于浅拷贝）原因：与深浅拷贝相同，堆区内存的重复释放，导致程序崩溃
class Person {
public:
int *m_Age;
Person(int age) {
m_Age = new int(age);
}
~Person(){
if (m_Age != NULL) {
delete m_Age;
m_Age = NULL;
}
}
//重载赋值运算符
Person& operator=(Person &p) {
//应先判断是否有属性在堆区，如果有，先释放干净，然后再深拷贝
if (m_Age != NULL) {
delete m_Age;
m_Age = NULL;
}
//深拷贝
m_Age = new int(*p.m_Age);
return *this;
}
};
void test0()
{
Person p1(18);
Person p2(20);
Person p3(22);
p3 = p2 = p1;
cout << "p1的年龄为" << *p1.m_Age << endl;
cout << "p2的年龄为" << *p2.m_Age << endl;
cout << "p3的年龄为" << *p3.m_Age << endl;
}
关系运算符重载== !=
作用：重载关系运算符，可以让两个自定义类型对象进行对比操作
class Person {
public:
string m_Name;
int m_Age;
Person(string name, int age) {
m_Name = name;
m_Age = age;
}
bool operator==(Person &p) {
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) {
return true;
}
return false;
}
bool operator!=(Person &p) {
if (this->m_Name != p.m_Name && this->m_Age != p.m_Age) {
return true;
}
return false;
}
};
函数调用运算符重载()
由于重载后使用的方式和函数的调用非常相似，因此称为仿函数
仿函数没有固定写法，非常灵活
class MyPrint {
public:
//重载函数调用运算符
void operator()(string test) {
cout << test << endl;
}
};
void test0()
{
MyPrint mp;
mp("HelloWorld");
}
class MyAdd {
public:
int operator()(int num1, int num2) {
return num1 + num2;
}
};
void test1()
{
MyAdd ma;
int ret = ma(100, 20);
cout << ret << endl;
//匿名对象
cout << MyAdd()(100, 20) << endl;
}