类和对象（下）

🕗 发布于 2024-10-16 15:07 c++

1.构造函数剩余知识点：

*之前实现构造函数时，初始化成员变量时采用的是函数体内赋值，构造函数初始化还有一种方式，就是初始化列表，以一个冒号开始然后逗号分隔的数据成员列表。每个成员变量后面跟一个原来本该放在括号中的初始值或表达式。

*每个成员变量在初始化成员列表中只能出现一次，语法理解上初始化列表可以理解为每个成员变量定义初始化的地方。

#include <iostream>
using namespace std;
//再探构造函数：
class Date
{
public:
Date(int year, int month, int day)//每个成员定义的地方
:_year(year)//只能初始化一次 
//, _ptr(malloc())//可以跟一个表达式
, _month(month)
, _day(day)
{}
void Print()const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
//整体声明：
int _year;
int _month;
int _day;
};

int main()
{
//对象定义：
Date d1(2024,7,24);
d1.Print();
}

*引用成员变量、const成员变量、没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会报错,因为这三个都是得在定义的时候初始化。

*C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示初始化列表位置进行初始化，否则会编译报错。如果给了缺省值之后没有在main函数中写构造，编译器就会调用这个缺省值去初始化。

#include <iostream>
using namespace std;
//再探构造函数：
class Date
{
public:
void Print()const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
//整体声明：
int _year = 1;//缺省值，没有开辟空间，还是定义。
int _month = 1;//给初始化列表用的
int _day = 1;
//const int _n;//必须在初始化列表完成初始化
};

int main()
{
//对象定义：
Date d1;
d1.Print();

//const int x;//只有一次初始化的机会就是定义的时候，后续没有改变的机会
//x = 1;
}

*尽量使用初始化列表进行初始化，因为那些不在初始化列表初始化的成员也会走初始化列表的途径，如果这个成员在声明位置给了缺省值，初始化列表也会用这个缺省值初始化。如果没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员的默认构造函数，如果没有默认构造会编译报错。

*总结一下就是：每个成员都要走初始化列表。

（1）在初始化列表初始化成员。

（2）没有初始化列表的成员：

a、声明的地方有缺省值就用缺省值。

b、没有缺省值：

x、内置类型：不确定得看编译器，但大概率是随机值。

y、自定义类型：调用默认构造，没有默认构造会编译报错。

（3）引用、const没有默认构造自定义，必须在初始化列表初始化。

*初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表中出现的先后顺序无关，建议声明顺序和初始化列表顺序保持一致。

class A
{
public:
A(int a)
:_a1(a)
,_a2(_a1)
{}
void Pint()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2 = 2;
int _a1 = 2;
};

int main()
{
A aa(1);
aa.Pint();

return 0;
}

上述结果是打印出了1和随机值。由于_a2是先声明的，所以在构造函数里面_a2是先初始化的，用_a1去初始化_a2，此时_a1是随机值，所以最后_a2就是随机值，然后再去初始化_a1，结果是1。

2.类型转换：

*C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数构造函数。

*构造函数前面加上explicit就不再支持隐式类型转换。

class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)//先去初始化，_a1是随机值
{}
void Pint()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2 = 2;//先声明的
int _a1 = 2;
};

int main()
{
A aa1(1);
A aa2 = 2;//类型转换
//先用2构造一个临时对象，再用这个临时对象去拷贝构造aa2。
aa2.Pint();

A& raa1 = aa2;
//A& raa2 = 2;//类型转换生成临时变量具有常性，给引用权限放大
const A& raa2 = 2;

return 0;
}

意义：更方便、更简单

假设有一个类A，和一个栈Stack，这时候要用先实例化类A然后放到栈里，就要先调用A的构造函数再去传用A实例化后的变量。

class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)//先去初始化，_a1是随机值
{}
void Pint()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2 = 2;//先声明的
int _a1 = 2;
};
class Stack
{
public :
void Push(const A& a)
{
//...
}
private:
A _arr[10];
int _top;
};

int main()
{
Stack st;

A aa3(3);//先实例化去调用构造
st.Push(aa3);//再传A去放入栈中


return 0;
}

但是呢这下面一步可以利用隐式类型转换改写，比如我要构造的值是3，那么就可以：

st.Push(3);

上面是单参数的，多参数的如下：

//多参数的转换：C++11支持
A aa4 = { 1,1 };
//也意味着支持：
const A& raa5 = { 2,2 };
//插入操作：
st.Push(aa4);
//也就意味着：
st.Push({ 2,2 });

