C++核心编程学习记录
前言
学习视频链接:黑马程序员匠心之作|C++教程
一、内存分区模型
二、引用
三、函数提高
四、类和对象
4.1封装
4.2对象的初始化和清理
4.2.3 拷贝构造函数调用时机
C++中拷贝构造函数调用时机通常有三种情况:
使用一个已经创建完毕的对象来初始化一个新对象;
值传递的方式给函数参数传值;
以值方式返回局部对象;
示例:
#include <iostream>
using namespace std;
class Person
{
public:
//无参(默认)构造函数
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a)
{
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person &p)
{
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person()
{
cout << "析构函数!" << endl;
}
public:
int age;
};
void test01()
{
Person p1(18);
//如果不写拷贝构造,编译器会自动添加拷贝构造,并且做浅拷贝操作
Person p2(p1);
cout << "p2的年龄为: " << p2.age << endl;
}
void test02()
{
//如果用户提供有参构造,编译器不会提供默认构造,会提供拷贝构造
Person p1; //此时如果用户自己没有提供默认构造,会出错
Person p2(10); //用户提供的有参
Person p3(p2); //此时如果用户没有提供拷贝构造,编译器会提供
//如果用户提供拷贝构造,编译器不会提供其他构造函数
Person p4; //此时如果用户自己没有提供默认构造,会出错
Person p5(10); //此时如果用户自己没有提供有参,会出错
Person p6(p5); //用户自己提供拷贝构造
}
int main()
{
// test01();
test02();
system("pause");
return 0;
}
注意:以值传递的方式返回局部对象 此局部等于栈,会自动释放;
4.2.4构造函数调用规则
#include <iostream>
using namespace std;
class Person
{
public:
//无参(默认)构造函数
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int age, int height)
{
cout << "有参构造函数!" << endl;
m_age = age;
m_height = new int(height);
}
//拷贝构造函数
Person(const Person &p)
{
cout << "拷贝构造函数!" << endl;
//如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题
m_age = p.m_age;
// m_height = p.m_height; //编译器默认的拷贝函数
//用深拷贝解决浅拷贝重复释放堆区的问题
m_height = new int(*p.m_height);
}
//析构函数
~Person()
{
cout << "析构函数!" << endl;
if (m_height != NULL)
{
delete m_height;
m_height = NULL;//防止野指针出现
}
}
public:
int m_age;
int *m_height;
};
void test01()
{
Person p1(18, 180);
Person p2(p1);
cout << "p1的年龄: " << p1.m_age << " 身高: " << *p1.m_height << endl;
cout << "p2的年龄: " << p2.m_age << " 身高: " << *p2.m_height << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
4.3C++对象模型和this指针
4.3.1成员变量和成员函数分开储存
在C++中,类内成员变量和成员函数分开存储的,互不干扰,其中类内只有非静态成员变量才属于类对象上;
代码示例:
#include <iostream>
using namespace std;
//成员变量 和 成员函数 分开存储的 互不干扰
class Person
{
public:
int m_A; //非静态成员变量 属于类的对象上
static int m_B; //静态成员变量 不属于类对象上
void func() //非静态成员函数 不属于类对象上
{
}
static void func2(){
} //非静态成员函数 不属于类对象上
};
int Person::m_B = 100;
void test01()
{
Person p;
//空对象占用内存空间为:0 4 1 答:1
// C++编译器会给每一个空对象也分配一个字节的空间,为了区分空对象占内存的位置
//每个空对象也应该有一个独一无二的内存地址
cout << "size of p:" << sizeof(p) << endl;
}
void test02()
{
//只要不属于空对象,定义是啥类型就是几个字节
Person p;
cout << "size of p:" << sizeof(p) << endl;
}
int main()
{
// test01();
test02();
system("pause");
return 0;
}
注:如果一个类的内部为空,此时他占用的字节并不是0,应该为1,因为C++的编译器会自动给空对象分配一个存储字节,用以区分存储位置;
错误:在定义静态成员变量后想要输出一下m_B
时发现并不能调用类;
原因:键入以后提示没有访问权限,想起一开始根据视频创建空类时,没有给其加公用属性,加上public
后就可以用两种方式对其进行访问了;
4.3.2 this指针概念
通过4.3.1我们知道在C++中成员变量和成员函数是分开存储的,每一个非静态成员函数只会诞生一份函数实例,也就是说多个同类型的对象会共用一块代码。
那么问题是:这一块代码是如何区分那个对象调用自己的呢?
c++通过提供特殊的对象指针,this指针,解决上述问题。this指针指向被调用的成员函数所属的对象,this指针是隐含每一个非静态成员函数内的一种指针。它并不需要定义,直接使用即可。
this指针的用途:
*当形参和成员变量同名时,可用this指针来区分
在类的非静态成员函数中返回对象本身,可使用return this
代码示例:
#include <iostream>
using namespace std;
class Person
{
private:
/* data */
public:
Person(int age)
{
// this指针,指向所调用的成员函数变量,所属的对象 防止重名
this->age = age;
}
Person &Personaddage(Person &p) //如果不带引用,则变为上几节学的拷贝函数,将会创建一个新的存储空间赋值
{
this->age += this->age;
return *this; //表示本体*this
}
int age; //演示出现重名现象,正常可以用下面形式定义成员变量
// int m_Age;
};
// 1、解决名称冲突
void test01()
{
Person p1(18);
cout << "p1的年龄是:" << p1.age << endl;
}
// 2、返回对象本身用*this
void test02()
{
Person p1(10);
Person p2(10);
//链式编程思想 与cout类似,可以无限堆加
p2.Personaddage(p1).Personaddage(p1);
cout << "p2的年龄是:" << p2.age << endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
注意:返回本身时,应该注意要使用引用的方法,如果是值返回的方式,会创建一个新的对象,即转化为拷贝函数;
4.3.3 空指针访问成员函数
C++中空指针也是可以调用成员函数的,但是也要注意有没有用到this指针
如果用到this指针,需要加以判断保证代码的健壮性
#include <iostream>
using namespace std;
//空指针访问成员函数
class Person
{
private:
/* data */
public:
void showPersonName()
{
cout << "this is class name" << endl;
}
void ShowPersonAge()
{
// cout << "age=" <<m_Age << endl;
//一般默认的this->m_Age 此时指针地址若是空,对于一个空的类储存单元访问其m_Age属性 属于无中生有
//可以加
if (this == NULL)
{
return;
}
cout << "age=" << this->m_Age << endl;
}
int m_Age;
};
void test01()
{
Person *p = NULL;
//空指针,可以调用成员函数
p->ShowPersonAge();
//
p->showPersonName();
}
int main()
{
test01();
system("pause");
return 0;
}
4.3.4 const修饰成员函数
常函数:
成员函数后加const后我们称为这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后,在常函数中依然可以修改
常对象:
声明对象前加const称该对象为常对象
常对象只能调用常函数
#include <iostream>
using namespace std;
// const修饰的成员函数、成员变量
// 常函数
class Person
{
private:
public:
// this指针的本质是一个指针常量,指针的指向是不可以修改的 但是指针指向的内存保存的数据可以修改
// 只有一个this->m_A时等于Person * const this 如果想让指针指向的值也不可以修改,需要声明常函数 -----> const Person * const this;
// ()后面的const相当于const Person * const this 第一个const 在成员函数后面加上const 相当于修饰this指针的指向,让指针指向的值也不可以修改
void showPerson() const
{
this->m_B = 100;
// this->m_A = 100;
// this = NULL; //指针不能修改指针的指向 Person * const this
}
void func()
{
}
Person()
{
}
int m_A;
mutable int m_B; //特殊变量,在const修饰的常函数之中也可也修改值的变量 加关键字 mutable
};
void test01()
{
Person p;
p.showPerson();
}
//常对象
void test02()
{
const Person p; //在对象前面加个常 变成常对象 创建常对象时 应该在类里创建构造函数否则会报错
// p.m_A = 100;//常对象不可以修改
p.m_B = 100; // m_B是特殊值,在常对象下可以修改
p.showPerson(); //常对象只能调用常函数
// p.func();//不兼容的类型限定符
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
注意:每一个成员函数里的this指针;
this指针的本质 指针常量 指向不可以修改 但是指向的值可以修改
4.4 友元
生活中你的家有客厅(Public),有你的卧室(Private)
客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去
但是呢,你也可以允许你的好闺蜜好基友进去。
在程序里,有些私有属性 也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术
友元的目的就是让一个函数或者类 访问另一个类中私有成员
友元的关键字为 friend
友元的三种实现
- 全局函数做友元
- 类做友元
- 成员函数做友元
4.4.1全局函数做友元
#include <iostream>
using namespace std;
//全局函数做友元
//建筑物
class Building
{
// goodGay是Building的友元,因此可以访问其私有成员
friend void goodGay(Building *building);
public:
Building()
{
m_BedRoom = "卧室";
m_SettingRoom = "客厅";
}
private:
string m_BedRoom;
public:
string m_SettingRoom;
};
//创建一个全局函数
void goodGay(Building *building) //指针应该传一个地址
{
cout << "好基友全局函数正在访问:" << building->m_SettingRoom << endl;
cout << "好基友全局函数正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
Building building;
goodGay(&building);
}
void test02()
{
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
4.4.2 类做友元
#include <iostream>
using namespace std;
//类做友元
class Building; //声明一下
class goodGay
{
private:
public:
goodGay();
void vsisit();
Building *building;
};
//建筑物
class Building
{
//告诉编译器 goodGay类是Building类的友元 前者可以访问后者的私有内容
friend class goodGay;
public:
Building();
private:
string m_BedRoom;
public:
string m_SettingRoom;
};
Building::Building()
{
this->m_BedRoom = "卧室";
this->m_SettingRoom = "客厅";
}
goodGay::goodGay()
{
building = new Building; // 注意-------------------类里使用指针一定要分配一个新的内存
}
void goodGay::vsisit()
{
cout << "好基友全局函数正在访问:" << building->m_SettingRoom << endl;
cout << "好基友全局函数正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.vsisit();
}
void test02()
{
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
注意:类内使用指针一定要在构造函数中用new分配一个新的内存
4.4.3 成员函数做友元
#include <iostream>
using namespace std;
//成员函数做友元
class Building;
class goodGay
{
private:
/* data */
public:
goodGay();
void visit01(); //让visit01函数可以访问Building中的私有成员
void visit02(); //让visit02函数不可以访问Building中的私有成员
Building *building;
};
//指针指向所指对象的各种东西时用 -> 。
//类指向类下面的各种东西时,要用:: 。
//对象指向对象下面的各种东西时用 . 。
class Building
{
friend void goodGay::visit01(); //不带goodGay::作用域的话代表是全局函数
private:
string m_BedRoom;
public:
Building();
string m_SetRoom;
};
//类外实现成员函数 记得使用this->
Building::Building()
{
this->m_BedRoom = "卧室";
this->m_SetRoom = "客厅";
}
goodGay::goodGay()
{
building = new Building; //创建一个Building类型的对象堆区,并且用building存储
}
void goodGay::visit01()
{
cout << "visit01正在访问 " << building->m_SetRoom << endl;
cout << "visit01正在访问 " << building->m_BedRoom << endl;
}
void goodGay::visit02()
{
cout << "visit02正在访问 " << building->m_SetRoom << endl;
// cout << "visit02正在访问 " << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit01();
gg.visit02();
}
void test02()
{
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
/*
成员函数做友元易错点:
1.因为Goodgay类需要声明Building类变量,所以Building类必须Goodgay类之前声明(前向声明);
2.因为Building的定义中需要将Goodgay类的成员函数声明成友元成员函数,所以Building类必须Goodgay类之后定义;
3.因为Goodgay中的构造函数需要调用Building的构造函数,所以Goodgay类中构造函数的实现必须在Building类的定义之后;
总结:
1. Building类在Goodgay类前面声明,后面定义;
2. Goodgay类定义“类内”时不实现 构造函数 和 需要friend的成员函数;
3. Goodgay在Building类定义后,“类外”实现构造函数 和 需要friend的成员函数;
*/
成员函数做友元易错点:
1.因为Goodgay类需要声明Building类变量,所以Building类必须Goodgay类之前声明(前向声明);
2.因为Building的定义中需要将Goodgay类的成员函数声明成友元成员函数,所以Building类必须Goodgay类之后定义;
3.因为Goodgay中的构造函数需要调用Building的构造函数,所以Goodgay类中构造函数的实现必须在Building类的定义之后;
总结:
- Building类在Goodgay类前面声明,后面定义;
- Goodgay类定义“类内”时不实现 构造函数 和 需要friend的成员函数;
- Goodgay在Building类定义后,“类外”实现构造函数 和 需要friend的成员函数;
4.5 运算符重载
运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
4.5.1 加号运算符重载
作用:实现两个自定义数据类型相加的运算
#include <iostream>
using namespace std;
// 重载之后的+只是简写, 还是得按照参数列表传值
// 加号运算符重载
// 1、成员函数重载 +号 本质运算是 Person p3 = p1.operator+(p2);
// 2、全局函数重载 +号 本质运算是 person p3 = p1.operator+(p1,p2)
class Person
{
private:
/* data */
public:
// Person operator+(Person &p)// P为值传递,无法改变实参,&p为引用传递,可以改变实参
// {
// Person temp;
// temp.m_A = this->m_A + p.m_A;
// temp.m_B = this->m_B + p.m_B;
// return temp;
// }
int m_A;
int m_B;
};
// 2、全局函数重载 +号
Person operator+(Person &p1, Person &p2) // P为值传递,无法改变实参,&p为引用传递,可以改变实参
{
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 num)
{
Person temp;
temp.m_A = p1.m_A + num;
temp.m_B = p1.m_B + num;
return temp;
}
void test01()
{
//这里其实写的有点麻烦 不如用括号法加上构造函数来赋值
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
Person p3;
p3 = p1 + p2;
Person p4;
p4 = p1 + 25;
cout << "p3.m_A=" << p3.m_A << endl;
cout << "p3.m_B=" << p3.m_B << endl;
cout << "p4.m_A=" << p4.m_A << endl;
cout << "p4.m_B=" << p4.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结1:重载之后的+只是简写, 原则上还是得按照参数列表传值
4.5.2 左移运算符重载
作用:可以输出自定义数据类型
通过重载左移运算符,让编译器知道如何操作形似cout<<p
该类运算符
#include <iostream>
using namespace std;
class Person
{
friend ostream &operator<<(ostream &out, Person &p);
private:
int m_A;
int m_B;
public:
Person(int a, int b);
// p<<cout 成员函数实现不了重载左移运算符 本质上 p.operator<<(cout) 简化表示其实是 p<< cout 并不是我们想要的cout << p;
// void operator<<(Person &p) {}
// int m_A;
// int m_B;
};
Person::Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//只能使用全局函数重载左移运算符
//本质 operator<<(cout,p) 简化为cout << p 注意: void operator<<(ostream &out, Person &p)仅仅实现一次 cout<<p 联想上几次课this返回对象本身实现的链式编程,一定要加引用& 否则会创建一个新的的对象
ostream &operator<<(ostream &out, Person &p) //可以把引用&cout换为&out 因为引用本身就有起别名的功能
{
out << "a:" << p.m_A << " b:" << p.m_B;
return out;
}
void test()
{
Person p1(10, 20);
cout << p1 << " hello world " << endl;//链式编程
}
int main()
{
test();
system("pause");
return 0;
}
注意:成员函数不能够进行左移运算符重载,只有全局函数可以进行左移运算符重载
注意:cout 隶属于 ostream输出流,链式编程的代表就是cout
注意:链式编程一定要在函数返回前加上&,否则将会创建一个新的对象
4.5.3 递增运算符重载
作用:通过重载递增运算符,实现自己的整形数据前置递增和后置递增运算
#include <iostream>
using namespace std;
//重载递增运算符
//自定义整型
class MyInteger
{
friend ostream &operator<<(ostream &cout, const MyInteger &myint);
private:
int m_Num;
public:
MyInteger();
~MyInteger();
//重载前置++运算符
MyInteger &operator++() //返回引用是因为不想重新生成一个新的对象,链式编程思想,只对一个对象做重复操作
{
m_Num++;
return *this; //*this解引用表示自身
}
//重载后置++运算符
//此时不加引用,返回一个值是因为已经建立新对象temp,且如果返回一个引用则会使得temp变为局部对象变量,局部对象变量会再当前函数结束后自动释放掉
MyInteger operator++(int) // int代表占位参数,可以用于区分前置和后置递增
{
// 1.先记录当时结果
MyInteger temp = *this;
// 2.后进行递增
m_Num++;
// 3.最后再返回记录的结果
return temp;
}
};
MyInteger::MyInteger()
{
this->m_Num = 0;
}
MyInteger::~MyInteger()
{
}
//重载左移<<运算符
// ostream &operator<<(ostream &cout, MyInteger myint)//后置的时候不能进行链式运算
ostream &operator<<(ostream &cout, const MyInteger &myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
MyInteger myint;
cout << ++(++myint) << endl; //直接加入操作符会提示并不存在,原因是myint是我们自定义的整型数据
cout << myint << endl;
}
// C++中产生的临时对象是不可修改的,即默认为const的
//非const引用只能绑定到与该引用同类型的对象,但是非常量对象可以绑定到const引用上,
//因此可以去掉左移重载参数的类的引用符,即ostream &operator<<(ostream &cout, MyInt myint)
//或者加上const变为常量引用,即ostream &operator<<(ostream &cout, const MyInt &myint)
//注意该两种方法一定要记得把最上面的友元修改为相同的形式,否则会报错
void test02()
{
MyInteger myint1;
cout << myint1++ << endl;
cout << myint1 << endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
注意:前置运算符需要引用,后置运算符需要返回值
注意:区分前置运算符重载和后置运算符重载的关键是占位符 int
注意:后置递增报错问题,原理以及两种解决方案:
C++中产生的临时对象是不可修改的,即默认为const的
非const引用只能绑定到与该引用同类型的对象,但是非常量对象可以绑定到const引用上,
因此可以去掉左移重载参数的类的引用符,即ostream &operator<<(ostream &cout, MyInt myint)
或者加上const变为常量引用,即ostream &operator<<(ostream &cout, const MyInt &myint)
注意该两种方法一定要记得把最上面的友元修改为相同的形式,否则会报错
注意:第三种方法搞定后置递增运算报错,不需要修改重载左移运算符函数,使用后置递增运算myint1++;cout<<myint1<<out;
此方法仅能将运算符后置运算之后的值输出,不可以输出myint1
的值
问题遗留:该节虽然实现了前置运算符和后置运算符的重载,对自定义整型参数进行了递增运算,但是基于链式编程的思想,仅完成了前置递增运算,后置递增运算并没有实现,后续如果有能力应该对此节后置递增运算符重新构建;
拓展递减运算重载
#include <iostream>
using namespace std;
//重载递增运算符
//自定义整型
class MyInteger
{
friend ostream &operator<<(ostream &cout, const MyInteger &myint);
private:
int m_Num;
public:
MyInteger();
~MyInteger();
//重载前置++运算符
MyInteger &operator++()
{
m_Num++;
return *this; //*this解引用表示自身
}
//重载后置++运算符
MyInteger operator++(int) // int代表占位参数,可以用于区分前置和后置递增
{
// 1.先记录当时结果
MyInteger temp = *this;
// 2.后进行递增
m_Num++;
// 3.最后再返回记录的结果
return temp;
}
//重载前置--运算符
MyInteger operator--()
{
m_Num--;
return *this;
}
//重载后置--运算符 int 相当于占位符
MyInteger operator--(int)
{
//先记录当前这个数
MyInteger temp;
//进行--操作
m_Num--;
//返回开始记录的那个数
return temp;
}
};
MyInteger::MyInteger()
{
this->m_Num = 3;
}
MyInteger::~MyInteger()
{
}
//重载左移<<运算符
ostream &operator<<(ostream &cout, const MyInteger &myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
MyInteger myint;
cout << ++(++myint) << endl;
cout << myint << endl;
}
void test02()
{
MyInteger myint;
cout << myint++ << endl;
cout << myint << endl;
}
void test03()
{
MyInteger myint;
cout << myint--<<endl;
cout << myint << endl;
}
void test04()
{
MyInteger myint;
cout << --myint << endl;
cout << myint << endl;
}
int main()
{
test01();
test02();
test03();
test04();
system("pause");
return 0;
}
4.5.4 赋值运算符重载
c++编译器至少给一个类添加4个函数
默认构造函数(无参,函数体为空)
默认析构函数(无参,函数体为空)
默认拷贝构造函数,对属性进行值拷贝
赋值运算符 operator=, 对属性进行值拷贝
如果类中有属性指向堆区,做赋值操作时也会出现深浅拷贝问题
#include <iostream>
using namespace std;
//赋值运算符重载
class Person
{
private:
public:
Person(int age);
~Person();
Person &operator=(Person &p)
{
//编译器提供的浅拷贝 m_Age=P.m_Age;
//应该先判断是否有属性在堆区,如果有应该先释放干净,然后再进行深拷贝
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
//深拷贝
this->m_Age = new int(*p.m_Age);
//返回对象本身
return *this; //链式编程思想
}
int *m_Age;
};
Person::Person(int age)
{
this->m_Age = new int(age); //堆区 由程序员手动开启,由程序员手动释放 因此需要加个析构韩硕
}
Person::~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
void test01()
{
Person p1(18);
Person p2(28);
Person p3(38);
p3 = p2 = p1; //赋值操作
cout << "p1岁数:" << *p1.m_Age << endl;
cout << "p2岁数:" << *p2.m_Age << endl;
cout << "p3岁数:" << *p3.m_Age << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
//是指针的值,存储的是地址。所以本质上拷贝过去的值是一个地址值。这也导致了,两个不同的指针,指向同一块儿内存。看上去像是改变了'值',实际上只是挪了以下指针的指向而已。但是原本类里开辟的区域,它的值可以一直存在的,该多少还是多少。因此,这根本不算值拷贝
注意:因为第二次判断时是判断p2中的地址是不是空而不是判断堆区的内存,两个指针地址都指向同一个内存,因此会出现重析构运行bug
解决方案:利用深拷贝解决浅拷贝带来的问题
4.5.5 关系运算符重载
作用:重载等于==
和不等于!=
两个关系运算符,用于自定义类型对象的对比操作
#include <iostream>
using namespace std;
//重载 关系运算符
class Person
{
private:
public:
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;
}
else
return false;
}
bool operator!=(Person &p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return false;
}
else
return true;
}
string m_Name;
int m_Age;
};
void test01()
{
Person p1("Tom", 19);
Person p2("Tom", 18);
if (p1 == p2)
{
cout << "equivalent" << endl;
}
else
{
cout << "not equivalent!!!" << endl;
}
if (p1 != p2)
{
cout << "not equivalent" << endl;
}
else
{
cout << "equivalent!!!" << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
4.5.6 函数调用运算符重载
函数调用运算符 () 由于重载后使用的方式非常像函数的调用,因此称为仿函数
作用:仿函数比较灵活多变 此处用于实现一个打印输出类
拓展:匿名函数 即直接使用重载后的函数调用运算符(没有声明)
#include <iostream>
using namespace std;
//重载 函数调用运算符 ()
//打印输出的一个类
class MYPrint
{
private:
/* data */
public:
void operator()(string test)
{
cout << test << endl; // test不加双引号,直接输出string test
}
};
void test01()
{
MYPrint myPrint;
myPrint("hello world!"); //仿函数
}
//仿函数非常灵活,没有固定的写法
//加法类
class MYAdd
{
private:
/* data */
public:
int operator()(int a, int b)
{
return a + b;
}
};
void test02()
{
MYAdd myadd;//myadd算作起名了
int sum = myadd(100, 100);
cout << sum << endl;
//匿名函数对象
cout << MYAdd()(100, 100) << endl;
//特点当前行执行完立即被释放
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
4.6 继承
继承是面向对象三大特性之一
有些类与类之间存在特殊的关系,定义这些类时,下级别的成员除了拥有上一级的共性,还有自己的特性。
这个时候我们就可以考虑利用继承的技术,减少重复代码
4.6.1 继承的基本语法
继承的好处:减少重复代码
继承使用语法: class 子类 : 继承方式 父类
子类 也称为 派生类
父类 也称为 基类
子类中包含两大部分:
一部分是从父类通过不同方式继承,一部分是自己本身区别于父类增加的。
从父类继承过来的部分表现子类共性,而新增的部分则体现了子类个性。
#include <iostream>
using namespace std;
//继承实现
//公共页面
class BasePage
{
public:
void header()
{
cout << "首页、公开课、登录、注册...(公共头部)" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java,Python,C++...(公共分类列表)" << endl;
}
};
//继承的好处:减少重复代码
//继承使用语法: class 子类 : 继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类
// Java页面
class Java : public BasePage //此处继承方式是public 公共继承方式
{
public:
void content()
{
cout << "JAVA学科视频" << endl;
}
};
// Python页面
class Python : public BasePage
{
public:
void content()
{
cout << "Python学科视频" << endl;
}
};
// C++页面
class CPP : public BasePage
{
public:
void content()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
// Java页面
cout << "Java下载视频页面如下: " << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "--------------------" << endl;
// Python页面
cout << "Python下载视频页面如下: " << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "--------------------" << endl;
// C++页面
cout << "C++下载视频页面如下: " << endl;
CPP cp;
cp.header();
cp.footer();
cp.left();
cp.content();
}
int main()
{
test01();
system("pause");
return 0;
}
总结
此系列用于记录平时学习C++过程中的笔记;