类和对象竟是这样的（下集）

小灵蛇

已于 2024-04-12 21:46:08 修改

阅读量966

点赞数 33

分类专栏： C嘎嘎文章标签：开发语言 c++

于 2024-03-07 22:50:53 首次发布

本文链接：https://blog.csdn.net/weixin_75172965/article/details/135768800

版权

C嘎嘎专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文详细介绍了C++编程中的初始化列表、构造函数的区别，静态成员的特性和使用，友元的概念，以及编译器在处理拷贝对象时的优化策略。通过实例讲解，帮助读者更好地掌握这些关键概念。

摘要由CSDN通过智能技术生成

一.初始化列表

其实大家可能会问，诶前面不是讲了有构造函数这个东西吗？为什么又要搞一个初始化列表出来。

其实根据其名字可以知道初始化列表是用来初始化的，在构造函数中，其实并不能算是初始化，只能算赋值，因为构造函数可以多次调用，而初始化只能一次。

1.列表格式

列表格式：以一个冒号开始，接着是一个个逗号隔开的成员变量，成员变量后面跟着其相应的一个放在括号里的初始值或表达式。

class Date

{

public:
 Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
 

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

2.注意事项

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

（2）下面几种情况的成员变量只能用初始化列表初始化：

a.引用成员变量

b.const修饰的成员变量

c.自定义类成员变量（且该类没有默认构造函数）

class A
{
public:
    A（int a）
    :_a(a)
    {}
private:
    int _a;
}
class B
{
public:
    B(int a,int b)
    :_obj(a)
    ,_b(b)
    ,_c(10)
private:
    A _obj;//没有默认构造函数
    int& _b;//引用
    const int _c;//const引用
}

（3）尽量使用初始化列表，因为无论你使不使用初始化列表，对于自定义类型变量，都会优先使用初始化列表

#include<iostream>
using namespace std;
class Time
{
public:
	Time(int hour=0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	Date(int day)
	{}
private:
	int _day;
	Time _time;
};
int main()
{
	Date t(1);
}

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

下面我们来做一个小题：

class A

{

public:

        A(int a)

:_a1(a)

,_a2(_a1)

        {}

        void Print()

        {

         cout_a1" "_a2endl;

        }

private:

      int _a2;

       int _a1;

};

int main()

{

A aa(1);

aa.Print();

}

A. 输出1 1

B.程序崩溃

C.编译不通过

D.输出1 随机值

答案是D

为什么呢？

因为在声明时按照的是_a2,_a1的顺序来的，而在初始化列表中是_a1,_a2的顺序来的，按照我们的说法，应该是按照生命的顺序来初始化，所以先初始化_a2，此时_a1还是随机值，所以_a2就是随机值。

3.explicit关键字

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

而加上explicit修饰后，就不能类型转换了。

二.static成员

1.概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用

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

2.特性

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

（2）. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

（3）. 类静态成员即可用类名::静态成员或者对象.静态成员来访问

（4）. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

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

（6）.静态成员函数不可以调用非静态成员函数，非静态成员函数可以调用类的静态成员函数

三.友元

五.匿名对象

直接上代码：

class A
{
public:
 A(int a = 0)
 :_a(a)
 {
     cout << "A(int a)" << endl;
 }
 ~A()
 {
     cout << "~A()" << endl;
 }
private:
 int _a;
};
class Solution {
public:
 int Sum_Solution(int n) {
 //...
 return n;
 }
};
int main()
{
 A aa1;
 // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义

 //A aa1();

 // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，

 // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数

 A();
 A aa2(2);
 Solution().Sum_Solution(10);
 return 0;
}

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

在传参和传返回值的过程中，一般编译器会做一些优化（不同编译器优化可能不同，只是举个普遍现象），减少对象的拷贝：

（1）.连续构造+连续构造-》优化为构造

（2）.一个表达式中，连续构造+拷贝构造-》优化为一个构造

（3）.一个表达式中，连续拷贝构造+拷贝构造-》优化为一个拷贝构造

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 << endl;

 // 传值返回
 f2();
 cout << endl;

 // 隐式类型，连续构造+拷贝构造->优化为直接构造
 f1(1);

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

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

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

总结

好了，到这里今天的知识就讲完了，大家有错误一点要在评论指出，我怕我一人搁这瞎bb，没人告诉我错误就寄了。

祝大家越来越好，不用关注我（疯狂暗示）