C++入门☞关于类的一些特别知识点

美丽的神话 · 前天 01:59

涉及的关于类中的默认成员函数的知识点可以看我的这篇博客哦~
C++入门必须知道的知识☞类的默认成员函数，一文讲透+运用
目次
初始化列表
范例转换
static成员
友元
内部类
匿名对象
对象拷贝时的一些编译器的优化

初始化列表
我们知道类中的构造函数的使命是完成对象的初始化，使用构造函数完成初始化的方式除了在函数体内对成员变量进行赋值的方式，如下：

class Date
{
public:
// 构造函数
Date(int year, int month, int day)
{
// 函数体内赋值初始化
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};

复制代码

还有一种方式可以进行初始化——初始化列表
初始化列表的格式：

以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值大概表达式
比如上面的构造函数就可以写成下面的样子：

class Date
{
public:
// 初始化列表的形式
Date(int year,int month,int day)
:_year(year)
,_month(month)
,_day(day)
{}
private:
int _yeaer;
int _month;
int _day;
};

复制代码

两种初始化的区别：
使用函数体内赋值的方式时，成员变量会先辈行默认初始化，然后再在构造函数体内被赋值。也就是在函数体内被赋值时不能称为"初始化"，只能称为"赋值"，初始化只能进行一次，而构造函数体内可以多次赋值；
假如用初始化列表，则直接跳过默认初始化步骤，一步到位完成初始化
默认初始化：指当对象被创建时，假如没有显式指定初始值，编译器会自动进行的初始化运动。具体运动取决于成员变量的范例。具体运动如下：

内置范例（如 int, double, 指针等）：
- 假如变量在全局作用域（或静态存储区），默认初始化为 0/nullptr。
- 假如变量在局部作用域（如函数内、类构造函数体内），不初始化，值是未定义的（垃圾值）。
类范例（如 std::string, 自定义类）：
- 调用该类的默认构造函数（假如没有默认构造函数，会编译报错）。

两种方式在面临自定义范例的初始化时，还会有效率的差别，初始化列表的效率更高：
使用函数体内赋值的方式，会先去调用自定义范例的构造函数，然后再调用赋值重载将构造的值赋值给成员变量
  使用初始化列表的方式，对于自定义范例只会调用一次拷贝构造函数一次性完成初始化
  初始化列表的注意事项：

1、每个成员变量在初始化列表中只能出现一次（即初始化只能初始化一次）
  2、类中包罗以下成员时，它们的初始化必须放在初始化列表位置进行（否则编译报错）：

引用成员变量（因为引用在定义初始化时必须赋值，且不能更改引用的对象）
const修饰的成员变量（const的原因与引用类似）
自定义范例的成员变量，且该成员变量的类没有默认构造函数时（因为使用函数体内的方式时，对于自定义范例，会先去调用其构造函数）

3、成员变量在类中的声明次序就是在初始化列表的初始化次序，与其在初始化列表中的位置次序无关（★），所以建议初始化列表的次序和声明的次序同等
关于第三条：如下述代码，会得到错误的结果，因为虽然初始化列表中的次序是先初始化_a，再用_a的值初始化_b，看着是没错，但是因为成员变量声明时，是先声明的_b，再是_a，所以初始化时会先初始化_b，而不是_a，也就是初始化次序只和声明的次序相干，和初始化列表中的次序无关，但是因为_a还未初始化，所以_b的值就会是随机数

class A
{
public:
// 初始化列表
A(int a)
:_a(a)
,_b(_a+1)
{}
private:
int _b;
int _a;
};

复制代码

别的，C++11还支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有表现在初始化列表初始化的成员使用的，如：

class A
{
public:
A(int a)
:_a1(a)
{}
private:
int _a2 = 2;
int _a1;
};

复制代码

此时，_a2初始化后的值就是2，相称于_a2也走了初始化列表，只不过用的声明时给的缺省值进行初始化，_a1初始化后的值就是传给参数a的值
总结：
尽量使用初始化列表初始化，因为无论是否表现写初始化列表，每个构造函数都有初始化列表；⽆论是否在初始化列表表现初始化，每个成员变量都要走初始化列表初始化，假如这个成员在声明位置给了缺省值，初始化列表就会用这个值进行初始化。假如你没有给缺省值，那么编译器对其的初始化是不确定的，且对于自定义范例，使用初始化列表的方式会更加高效一点
成员变量初始化思维导图：

范例转换

C++支持内置范例隐式范例转换为类范例的对象，必要有相干内置范例为参数的构造函数
如下：使用一个int范例的值构造了一个A范例的对象，其中发生了隐式范例转换，将int范例转为自定义范例A

class A
{
public:
// 以int类型为参数的相关构造函数
A(int a)
:_a(a)
{}
private:
int _a;
};
int main()
{
// 使用int类型的1构造了一个A类型的对象
A b(1);
return 0;
}

复制代码

explicit关键字
但是上述的隐式范例转换，假如你不想让它发生可以使用explicit关键字对构造函数进行修饰，那么这种隐式范例就会被禁止

// 此时再想用一个数字去构造A类型的对象就会编译报错
class A
{
public:
// 以int类型为参数的相关构造函数
explicit A(int a)
:_a(a)
{}
private:
int _a;
};

复制代码

对于内置范例隐式范例转换构造自定义范例时，相干内置范例的构造函数必须要有，且必要包管传入该内置范例参数时，可以构造出一个对象
除了内置范例和类范例的隐式范例转换，类范例的对象之间也可以隐式转换，必要相应的构造函数的支持
如下方的将A范例的对象隐式范例转换为B范例的对象进行构造，构造出一个临时对象用来拷贝构造B范例的对象b，但是编译器会优化，所以就酿成了直接用A范例的对象构造出了一个B范例的对象，但这个过程是因为有相干范例参数的构造函数支持才完成的

class A
{
public:
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{}
int Get() const
{
return _a1 + _a2;
}
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
public:
// 临时对象具有常性，所以需要用const接收
B(const A& a)
:_b(a.Get())
{}
private:
int _b = 0;
};
int main()
{
// { 2,2 }构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造a
// 编译器遇到连续构造+拷⻉构造->优化为直接构造
A a = { 2,2 }; // C++11之后才⽀持的多参数转化
// a 隐式类型转换为b对象
// 原理跟上⾯类似
B b = a;
return 0;
}

复制代码

static成员

定义：
被static修饰的成员称为static成员，也叫类的静态成员

静态成员也是类的成员，受public、protected、private访问限定符的限制
突破类域可以访问静态成员，可以通过类名::静态成员 大概 对象.静态成员 来访问静态成员变量和静态成员函数

