【C++】类与对象（三）

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;//第一次赋值
_year = 2022;//也可以第二次赋值
//....
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};

1.2 初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式

测试代码：

class Date
{
public:
//构造函数
Date(int year, int month, int day)
: _year(year)//初始化列表
, _month(month)
, _day(day)
{

}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d(2024,9,29);
return 0;
}

注意：

（1）每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

测试代码：

class Date
{
public:
//构造函数
Date(int year, int month, int day)
: _year(year)//初始化列表
, _year(year)//error
, _month(month)
, _day(day)
{

}
private:
int _year;
int _month;
int _day;
};

编译报错：

在这里插入图片描述

（2）类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时)

a. 引用成员变量

引用类型的变量在定义时就必须给其一个初始值，所以引用成员变量必须使用初始化列表对其进行初始化

测试代码：

class Date
{
public:
Date(int year, int month, int day)
{
_year = year;//是赋值
_month = month;
_day = day;
}
private:
int& _year;//引用，必须初始化，不初始化error
int _month;
int _day;
};

编译失败，必须使用初始化列表初始化

b. const 成员变量

被const修饰的变量也必须在定义时就给其一个初始值，也必须使用初始化列表进行初始化

测试代码：

class Date
{
public:
Date(int year, int month, int day)
//：_year(year) //true
{
_year = year;
_month = month;
_day = day;
}
private:
const int _year;//const 成员，必须在列表初始化
int _month;
int _day;
};

编译报错，必须使用初始化列表初始化

c. 自定义类型成员(且该类没有默认构造函数时)

若一个类没有默认构造函数，那么我们在实例化该类对象时就需要传参对其进行初始化，所以实例化没有默认构造函数的类对象时必须使用初始化列表对其进行初始化

在这里再声明一下，默认构造函数是指不用传参就可以调用的构造函数：

1.我们不写，编译器自动生成的构造函数
2.无参的构造函数
3.全缺省的构造函数

测试代码：

class Date//该类没有默认构造函数 
{
public:
Date(int year)
{
_year = year;
}
private:
int _year;
};

class A
{
public:
A()
//:_d(2021) //必须使用初始化列表对其进行初始化,true
{
_d = 2022;//error
}
private:
Date _d; //自定义类型成员（该类没有默认构造函数）
};

编译报错：

在这里插入图片描述

（3）尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

对于内置类型，使用初始化列表和在构造函数体内进行初始化实际上是没有差别的
对于自定义类型，使用初始化列表可以提高代码的效率

（4）成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

测试代码：

class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)
{}
void Print() {
cout << _a1 << " " << _a2 << endl;
    }

private:
int _a2;//与声明顺序有关，与初始化列表顺序无关
int _a1;
};
int main() 
{
A aa(1);
aa.Print();
}

运行结果 a1 为 1，a2 为随机值
声明顺序先 a2 和a1 ，初始化顺序也一样（不要看写的顺序)，可以调试看看。
在这里插入图片描述

1.3 explicit 关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用

先看测试代码：

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1) //单个参数的构造函数
:_year(year)
{}
void Print()
{
cout << _year << endl;
}
private:
int _year;
};
int main()
{
Date d0(2022);
d0.Print();
Date d1 = 2022; //也支持该操作，隐式类型转换
d1.Print();
return 0;
}

Date d1 = 2022 这种单参数写法是 C++98 就已经支持了，Date d1 = 2022 等价于以下两句（先构造，再拷贝构造）

Date tmp(2021); //先构造
Date d1(tmp); //再拷贝构造

在早期的编译器中，当编译器遇到 Date d1 = 2022 这句代码时，会先构造一个临时对象 tmp，再用临时对象 tmp 拷贝构造d1
但是现在的编译器已经做了优化，当遇到 Date d1 = 2022 这句代码时，会按照 Date d0(2022) 这句代码处理（只有构造，优化掉了拷贝构造），Date d1 = 2022 这就叫做隐式类型转换

