目录
一、类的引入
二、类的访问限定符
三、类的中成员函数的定义和声明
四、类的大小及类对象的存储方式
1、类的大小
2、类对象的存储方式
五、隐含的this指针
1、this指针的特点
2、this指针可以为空吗?
六、运算符重载
1、运算符重载的概念
2、运算符重载的注意事项
3、<<流插入、>>流提取运算符
4、赋值运算符重载
七、类的六大默认成员函数
八、全局函数的函数名重复问题
1、问题描述
2、解决方案
九、const对象、成员函数权限问题
1、const对象无法调用非const成员函数
2、日期类const对象调用非const的operator-失败
十、类的静态成员
1、类的静态成员特点
2、静态成员函数能调用非静态成员变量吗?
十一、友元
1、友元函数
2、友元函数的特点
3、友元类
4、友元类的特点
十二、内部类
1、内部类的大小
2、内部类的访问
3、内部类的特点
十三、匿名对象及编译器的优化行为
1、匿名对象
2、单参数、多参数的隐式类型转换的优化行为
3、匿名对象传参时的优化写法
3.1优化前
3.2优化后
4、编译器对返回值的优化
4.1无优化
4.2构造优化
4.3使用匿名对象极致优化
C语言中,结构体struct中只能定义变量,而函数全部都定义在结构体的外部,这就使得C语言是一门面向过程的语言。而C++中,将成员变量和成员函数放在一个类中,使得C++是面向对象的语言。
类的访问限定符有public(公有)、private(私有)、protected(保护)
1、类的访问限定符是限制类域外的访问权限,类域内部都是可以互相访问到的
2、class默认访问权限是private,而struct的中的默认访问权限是public
类定义了一个新的作用域,成员函数可以在类中定义,也可以只把函数声明放在类中,定义放在类外。不过将定义放在类外的方式需要在函数名前写清楚类域。
class stu
{
public:
void print();
private:
char _name[10];
size_t _age;
};
void stu::print()//定义在外,需要指明该函数的类域
{
;
}
类的大小只计算成员变量的大小,不计算成员函数的大小。类的大小遵循内存对齐规则(详见【C语言】结构体内存对齐规则)。
注意:空类的大小是1字节,用于占位。
类的非静态成员变量存储在类中(栈区),在计算类的大小时,只计算成员变量的大小即可。
每个对象的成员变量都不相同,但每个变量所需要调用的成员函数都是相同的,所以把类的非静态成员函数全部放在代码区,形成一个公共的类函数代码区域,每个对象在调用函数时直接去该区域调用成员函数。
这样做的优势是,每个对象在创建时,只要保存成员变量即可,减少了创建变量所需要的空间,需要调用成员函数时,每个对象自己去公共的代码区域调用即可。
那么C++中的类将成员变量和成员函数封装在一起,我们并没有像C语言那样传入对象结构体的参数,那么编译器是怎么知道这次调用时属于哪个对象的呢?原因在于C++中,每个非静态函数有一个隐含的this指针。通过this指针,谁调用成员函数就是访问谁的成员变量。
this指针定义传递是编译器的事情,我们只能在成员函数内部使用this指针。
1、className* const this注意this指针是被const修饰的,我们不能改动this。只能在成员函数内部使用this
2、this指针本质上是成员函数的形参,当对象调用成员函数时,将对象的地址作为实参传递给this指针,所以对象中不存储this指针。
3、编译器在生产程序时获取了对象的地址,并把获取到的地址放到了寄存器ECX中。(形参存放在栈区,this指针在寄存器ECX中)
this指针可以为空。
class A {
public:
void Print()//这里的this指针不发生解引用
{
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();//这里不是解引用
return 0;
}
上面这段代码是可以运行成功的。因为成员函数没有存放在对象中,而是在公共代码区域,所以p->Print()不是解引用,A* const this(这里的this就是p)调用Print()函数。所以this指针可以为空。
class A
{
public:
void PrintA()
{
cout << _a << endl;//相当于cout<_a<PrintA();//这里不是解引用
return 0;
}
上面这段代码printA函数中发生了this指针的解引用,this就是外部传入的p,这里相当于对空指针的解引用。
运算符重载的使用可参考此处:【C++】实现一个日期计算器。
C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。
函数名为:关键字operator后面接需要重载的运算符符号。
函数原型:返回值类型 operator操作符(参数列表)
例如bool operator==(const Date& d)
1、不能通过连接其他符号来创建新的操作符:比如operator@ ,@是未知字符,只有运算符才能重载。
2、运算符重载必须有一个类类型参数,且这个操作符有几个操作数就得有几个参数,比如全局operator+,类内通过函数调用私有变量,有两个参数。
3、用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不能改变其含义。
4、写成成员函数时,第一个参数是隐含的this指针。
5、.* :: sizeof ?: . 注意以上5个运算符不能重载。
6、像++和--是单操作数的运算符,在重载时,无法区分是前置的重载还是后置的重载,所以C++规定:前置重载与普通运算符重载一致,后置重载需要在参数列表中加入一个无用的参数。这个参数必须是int类型(用别的类型编译器报错)。
这两个运算符一般不在类中重载,而是在全局重载。为了访问到类中的私有变量,会在类中放入该函数友元声明。
因为类中的成员函数第一个参数是隐含的this指针,而根据使用习惯,流插入和流提取运算符的重载的类对象应该是右操作数。
对于赋值运算符重载,这是一个特殊的运算符重载,因为它是类的六大默认成员函数之一。
所以它的声明必须在类中,如果声明在全局,类中会生成默认的赋值运算符的重载,会和这个全局的赋值运算符重载发生函数名冲突!!!
详见【C++】类的六大默认成员函数
当一个函数定义在全局的头文件时,它将会在预处理阶段在所有的.cpp文件中展开并包含。并在链接阶段发生函数名重复的问题。
1、声明和定义分离;
2、在函数前加上static,改变函数的链接属性。当该函数在预处理阶段被多个.cpp包含时,因为是静态的函数,不会进符号表。(仅当前文件可见)
3、在函数前加上inline,内联函数在编译时不会进符号表。
所以.h尽量不要定义全局的变量或函数。
注意:权限放大只针对指针和引用,与赋值无关。
函数右边的const是修饰this指针指向的内容,即*this。
例如此处的报错是由于d.operator>(const Date& d);传参时权限放大。
总结:函数内部不改变成员变量,即*this对象数据不改变的函数,函数后需要加上const修饰this指针,保护*this。
1、静态成员变量必须在类外初始化,且定义时不加static但要加上类域(C++语法中,只有指针和整型的const static成员是可以在类中进行初始化的。)
2、静态成员存放于静态区,所有类对象共享这些静态成员,所以静态成员不占用类的内存空间。
3、类的公共静态成员可用类名::静态成员 或者 对象.静态成员来访问
4、静态成员函数没有隐藏的this指针,不能访问任何非静态成员
5、静态成员也是类的成员,生命周期是全局的,但是作用域受public、protected、private 访问限定符的限制
不能。
因为静态成员函数没有this指针,无法调用对象的普通成员函数。
记住普通可以调静态,静态调不了普通,原因是静态没有this。
友元破坏封装,尽量少用。
//类内声明为友元函数
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
//需要在类外定义
inline ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << " " << d._month << " " << d._day << endl;
return out;
}
inline istream& operator>>(istream& in, Date& d)
{
in >> d._year >>d._month >> d._day;
return in;
}
像流插入和流提取运算符在重载时,根据使用习惯,第一个参数不应是本身,所以将这两个运算符放在类外定义,在类中放入该声明,并在声明前加上friend修饰。让这个函数成为友元函数。
1、友元函数可以访问类的私有和保护成员,但不是类的成员函数。
2、友元函数不能用const修饰
3、友元函数的声明可以放在类中的任意位置,它不受类访问限定符限制
4、一个函数可以是多个类的友元
class Time
{
private:
friend class Date;//友元声明可以在类中的任意位置
int _hour;
};
Date类是Time类的友元,这样Date就可以正常访问Time的私有和保护成员。
1、友元没有传递性,比如A是B的友元,B是C的友元,但是不能说A是C的友元。
2、友元关系不能继承。
class A
{
public:
class B//B类不在A中
{
int b;
};
private:
int _a;
};
这里A的大小是4字节。
B是A的内部类,但是B不存储于A的类中。
A::B b;
1、注意B类也会受A类访问限定符的影响
2、B类天生是A类的友元。(B可以偷A的家,但A无法偷B的家)所以内部类也尽量少用。
Date();//创建了个匿名对象
Date().Func();//使用匿名对象调用成员函数
Date Func()//使用匿名对象返回
{
return Date(10);
}
匿名对象的生命周期在这一行。匿名对象具有常性。
//日期类略
int main()
{
//单参数的构造,构造+拷贝,编译器直接优化为构造C++98
Date d1 = 2022;
//临时对象具有常性,这里就发生了一次构造,编译器没有优化空间了
const Date& d2 = 2023;
//多参数的构造C++11
Date d3 = { 2022,10,16 };
return 0;
}
单参数、多参数的构造由构造+拷贝构造优化为直接构造。
void Func(Date d)
{
}
int main()
{
Date d1(2022);//构造
Func(d1);//传参发生拷贝构造
return 0;
}
void Func(Date d)//形参改成const Date& d也是一种优化
{
}
int main()
{
Func(Date(2022));//使用匿名对象传参,构造+拷贝构造,编译器直接优化为构造
Func(2022);//隐式类型转换的优化,也是由构造+拷贝构造,编译器直接优化为构造
return 0;
}
由构造+拷贝构造变成一次构造。
Date Func()
{
Date d(2022);//构造
return d;//return时拷贝构造一份临时对象
}
int main()
{
Date ret;
ret = Func();//使用返回的临时对象进行赋值
return 0;
}
Date Func()
{
Date d(2022);//构造
return d;//return时拷贝构造一份临时对象
}
int main()
{
Date ret = Func();//使用返回的临时对象拷贝构造ret
return 0;
}
正常的流程如注释所示,需要构造+拷贝构造+拷贝构造,但是编译器会将其优化为构造+拷贝构造。
Date Func()
{
return Date(2022);//使用2022构造一个临时匿名对象,return时再拷贝构造一份临时对象
}
int main()
{
Date ret = Func();//使用返回的临时对象进行拷贝构造
return 0;
}
这样写由构造+拷贝构造+拷贝构造,会被编译器直接优化为构造。是最优的写法。(因为匿名对象的生命周期只在这一行,所以只能传值返回,而不能传引用返回。)