  由static修饰的成员变量称为静态成员变量，由static修饰的成员函数称为静态成员函数。
  静态成员变量：

静态成员变量一定要在类外进行初始化，即不在构造函数初始化
  静态成员变量为类的全部对象共享，不属于某个具体的对象，不存在对象中，存放在静态区
  静态成员变量不能在声明位置给缺省值初始化，因为缺省值是给构造函数初始化列表初始化的，静态成员变量不属于某个对象，不走构造函数的初始化列表
  静态成员函数：

静态成员函数没有this指针
  静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针
  非静态成员函数可以访问恣意的静态成员变量和静态成员函数
  场景：统计一个类实例化了多少个对象——使用静态成员变量

#include<iostream>
using namespace std;
class A
{
public:
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() << "个A类型对象" << endl;
return 0;
}

复制代码

在A范例的构造函数中使用静态成员变量count++进行计数，则每初始化一个对象就会对其进行一次++，最终就会得到实例化出的对象个数，同时注意count变量是在类外进行初始化的，只是在类内声明，且在访问静态成员时都使用了类域::静态成员变量的方式(A::count、A::getCount)
上方代码，假如黑白静态的成员函数getCount()的话，就通过对象.静态成员函数的方式得到静态成员变量count的值

// 非静态成员函数
int getCount()
{
return count;// 返回静态成员变量
}
// 其余代码一致....
int main()
{
A a1;
A a2;
A a3;
cout << "创建了"<< a3.getCount() << "个A类型对象" << endl;
return 0;
}

复制代码

友元

定义：
友元分为友元函数和友元类，在一个类里，给函数声明大概类的声明前面加上friend的修饰，则称其为类的友元函数大概友元类，成为类的友元后可以访问类中的私有成员和保护成员
友元类：

class A
{
// 友元声明，B这个类变成A的友元类
friend class B;
private:
int _a1 = 1;
};
class B
{
public:
void func(const A& aa)
{
// 友元类B就可以访问A类的私有成员
cout << aa._a1 << endl;
cout << _b1 << endl;
}
private:
int _b1 = 3;
};
int main()
{
A aa;
B bb;
bb.func(aa);
return 0;
}

复制代码

成为一个类的友元类后，友元类的全部成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

友元关系是单向的，不具有互换性。（比如上面的B类可以访问A类的私有成员，但是A类就不可以反过来访问B类的非公有成员，因为A类不是B类的友元类）
友元关系不能传递（假如C是B的友元， B是A的友元，则不能说明C时A的友元）
友元关系不能继承（涉及继承知识）

友元函数：

友元函数可以直接访问类的私有成员，它是定义在类外部的平凡函数，不属于任何类，即不属于类的成员函数，但必要在类的内部声明，声明时必要加friend关键字，如下

class Date
{
// 友元函数声明
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
// 自定义Date类的输入输出
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main()
{
Date d;
cin >> d;
cout << d << endl;
return 0;
}

复制代码