在C++入门的博客就已经提过隐式类型转换了（常引用，关于权限那里提过），这里再提一下：

int a = 10;
double b = a; //隐式类型转换
const double& rb = b; //隐式类型转换

对于 Date d1 = 2022 这种写法可读性是不好的==，我们若是想禁止单参数构造函数的隐式转换，可以用关键字 explicit 来修饰构造函数==

测试代码：

class Date
{
public:
explicit Date(int year = 1) //explicit 修饰，不再支持隐式类型转换
:_year(year)
{}
void Print()
{
cout << _year << endl;
}
private:
int _year;
};
int main()
{
Date d0(2022);
d0.Print();
Date d1 = 2022; //explicit 修饰，不再支持隐式类型转换
d1.Print();
return 0;
}

编译出错：

在这里插入图片描述

在 C++11 语法已经支持多参数构造了，比如 Date d1 = 2022,10,13，在 2011 年之前的编译器都不支持多参数

测试代码：

class Date
{
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{}
void Print()
{
cout << _year << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d0(2022, 10, 13);
d0.Print();
Date d1 = { 2022, 10, 13 }; //C++11支持多操作，隐式类型转换，用一对 {} 括住
d1.Print();
return 0;
}

二、static成员

2.1 static 概念

声明为 static 的类成员称为类的静态成员，用 static 修饰的成员变量，称之为静态成员变量
用 static 修饰的成员函数，称之为**静态成员函数。**静态成员变量一定要在类外进行初始化

2.2 static 的特性

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

测试代码：

class A
{
private:
static int _a;
};

int main()
{
A aa;
A bb;
A cc;
//....
//A类所创建的所有对象都共享静态成员 _a
return 0;
}

静态成员变量

所有对象共享同一份数据
编译阶段分配内存
类内声明，类外初始化操作（类外定义），记得一定要初始化
定义时不添加static关键字

测试代码：

class A
{
private:
static int _a;//声明
};
_a=100;  //这样写，就是全局变量
int A::_a = 0;//静态成员定义（初始化）

int main()
{
A aa;
return 0;
}

类静态成员访问

当静态成员变量为公有时，有以下几种访问方式：

测试代码：

class A
{
public:
static int _n; //公有
};
// 静态成员变量的定义初始化
int A::_n = 0;
int main()
{
A aa;
cout << aa._n << endl; //1.通过类对象突破类域进行访问
cout << A::_n << endl; //2.通过类名突破类域进行访问
cout << A()._n << endl; //3.通过匿名对象突破类域进行访问

return 0;
}

当静态成员变量为私有时，有以下几种访问方式：

测试代码：

class A
{
public:
    //含有静态成员变量的类，一般含有一个静态成员函数，用于访问静态成员变量。
static int GetN()//静态成员函数，获取 _n
{
return _n;
}
private:
static int _n; //私有
};
// 静态成员变量的定义初始化
int A::_n = 0;

int main()
{
A aa;
cout << aa.GetN << endl; //1.通过类对象突破类域进行访问
cout << A::GetN << endl; //2.通过类名突破类域进行访问
cout << A().GetN << endl; //3.通过匿名对象突破类域进行访问

return 0;
}

静态成员函数

没有隐藏的this指针，不能访问任何非静态成员
所以对象共享同一个函数
测试代码：

class A
{
public:
static void Print()
{
//cout << _a << endl; //error，静态成员函数不能访问非静态成员
cout << _n << endl; //静态成员函数可以访问静态成员变量
}
private:
int _a; //非静态成员
static int _n; //静态成员
};

静态成员也是类的成员，受public、protected、private 访问限定符的限制

当静态成员变量设置为 private 时，尽管我们突破了类域，也不能直接对其访问，要通过间接访问才可以访问到，比如：静态成员函数 static int GetN()

【面试题】

1、静态成员函数可以调用非静态成员函数吗？

答：不可以。因为非静态成员函数的第一个形参默认为this指针，而静态成员函数中没有this指针，故静态成员函数不可调用非静态成员函数

2、非静态成员函数可以调用类的静态成员函数吗？

可以。因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

3、static 的作用C 语言、C++ ？

在C 语言：

static 修饰局部变量，改变了局部变量的生命周期　(本质上是改变了变量的存储类型)，局部变量由栈区转向静态区，生命周期同全局变量一样
static 修饰全局变量，使得这个全局变量只能在自己所在的文件内部使用，而普通的全局变量却是整个工程都可以使用
static 修饰函数，使得函数只能在自己所在的文件内部使用，本质上 static 是将函数的外部链接属性变成了内部链接属性 (同 static 修饰全局变量)

为什么全局变量能在其它文件内部使用 ？

因为全局变量具有外部链接属性；但是被 static 修饰后，就变成了内部链接属性，其它源文件不能链接到这个静态全局变量了

在C++：

修饰成员变量和成员函数，成员变量属于整个类，所有对象共享，并且修饰的成员函数没有 this 指针

4、计算程序中创建出了多少个类对象

代码：

class A
{
public:
A() 
{ 
++_scount;
}
A(const A& t)
{ 
++_scount; 
}
~A() 
{ 
--_scount; 
}

static int GetACount() 
{ 
return _scount; 
}

private:
static int _scount;
};

int A::_scount = 0;

int main()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;

return 0;
}