3传过去就会产生一个临时对象。

3.static成员：

*用static修饰的成员变量称之为静态成员变量，静态成员变量一定要在类当中进行初始化。

*静态成员变量为所有类对象共享，不属于某个具体的对象，不存在对象中，存放在静态区。

class A
{
public:
A()
{
_scount++;
}
A(const A& a)
{
_scount++;
}
~A()
{
_scount--;
}
private:
//类里面声明：
static int _scount;
};

//类外面初始化：
int A::_scount = 0;

int main()
{
cout << sizeof(A) << endl;

return 0;
}

输出的结果是A类的大小，可以看出A类的大小是1，没有包含_scount的值。

*用static修饰的成员函数称之为静态成员函数，静态成员函数没有this指针。

*静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。

class A
{
public:
A()
{
_scount++;
}
A(const A& a)
{
_scount++;
}
~A()
{
_scount--;
}
static int GetACount()//用于访问私有静态成员变量，没有this指针
{
_a++;//不能操作访问非静态成员，因为要this指针
return _scount;
}
private:
//类里面声明：
static int _scount;
int _a;//非静态成员
};

下面利用静态成员变量来记录对象的创建。

class A
{
public:
A()
{
_scount++;
}
A(const A& a)
{
_scount++;
}
~A()
{
_scount--;
}
static int GetACount()//用于访问私有静态成员变量，没有this指针
{
return _scount;
}
private:
//类里面声明：
static int _scount;
};

//类外面初始化：
int A::_scount = 0;

int main()
{
//cout << sizeof(A) << endl;

//利用_scount来记录对象：
cout << A::GetACount() << endl;//此时没有对象，_scount为0
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;//构造两次，拷贝构造一次，为3
return 0;
}

*非静态的成员函数可以访问任意静态成员变量和静态成员函数。

static int GetACount()//用于访问私有静态成员变量，没有this指针
{
_a++;//不能操作访问非静态成员，因为要this指针
return _scount;
}
//非静态的可随便访问静态的
void  Func()
{
cout << _scount << endl;
cout << GetACount() << endl;
}

*突破类域就可以访问静态成员，可以通过类名::静态成员或者对象::静态成员来访问静态成员变量和静态成员函数。

4.友元：

*友元提供了一种突破类访问限定符封装的方式，友元分为友元函数和友元类，在函数声明和类声明前面加上“friend”，并且把友元声明放到一个类里。

*外部友元函数可访问类的私有和保护成员，友元函数只是一种声明，不是类的成员函数。

*友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

*一个函数可以是多个类的友元函数。

class A
{
//友元声明：
friend void Func(const A&& aa, const B&& b);
private:
int _a1 = 1;
int _a2 = 2;
};

class B
{
//友元声明：
friend void Func(const A&& aa, const B&& bb);
private:
int _b1 = 3;
int _b2 = 4;
};

void Func(const A&& aa, const B&& bb)
{
cout << aa._a1 << aa._a2 << endl;
cout << bb._b1 << bb._b2 << endl;
}

*友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。

class A
{
//友元声明：
friend class B;//这样子B类中的成员函数就都可以访问A类的私有成员了。
private:
int _a1 = 1;
int _a2 = 2;
};

class B
{
public:
void Func1(const A&& aa)
{
cout << aa._a1 << endl;
cout << _b1 << endl;
}
void Func2(const A&& aa)
{
cout << aa._a2 << endl;
cout << _b2 << endl;
}
private:
int _b1 = 3;
int _b2 = 4;
};

*友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但B类不是A类的友元。

*友元类关系不能传递，如果A是B的友元，B是C的友元，但A不是C的友元。

*有时候提供了便利，但是友元会增加耦合度，破坏了封装，不宜多用。

5.内部类：

*如果一个类定义在另一个类的内部，这个类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，它只受外部类类域限制和访问限定符限制，所以外部类定义的对象不包含内部类。

class A
{
private:
static int _k;
int _h = 1;
public:
class B//B默认是A的友元
{
public:
void foo(const A& a)
{
//cout << _k << endl;
//cout << a._h << endl;
}
private:
int _b = 1;
};
};

int main()
{
cout << sizeof(A) << endl;
}

代码的运行结果是4，也就是说类A里面包含的只有_h而没有_b，_b是独立出来的。

*内部类默认是外部类的友元类。

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

6.匿名对象：用类型（实参）定义出来的对象叫做匿名对象。之前定义的叫做有名对象。匿名对象生命周期中只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

