【C++核心编程(三)】
一、C++对象模型和this指针
1.1、成员变量和成员函数分开存储
在C++中，类内的成员变量和成员函数分开存储，
只有非静态成员变量才属于类的对象上。
class Person
{
int m_A;//非静态成员变量 - 属于类的对象上
static int m_B;//静态成员变量 - 不属于类的对象上
void func() {}//非静态成员函数 - 不属于类的对象上
static void func2() {}//静态成员函数 - 不属于类的对象上
};
int Person::m_B = 10;
void test01()
{
Person p;
//空对象占用内存空间为: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;
}
1.2、this指针概念
通过上述知识点我们知道在C++中成员变量和成员函数是分开存储的，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。那么问题是: 这一块代码是如何区分那个对象调用自己的呢?
C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象。
this指针是隐含每一个非静态成员函数内的一种指针。
this指针不需要定义，直接使用即可。
this指针的用途:
·当形参和成员变是同名时，可用this指针来区分
·在类的非静态成员函数中返回对象本身，可使用return *this
class Person
{
public:
int age;
Person(int age)
{
this -> age = age;
}
Person& PersonAddAge(const Person& p)
{
this->age += p.age;
//this是指向p2的指针,而*this就是指向p2这个对象本体
return *this;
}
};
//this解决名称冲突问题
void test01()
{
Person p(18);
cout << "p的年龄:" << p.age << endl;
}
//返回对象本身用this*
void test02()
{
Person p1(10);
Person p2(10);
//链式编程思想
p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
cout << "p2的年龄:" << p2.age << endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
1.3、空指针访问成员函数
C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针。
如果用到this指针，需要加以判断保证代码的健壮性!
class Person
{
public:
int m_Age;
void showClassName()
{
cout << "this is Person class!" << endl;
}
void showPersonAge()
{
if (this == NULL)
{
return;
}
//错误原因是因为传入的指针是NULL(属性前默认有this->)
cout << "age = " << this->m_Age << endl;
}
};
void test01()
{
Person* p = NULL;
p->showClassName();
p->showPersonAge();
}
int main()
{
test01();
system("pause");
return 0;
}
1.4、const修饰成员函数
常函数:
·成员函数后加const后我们称为这个函数为常函数
·常函数内不可以修改成员属性
·成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象:
·声明对象前加const称该对象为常对象
·常对象只能调用常函数
class Person
{
public:
int m_A;
mutable int m_B;//特殊变量,即使在常函数中,也可以修改
void showPerson()const//常函数
{
//this指针的本质是指针常量,指针的指向是不可以修改的
//const Person* const this
//this->m_A = 100;//err - 在成员函数后加const,修饰的是this指向,让指针指向的值也不可以修改
//this = NULL;//err - this指针是不可以修改指针指向的
this->m_B = 10;
}
void func()
{
m_A = 100;
cout << "fun()" << endl;
}
};
void test01()
{
Person p;
p.showPerson();
}
void test02()
{
const Person p;//常对象
//p.m_A = 100;//err
p.m_B = 100;//m_B是特殊值,在常对象下也可以修改
//常对象只能调用常函数
p.showPerson();
//p.func();//err - 因为常对象是不允许修改属性的,如果常对象调用普通函数则可以修改属性,前后矛盾
//普通成员函数可以修改属性
}
int main()
{
test01();
system("pause");
return 0;
}
二、友元
生活中你的家有客厅(Public)，有你的卧室(Private)
客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去
但是呢，你也可以允许你的好闺蜜好基友进去。
在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术。
友元的目的就是让一个函数或者类访问另一个类中私有成员
友元的关键字为:friend
友元的三种实现:
·全局函数做友元
//建筑物类
class Building
{
//goodGay全局函数是Building的好朋友,可以访问Building中私有成员
friend void goodGay(Building& building);
public:
string m_SittingRoom;//客厅
private:
string m_BedRoom;//卧室
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
};
//全局函数
void goodGay(Building& building)
{
cout << "好朋友的全局函数正在访问:" << building.m_SittingRoom << endl;
cout << "好朋友的全局函数正在访问:" << building.m_BedRoom << endl;
}
void test01()
{
Building building;
goodGay(building);
}
int main()
{
test01();
system("pause");
return 0;
}
·类做友元
class Building
{
//GoodGay类是本类的好朋友,可以访问本类的私有成员
friend class GoodGay;
public:
string m_SittingRoom;//客厅
private:
string m_BedRoom;//卧室
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
};
class GoodGay
{
public:
Building* building;
GoodGay()
{
//创建建筑物对象
building = new Building;
}
void visit()//参观函数,访问Building属性
{
cout << "好朋友类正在访问:" << building->m_SittingRoom << endl;
cout << "好朋友类正在访问:" << building->m_BedRoom << endl;
}
};
void test01()
{
GoodGay gay;
gay.visit();
}
int main()
{
test01();
system("pause");
return 0;
}
·成员函数做友元
class Building;
class GoodGay
{
public:
Building* building;
GoodGay();
void visit();
void visit2();
};
class Building
{
//告诉编译器GoodGay类下的visit成员函数作为本类的好朋友,可以访问私有成员
friend void GoodGay::visit();
public:
string m_SittingRoom;//客厅
private:
string m_BedRoom;//卧室
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
};
GoodGay::GoodGay()
{
building = new Building;
}
void GoodGay::visit()
{
cout << "visit函数正在访问:" << building->m_SittingRoom << endl;
cout << "visit函数正在访问:" << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
cout << "visit2函数正在访问:" << building->m_SittingRoom << endl;
//cout << "visit2函数正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
GoodGay gay;
gay.visit();
gay.visit2();
}
int main()
{
test01();
system("pause");
return 0;
}上述代码的顺序必须严格，不然则会报错。
①先声明Building类的存在(因为GoodGay中创建了Building类型的指针)
②实现GoodGay类(利用全局函数的方式来实现，类内的成员函数仅做声明)
③实现Building类
④对GoodGay类中的函数一一实现(GoodGay的构造函数必须在类外实现且要在Building类实现后，因为里面需要创建Building类的对象，如若在类内实现，前面光声明Building类不够，会报错)
三、运算符重载
运算符重载概念:对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
编译器给起了一个通用名称：operator运算符
3.1、加号运算符重载
作用:实现两个自定义数据类型相加的运算
//加号运算符重载
class Person
{
public:
int m_A;
int m_B;
//1.成员函数重载+号
//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 operator+(Person& p1, Person& p2)
{
Person temp;
temp.m_A = p1.m_A + p2.m_B;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
//函数重载的版本
Person operator+(Person& p, int num)
{
Person temp;
temp.m_A = p.m_A + num;
temp.m_B = p.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 = p1.operator+(p2);
//全局函数重载的本质调用
//Person p3 = operator+(p1, p2);
Person p3 = p1 + p2;
cout << "p3的m_A:" << p3.m_A << endl;
cout << "p3的m_B:" << p3.m_B << endl;
//运算符重载也可以发生函数重载
Person p4 = p1 + 100;
cout << "p4的m_A:" << p4.m_A << endl;
cout << "p4的m_B:" << p4.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结1:对于内置的数据类型的表达式的的运算符是不可能改变的
总结2:不要滥用运算符重载
3.2、左移运算符重载
作用: 可以输出自定义数据类型
//左移运算符重载
class Person
{
friend ostream& operator<<(ostream& cout, Person& p);
public:
Person(int a, int b)
{
m_A = a;
m_B = b;
}
private:
int m_A;
int m_B;
//利用成员函数重载<<
//一般不会利用成员函数重载<<运算符,因为无法实现cout在左侧
//void operator<<(cout)// == p.operator<<(cout) 简化:p << cout
//{
//}
};
//全局函数重载<<
ostream& operator<<(ostream &cout , Person& p)//本质:operator<<(cout , p) - 简化:cout << p
{
cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
return cout;
}
void test01()
{
Person p(10, 10);
cout << p << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
总结: 重载左移运算符配合友元可以实现输出自定义数据类型
3.3、递增运算符重载
作用: 通过重载递增运算符，实现自己的整型数据
//重载递增运算符++
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger myint);
private:
int m_Num;
public:
MyInteger()
{
m_Num = 0;
}
//重载++运算符
//重载前置++
MyInteger& operator++()//使用引用是为了一直对一个数据进行递增操作
{
//先进行++运算
m_Num++;
//再将自身返回
return *this;
}
//后置递增返回值/前置递增返回引用 - 因为如果后置递增返回引用,那我们返回的是局部对象的引用
//局部对象在当前函数执行完后会被释放,还要访问其引用则是非法操作
//重载后置++
MyInteger operator++(int)//int代表占位参数 - 可以用于区分前置和后置++
{
//先记录当时结果
MyInteger temp = *this;
//后递增
m_Num++;
//最后将记录结果返回
return temp;
}
};
//重载左移运算符
ostream& operator<<(ostream &cout , 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;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
总结:前置递增返回引用，后置递增返回值
3.4、赋值运算符重载
c++编译器至少给一个类添加4个函数:
1.默认构造函数(无参，函数体为空)
2.默认析构函数(无参，函数体为空)
3.默认拷贝构造函数，对属性进行值拷贝
4.赋值运算符 operator=，对属性进行值拷贝
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题。
3.5、关系运算符重载
作用: 重载关系运算符，可以让两个自定义类型对象进行对比操作
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;
}
};
void test01()
{
Person p1("Tom", 18);
Person p2("Jerry", 18);
if (p1 == p2)
{
cout << "p1和p2相等!" << endl;
}
if (p1 != p2)
{
cout << "p1和p2不相等!" << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}3.6、函数调用运算符重载
·函数调用运算符()也可以重载
·由于重载后使用的方式非常像函数的调用，因此称为仿函数
·仿函数没有固定写法，非常灵活
//打印输出类
class MyPrint
{
public:
//重载函数调用运算符
void operator()(string print)
{
cout << print << endl;
}
};
void test01()
{
MyPrint myprint;
myprint("Hello World!");//由于使用起来非常类似于函数调用,因此称为仿函数
}
//仿函数非常灵活,没有固定的写法
//加法类
class MyAdd
{
public:
int operator()(int num1, int num2)
{
return num1 + num2;
}
};
void test02()
{
MyAdd myadd;
int ret = myadd(100, 200);
cout << "ret = " << ret << endl;
//匿名函数对象 - 是匿名对象,同时又重载了仿函数
cout << MyAdd()(100, 200) << endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}