结果是：0 ，3 ，调用了两次构造函数和一次拷贝构造函数

5、类的大小

代码：

class A
{
private:
static int _n;
int _a;
};
int main()
{
cout << sizeof(A) << endl;
return 0;
}

结果为 4，静态成员_n是存储在静态区的，属于整个类，也属于类的所有对象。所以计算类的大小或是类对象的大小时，静态成员并不计入其总大小之和

补充 static const

在C++中，类内部只能初始化静态整数类型（如int、float等）的静态常量成员变量，而不能初始化静态字符串类型的静态常量成员变量。

想在类内部初始化一个静态字符串类型的静态常量成员变量，可以使用以下方式：

class MyClass {
public:
    static const std::string default;
};

const std::string MyClass::default = "aaa";

三、友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用，友元分为：友元函数和友元类

3.1 友元函数

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

说明:

友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

全局函数做友元（当然也可以写一个类的内部成员函数作为友元）

class A
{
// 声明是A的友元类
friend void Print(A& p);
public:
A(int a = 0)
:_a(a)
{}
private:
int _a;
};
void Print(A& p)
{
cout<<"_a="<<_a<<endl;//访问类的私人成员
}

3.2 友元类

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

测试代码：

class A
{
// 声明B是A的友元类
friend class B;
public:
A(int a = 0)
:_a(a)
{}
private:
int _a;
};

class B
{
public:
void Test(A& a)
{
// B类可以直接访问A类中的私有成员变量
cout << a._a << endl;
}
};

说明：

友元关系是单向的，不具有交换性。

比如之前Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递

比如，如果B是A的友元，C是B的友元，则不能说明C时A的友元。

友元关系不能继承，在继承位置再详细介绍。

-------------------我是分割线------------------

四、内部类

概念：如果一个类定义在另一个类的内部（类中类），这个内部类就叫做内部类。

外部类的对象不可以访问内部类的成员。
内部类可以通过外部类的对象参数来访问外部类中的所有成员。
即内部类就是外部类的友元类，但是外部类不是内部类的友元
内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
sizeof(外部类) = 外部类，和内部类没有任何关系

测试代码：

class A
{

public:
class B // B天生就是A的友元
{
public:
void f(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
}
};

private:
static int k;
int h;
};

int A::k = 1;

int main()
{
A::B b;
b.f(A());//这个是匿名对象

return 0;
}

sizeof(外部类) = 外部类，和内部类没有任何关系

测试代码：

class A //外部类
{
public:
class B //内部类
{
private:
int _b;
};
private:
int _a;
};
int main()
{
cout << sizeof(A) << endl; //外部类的大小
return 0;
}