class A
{
private:
static int _k;
int _h = 1;
public:
class B//B默认是A的友元
{
public:
void foo(const A& a)
{
//cout << _k << endl;
//cout << a._h << endl;
}
private:
int _b = 1;
};
};

int main()
{
A aa1;

A aa2();
//不能这么定义对象，因为编译器不知道是函数声明还是定义对象。
cout << sizeof(A) << endl;

A();//匿名对象
A(1);
}

7.对象拷贝时的编译器优化：(了解就好了）

*现代编译器为了尽可能提高程序的效率，在不影响正确率的前提下会尽可能的减少一些传参和返回值过程中可以省略的拷贝。

*如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理，当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新更“激进”的编译器还会进行跨行跨表达式的合并优化。

class A
{
public:
A(int a = 10)
:_a1(0)
{
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;
}
void Print()
{
cout << "A::Print->" << _a1 << endl;
}
A& operator++()
{
++_a1;
}
private:
int _a1 = 1;
};

A f2()
{
A aa(1);//构造
++aa;
return aa;//拷贝构造
}//析构
int main()//但是aa会被优化掉，直接消失。
{
f2().Print();//用临时对象调用Print
cout << endl;//临时对象析构
cout << "**********" << endl;
}

原文地址：https://blog.csdn.net/2301_80460166/article/details/142734054

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：使用 React Query 时还需要 Redux 吗？| 状态管理 2024
下一篇：嵌入式开发学习日记——数据结构基础

TikTok直播专线带宽怎么选？TikTok专线带宽选购指南
TikTok直播在当下越来越受欢迎。TikTok直播对网络的要求还是比较高的，为了确保直播质量，选择适当的TikTok直播专线带宽至关重要。下面我们来看看如何根据不同的直播需求选择合适的直播专线带宽。
阅读更多2024-10-17
海思hi3536c配置内核支持USB摄像头
内核更新后，系统启动，插上摄像头，在dev下面就可以看到video0设备了。选择Multimedia support，并进入。选择Media USB Adapters，并进入。内核版本：linux-3
阅读更多2024-10-17
FFMPEG录屏（17）--- 使用 DwmRegisterThumbnail 捕获指定窗口图像数据
通过 [] API，我们可以高效地捕获指定窗口的图像数据。本文介绍了如何检查 DWM 支持、注册缩略图、更新缩略图属性以及捕获窗口图像数据的完整过程。希望这篇文章对您有所帮助。
阅读更多2024-10-17
IJKPlayer源码分析-整体结构
功能：完成IJK播放环境的初始化，创建IjkMediaPlayer本地结构对象，然后初始化平台相关的解码器和音视频的处理例程，同时，把IjkMediaPlayer保存到JAVA端对应类的_mNativ
阅读更多2024-10-17
sqoop导入sql数据权限不够
报错信息："Host 'master' is not allowed to connect to this MySQL server"
阅读更多2024-10-17
C++-list模拟实现
##模拟实现list需要先看源码，了解基本的结构和设计思路###list底层是双向链表，每一个节点包含数据域和两个指针（一个指向后一个节点，一个指向前一个节点），并且list带有一个哨兵位；###链表
阅读更多2024-10-17
《使用Gin框架构建分布式应用》阅读笔记：p52-p76
书上使用ioutil包读取JSON文件，但是从go 1.16 开始，不再推荐使用ioutil，应该使用os 包。无，第二章除了食物名，整体来说生词比较少。
阅读更多2024-10-17
发票闪印 v3.1.10 免费电子PDF发票批量打印工具绿色版
发票闪印（电子发票打印工具）是一款免费的PDF发票打印辅助软件由远景论坛会员 by li495388759 开发制作，因为单位有很多电子发票需要打印，每次打印都要用reader阅读器打开，选打印，选份
阅读更多2024-10-17
【OpenCV】（八）—— 腐蚀和膨胀
本文介绍opencv中的腐蚀和膨胀，包括其衍生操作开运算闭运算和黑帽礼帽
阅读更多2024-10-17
PostgreSQL Windows系统初始化、登录、创建用户及数据库
完成以上步骤后，你就可以使用新创建的用户登录到。服务器，并且可以在新创建的数据库中进行操作。安装完，可以去服务里面查看，并启动该服务；服务名可自定义，此处服务名为。参数指定了要登录的用户名，这条命令将
阅读更多2024-10-17

类和对象（下）

相关文章