  1、友元函数可以在类定义的恣意地方声明（注意：是在类定义的地方声明，类的定义有声明和定义都在一个文件中实现的方式，也有声明定义分离的方式，假如是分离的方式，要在定义的地方声明友元函数），且它不受任何访问限定符的限制
  2、一个函数可以是多个类的友元函数
  友元提供了一种突破封装的方式，偶然提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用

内部类

定义：
假如一个类定义在另一个类的内部，这个内部的类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：

内部类默认就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的全部成员。但是外部类不是内部类的友元。
内部类可以访问的外部的全部成员中包括外部类的静态成员，不必要外部类的对象/类名来突破类域访问
sizeof(外部类)=外部类，和内部类没有任何关系。

内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要是给B类使用时，可以思量将其设为B类的内部类，假如放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。

匿名对象

定义：
用范例(实参) 定义出来的对象叫做匿名对象，前面我们使用 范例对象名(实参) 格式定义出来的叫有名对象

// 假设有一个名为A的类，且可以用int类型隐式转换初始化
int main()
{
A aa1(1);// 有名对象
A(1);// 匿名对象
}

复制代码

假如A类的构造是可以无参的，那么A类的匿名对象的创建也不可以省略掉括号，否则语法出错

A();// 无参的A类型匿名对象

复制代码

注意：匿名对象的生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以使用匿名对象

匿名对象调用场景：
①成员函数调用：

class Solution {
public:
int Sum_Solution(int n) {
//...
return n;
}
};
int main()
{
// 没有匿名对象时候，需要写两行调用
Solution s1;
cout << s1.Sum_Solution(10) << endl;
// 有了匿名对象直接写成一行调用
cout << Solution().Sum_Solution(10) << endl;
}

复制代码

②函数参数自定义范例，必要给参数缺省值：给匿名对象

void func(A aa = A(1))
{}

复制代码

延长匿名对象生命周期：
引用匿名对象，延长到和引用的生命周期同等，
但是匿名对象和临时对象一样具有常性，要加const

const A& r = A();

复制代码

匿名对象就像一个一次性的事物，用完就可丢~

对象拷贝时的一些编译器的优化

现代编译器会为了尽可能提⾼程序的效率，在不影响正确性的情况下会尽可能减少⼀些传参和传返回值的过程中可以省略的拷贝
假设一个类的定义如下：

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)
{}
int main()
{
// 优化
// 按理这里会先构造临时对象，再把临时对象拷贝构造给aa0
// 但是这里优化成直接用1进行构造了
A aa0 = 1;// 隐式类型转换
cout << endl;
// 优化
// 按理是用1构造一个匿名对象，再把匿名对象拷贝构造给aa
// 隐式类型转换，连续构造+拷贝构造->优化为直接构造
f1(1);
// 优化
// 一个表达式中，连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << endl;
return 0;
}

复制代码

传值返回时的编译器优化：

两次连续的拷贝构造优化成一次拷贝构造

A f2()
{
A aa;
return aa;// 不会返回aa，会用aa创建一个临时对象，返回临时对象
}
// 传值返回的优化
int main()
{
// 按理需要先用返回值aa拷贝构造一个临时对象，再用临时对象拷贝构造aa2
// 优化：两个拷贝构造合二为一为一个拷贝构造
// 更新的编译器优化：直接优化成一次构造,直接用aa的值构造aa2
A aa2 = f2();
cout << endl;
// 按理是返回值aa拷贝构造一个临时对象，再用临时对象赋值拷贝给aa1
// 优化：直接用aa的值赋值拷贝给aa1
A aa1 = 1;
aa1 = f2();
cout << endl;
return 0;
}

复制代码

完

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告

		自动登录	找回密码
密码			立即注册

C++入门☞关于类的一些特别知识点

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块