结果为 4，与内部类的大小无关。

五、匿名对象

测试代码：

class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};

int main()
{
//A aa1();
// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义

A();//匿名对象
// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数

//A aa2(2);//有名（aa2）对象

return 0;
}

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

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的

class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};

void f1(A aa)
{}

A f2()
{
A aa;
return aa;
}

int main()
{
// 传值传参
A aa1;
f1(aa1);
cout << "------分割线1-------" << endl;

// 传值返回
f2();
cout << "------分割线2-------" << endl;

// 隐式类型，连续构造+拷贝构造->优化为直接构造
f1(1);
cout << "------分割线3-------" << endl;

// 一个表达式中，连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << "------分割线4-------" << endl;

// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
A aa2 = f2();
cout << "------分割线5-------" << endl;

// 一个表达式中，连续拷贝构造+赋值重载->无法优化
aa1 = f2();


return 0;
}

--------------------- END ----------------------

「 作者 」 代码探秘者
「 更新 」 2024.9.30

原文地址：https://blog.csdn.net/2301_79090563/article/details/142645820

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

上一篇：如何创建一个包含多个列的表？
下一篇：CF 2013 E

FPGA时序分析和约束学习笔记（2、FPGA时序传输模型）
Tsu建立时间：目的寄存器自身的特性决定，在时钟上升沿到达其时钟接口时，其数据输入端（D）的数据必须提前Nns稳定下来，否则就无法确保数据正确存储。Skew时钟偏斜：时钟从源端口出发，到达目的寄存器和
阅读更多2024-10-06
打卡第一天 B2005 字符三角形
【代码】打卡第一天 B2005 字符三角形。
阅读更多2024-10-06
IEC104规约的秘密之六----配置参数k，w
w是通讯前就已经配置好的一个固定值，范围是1~32767，表示收到对方w帧后就必须给对方一个应答了，表示这些帧我已经收到了，如果不给对方应答，对方会认为自己发的这些帧没有收到，后续可以采用其他机制来让
阅读更多2024-10-06
算法闭关修炼百题计划（二）
给你一个整数数组 nums，返回数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。根据这一点，用哈希表分组，把排序后的字符串当做key，原字
阅读更多2024-10-06
C# 数组和集合
数组是具有相同数据类型的一组数据的集合。数组中的每一个变量称为数组的元素，数组能够容纳元素的数量称为数组的长度。
阅读更多2024-10-06
UE5 小地图的基础方法
UE5 平面小地图的基础方法，后续继续添加
阅读更多2024-10-06
第33次CCF计算机软件能力认证【T1~T3】：词频统计、相似度计算、化学方程式配平
CCF计算机软件能力认证，前三题包括大模拟、高斯消元、枚举等操作
阅读更多2024-10-06
洛谷刷题 P1042 [NOIP2003 普及组] 乒乓球
接着我们对二维数据循环访问处理数据，对11制和21制一轮结束情况做讨论，注意if，else if的使用（是并行情况还是多选一情况）那么数据存储我们可以用C++的vector<char>，或
阅读更多2024-10-06
spring boot发送邮件
spring boot整合mail发送邮件
阅读更多2024-10-06
银行数字化转型导师坚鹏：2025年银行开门红蓄客方法及案例
银行营销、运营、数字化营销、数字化运营、网点负责人、中高层干部等相关人员。3、第三个难题：银行需要做哪些准备工作？4、第四个难题：如何抛开疑虑、放手去做？1、第一个难题：银行锁定哪些目标客户？2
阅读更多2024-10-06

【C++】类与对象（三）

一、再谈构造函数

1.1 构造函数体赋值

1.2 初始化列表

1.3 explicit 关键字

二、static成员

2.1 static 概念

2.2 static 的特性

三、友元

3.1 友元函数

3.2 友元类

四、内部类

五、匿名对象

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

相关文章