C++类和对象收尾
在面向对象编程的世界里，“类和对象” 是构建代码大厦的核心基石。当我们对类的基本定义、对象的创建与使用有了初步认知后，还需要深入探索其更精妙的机制。本文将聚焦收尾的七大关键知识点，从构造函数的深层逻辑，到类型转换的规则；从 static 成员的独特作用，到友元带来的访问特权；从内部类的封装艺术，到匿名对象的灵活运用，再到对象拷贝时编译器的智能优化 —— 这些内容如同为你打开面向对象编程的进阶之门，助你更精准、更高效地驾驭类与对象的设计，让代码在规范性与性能之间找到完美平衡。
一初始化列表
之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方
式，就是初始化列表。
构造函数（）
:成员变量（初始值）
,成员变量（初始值）
,成员变量（初始值）
{
}
class Time
{
public:
Time()
:_hour(0)
,_min(0)
{
cout << "这是构造函数" << endl;
}
Time(int hour,int min)
:_hour(hour),
_min(min)
{
cout << "这是构造函数" << endl;
}
private:
int _hour;
int _min;
};
注意，初始化列表中每个变量只出现一次，但不是每个变量都必须出现，除了特殊的成员变量。
必须使用初始化列表的变量：
引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始
化，否则会编译报错。
正确代码：
class c
{
public:
c(int n)
{
_b = n;
}
private:
int _b;
};
class lab
{
public:
lab(int& a,int b,int d)
:_a(a)
,_b(b)
,_c(d)
{
}
private:
int& _a;
const int _b;
c _c;
};
这是因为他们在定义的时候就完成了初始化，之后都不可以在改变了。
给变量后加上缺省值：
C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的
成员使用的。
class Date
{
public:
Date()
:_year(2005)
{
cout << "构造函数" << endl;
}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year=2006;
int _month=2;
int _day=18;
};
int main()
{
Date d1;
d1.print();
return 0;
}
注意这里不是初始化，这里给的是缺省值，这个缺省值是给初始化列表的。
如果初始化列表没有显示初始化，默认就会用这个缺省值初始化。
运行结果：
理解初始化列表：
这里我们只使用初始化列表，不考虑构造函数内部初始化。
我们以后尽量使用初始化列表进行初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。
我们可以这样理解：初始化列表才是变量初始化的地方，而其他地方只是一个声明。
补充：
初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无
关。建议声明顺序和初始化列表顺序保持一致。
初始化列表总结：
无论是否显示写初始化列表，每个构造函数都有初始化列表；
无论是否在初始化列表显示初始化成员变量，每个成员变量都要走初始化列表初始化；
二类型转换
C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
这是一种隐式类型转换。加上关键字explicit就可以不发生隐式类型转换。
类类型与类类型也可以相互转换，也需要相应的构造函数实现。
编译器优化：
当然，C++是一种注重效率的语言，当编译器具体实现上面逻辑时会对操作进行优化，不同的编译器采用的方案是不一样的。
具体代码：
1.内置类型构造类类型
class A
{
public:
A(int a1)
:_a1(a1)
{
}
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{
}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a1=1;
int _a2=2;
};
int main()
{
A aa1 = 1;
aa1.Print();
return 0;
}
2.类类型构造类类型
class A
{
public:
A(int a1)
:_a1(a1)
{
}
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{
}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
int Get() const
{
return _a1 + _a2;
}
private:
int _a1=1;
int _a2=2;
};
class B
{
public:
B(const A& a)
:_b(a.Get())
{
}
private:
int _b;
};
int main()
{
// 1构造一个A的临时对象，再用这个临时对象拷贝构造aa3
A aa1 = 1;
aa1.Print();
const A& aa2 = 1;
A aa3 = { 2,2 };
// aa3隐式类型转换为b对象
B b = aa3;
const B& rb = aa3;
return 0;
}
三static成员
用static修饰的成员变量，称之为静态成员变量（相当于声明的全局变量）
和成员函数一样，static成员并不包含于类，它存放在静态区。
它的访问受限于类域，访问时要使用：：或 .或 Get 函数。
stati成员是所有类共享的，一定要在类外部初始化。
用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。它可以访问其他静态成员函数，不能访问静态成员变量。
静态成员函数的访问没有限制。非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
static成员不走初始化列表初始化，所有不要给缺省值。
static count;
在类内部声名，在类外部初始化。
class A
{
public:
static int Getcount()
{
return _count;
}
private:
static int _count;
};
int A::_count = 0;
作用：
// 实现一个类，计算程序中创建出了多少个类对象？
class A
{
public:
A()
{
_count++;
}
A(A& a)
{
_count++;
}
~A()
{
_count--;
}
static int Getcount()
{
return _count;
}
private:
static int _count;
};
int A::_count = 0;
检测用例：
int main()
{
A a1;
A a2;
A a3;
cout << A::Getcount() << endl;
A a4(a3);
cout << A::Getcount() << endl;
return 0;
}
对static成员变量的处理时机：
初始化：程序运行到定义位置时才对它进行初始化。全局变量最先初始化。
析构：static变量在普通成员后析构，在全局变量之前析构。
四友元
友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类
声明的前面加friend，并且把友元声明放到一个类的里面。
class B
{
public:
friend int add(int _a, int _b);
friend class A;
private:
int _a;
int _b;
};
函数或者类声明为友元后就可以访问类中的保护成员了。
友元的理解：
友元是一种单向的关系，类似抖音的关注。
声明为友元的函数和类可以随意访问自己，但是自己不能访问对方。
一个函数或类可以声明成为多个类的友元。
有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元类的使用：
一个类大量使用另一个类的变量时使用友元类，使用时记得声明和定义分离，还有前置声明。只前置声明用不了类的内部细节。
#include <iostream>
using namespace std;
// 步骤1：前向声明
class A;
class B;
// 步骤2：定义A，声明B为友元
class A {
private:
int _a = 10;
friend class B; // 友元声明
};
// 步骤3：定义B（可访问A的私有成员）
class B {
public:
void printA(A& a) {
cout << "A::_a = " << a._a << endl; // 访问A的私有成员
}
};
// 步骤4：使用
int main() {
A a;
B b;
b.printA(a); // 输出：A::_a = 10
return 0;
}
#include <iostream>
using namespace std;
// 定义类A，并在A中声明B为友元
class A {
private:
int _a = 10;
// 直接声明B为友元（此时B可以是已定义或未定义的，只要后定义B也可）
friend class B;
};
// 直接定义友元类B（与A在同一作用域，无需分离）
class B {
public:
// B可以直接访问A的私有成员
void printA(A& a) {
cout << "A的私有成员：" << a._a << endl; // 合法，因为B是A的友元
}
};
int main() {
A a;
B b;
b.printA(a); // 输出：A的私有成员：10
return 0;
}
#include <iostream>
using namespace std;
// 先定义类B（此时B还不是A的友元，但可以先存在）
class B {
public:
// 这里暂时不能访问A的成员（因为A还未定义）
void printA(A& a); // 仅声明，定义放在A之后
};
// 定义类A，声明B为友元
class A {
private:
int _a = 10;
friend class B; // 声明B为友元，此时B可以访问A的成员
};
// 补全B的成员函数定义（此时A已定义，B是友元，可访问A的私有成员）
void B::printA(A& a) {
cout << "A的私有成员：" << a._a << endl;
}
int main() {
A a;
B b;
b.printA(a); // 输出：A的私有成员：10
return 0;
}
四内部类
• 如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
• 内部类默认是外部类的友元类。
class A
{
private:
static int _k;
int _h = 1;
public:
class B // B默认就是A的友元
{
public:
void foo(const A& a)
{
cout << _k << endl; //OK
cout << a._h << endl; //OK
}
int _b1;
};
};
五匿名对象
对应有名对象
声明：变量名();
int();
特点：
生命周期只在当前一行。
匿名对象可以带参数。
匿名对象具有常性。
const引用会延长匿名对象的生命周期。
缺省值可以给匿名对象。
使用：
class solution
{
public:
int sum_solution(int n)
{
return n;
}
};
int main()
{
cout << solution().sum_solution(10) << endl;
}
六对象拷贝时的编译器优化
• 现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会尽可能减少一些传参和传返回值的过程中可以省略的拷贝。
• 如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新更"激进"的编译器还会进行跨行跨表达式的合并优化。
• linux下可以将下面代码拷贝到test.cpp文件，编译时用 g++ test.cpp -fno-elideconstructors
的方式关闭构造相关的优化。
来看看不同编译器的处理：
这是三种不同的优化：
我给出测试的代码：大家可以去不同的编译器上跑一跑看一下：
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a1(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a1 = aa._a1;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a1 = 1;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
int main()
{
// 传值传参
// 构造+拷贝构造
A aa1;
f1(aa1);
cout << endl;
// 隐式类型，连续构造+拷贝构造->优化为直接构造
f1(1);
// 一个表达式中，连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << endl;
cout << "***********************************************" << endl;
// 传值返回
// 不优化的情况下传值返回，编译器会生成一个拷贝返回对象的临时对象作为函数调用表达
//式的返回值
// 无优化 （vs2019 debug）
// 一些编译器会优化得更厉害，将构造的局部对象和拷贝构造的临时对象优化为直接构造
//（vs2022 debug）
f2();
cout << endl;
// 返回时一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 （vs2019 debug）
// 一些编译器会优化得更厉害，进行跨行合并优化，将构造的局部对象aa和拷贝的临时对象
//和接收返回值对象aa2优化为一个直接构造。（vs2022 debug）
A aa2 = f2();
cout << endl;
// 一个表达式中，开始构造，中间拷贝构造+赋值重载->无法优化（vs2019 debug）
// 一些编译器会优化得更厉害，进行跨行合并优化，将构造的局部对象aa和拷贝临时对象合
//并为一个直接构造（vs2022 debug）
aa1 = f2();
cout << endl;
return 0;
}
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
34
0- 0
已为社区贡献3条内容
所有评论(0)