【C++】类和对象（下）

【C++】类和对象（下）
天空没有极限，我们的的未来无边！破茧的我会飞翔C++更蔚蓝的明天！

前言

类和对象这次就是最后一篇了，也要告别了，但之前的知识学会了吗？细节多，繁杂需要我们好好去复习思考！

目录

天空没有极限，我们的的未来无边！破茧的我会飞翔C++更蔚蓝的明天！

前言

一、初始化列表

1.什么是初始化列表

2.为什么要初始化列表

1.const修饰的成员变量

2.没有默认构造函数的自定义类型

3.引用类型

二、隐式类型转化

1.单参数的构造函数支持隐式转换（C++98才支持）

2.多参数的构造函数的类型转化

3.explicit关键字

三、static修饰的静态成员

1.static修饰公有成员变量

2.static修饰私有成员变量

四、友元类和友元函数

五、内部类（C++中不重要）

六、匿名对象

七、编译器中的一些优化

总结：

一、初始化列表

1.什么是初始化列表

类的初始化分为在内部的初始化和初始化列表。

对于类，我们要初始化类的成员变量，就需要定义一个对象，这叫做对象实例化，是对象的整体定义。那么要对对象中的每个成员变量定义初始化的话，就要走初始化列表，并且所有成员变量都要先走初始化列表！

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

初始化列表在构造函数的函数头和实现{}的之间，并且成员变量在初始化列表只能出现一次。

日期类：
```
class Date
{
public:
 
   Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
   {}
 
private:
    int _year;
    int _month;
    int _day;
};
```
1.所有成员变量初始化都要先走初始化列表

对于内置类型，如果没有显示的初始化列表，就会用随机值，有显示的初始化列表，则按照初始化列表进行初始化。

对于自定义类型，如果没有显示初始化列表，那么就会调用它的默认构造函数，这个过程都是发生在初始化列表中！

2.初始化列表和函数体内的初始化可以混着来：（但只有初始化列表不能解决的问题）

栈类：
```
class Stack
{
public:
	/*Stack(int capacity = 4)
		:_a((int*)malloc(sizeof(int)*capacity))
		, _top(0)
		, _capacity(capacity)
	{
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
	}*/
 
	// 初始化列表和函数体内初始化可以混着来
	Stack(int capacity = 4)
		: _top(0)
		, _capacity(capacity)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memset(_a, 0, sizeof(int)*capacity);
	}
	
	~Stack()
	{
		cout << "~Stack()" << endl;
 
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
 
	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}
 
private:
	int* _a;  // 声明
	int _top;
	int _capacity;
};
```
Stack(int capacity = 4)
       :_a((int*)malloc(sizeof(int)*capacity)) //初始化列表
       , _top(0)
       , _capacity(capacity)
   {
       if (_a == nullptr)
       {
           perror("malloc fail");
           exit(-1);
       }
   }

但如果需要将初始化完成的动态内存空间进行初始化，那就需要混着来：
   Stack(int capacity = 4)
       : _top(0)
       , _capacity(capacity)
   {
       _a = (int*)malloc(sizeof(int)*capacity);
       if (_a == nullptr)
       {
           perror("malloc fail");
           exit(-1);
       }
       memset(_a, 0, sizeof(int)*capacity);
   }

2.为什么要初始化列表

必须要有初始化列表的三种情况：

1.const修饰的成员变量；2.没有默认构造函数的自定义类型；3.引用类型

1.const修饰的成员变量
```
class A
{
public:
    A()
    {
        _n = 1;
    }
private:
    const int _n;  //声明
};
```
我们知道，const修饰的变量必须初始化，且只能在定义的时候初始化，且只能初始化一次，之后不能修改。

但在这里，对于const修饰的成员变量，没有显示初始化列表，而_n=1;这是在赋值，但n只能在定义的时候初始化，之后不能修改，所以我们必须用到初始化列表！
```
class A
{
public:
    A()
    :_n(1)
    {}
private:
    const int _n;  //声明
};
```
2.没有默认构造函数的自定义类型

栈和队列：
```
 
class Stack
{
public:
     //默认构造
	Stack(int capacity = 4)    //若Stack(int capacity),则没有默认构造
		: _top(0)
		, _capacity(capacity)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memset(_a, 0, sizeof(int)*capacity);
	}
	......
 
private:
	int* _a;  // 声明
	int _top;
	int _capacity;
};
 
class MyQueue {
    public:
    	MyQueue()
    	{}
    
    	void push(int x)
    	{
    		_pushST.Push(x);
    	}
    private:
    	Stack _pushST;   //自定义类型
    	Stack _popST;
    	size_t _size = 0; 
    };
 
int main()
{
   MyQueue q;
}
```
对于自定义类型：自定义类型若初始化列表中无显示的初始化，自定义类型就会调用默认构造函数，若没有默认构造函数，就需要在初始化列表中显示初始化，否则报错！

没有默认构造情况下: 若Stack(int capacity),则没有默认构造
```
class MyQueue {
    public:
    	MyQueue()
         : _pushST(5)
    	 , _popST(5)
    	{}
     ......
    private:
    	Stack _pushST;   //自定义类型
    	Stack _popST;
    	size_t _size = 0; 
    };
```
3.引用类型

引用类型和const修饰的成员变量是一样的，都是能在定义的时候初始化。
```
class A
{
public:
 A(int a)
  :_a(a)
  {}
private:
  int _a=1;//缺省值
};
 
class B
{
public:
   B(int a, int b)
    :_b(a)
    ,_c(b)
    ,_n(10)
   {}
private:
   A _b;  // 没有默认构造函数
   int& _c;  // 引用
   const int _n; // const 
};
```
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后

次序无关：
```
class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}
A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值
```
试一下，选什么？？

声明次序就是其在初始化列表中的初始化顺序

那么先初始化_a2,但因为 ,_a2(_a1)，_a1还没有初始化，所以_a1就是随机值。:_a1(a)到_a1初始化时，把a的值传过去，就是1。选D.

总结：

内置类型：在初始化列表中没有写显式初始化，就会用随机值初始化，若有缺省值，则就会用缺省值，若有显示初始化，则不会用缺省值。

自定义类型成员在初始化列表中，没有显式初始化，且没有默认构造函数，则需要在初始化列表中显示！

二、隐式类型转化

提到隐式类型转化，你有没有想起什么？？（没有就去点击链接回顾一下，引用那块）

int i = 0;

double d = i;(隐式类型转换），不同类型之间会产生一个临时变量

const double& rd = i; 给i起别名，但类型不同，产生临时变量，这时rd是临时变量的别名，临时变量具有常性，不加const会扩大权限。

1.单参数的构造函数支持隐式转换（C++98才支持）
```
class Date
{ 
public:
    Date(int year = 1, int month = 1, int day = 1)
    	: _year(year)
    	, _month(month)
    	, _day(day)
    	{}
private:
    	int _year;
    	int _month;
    	int _day;
};
 
int main()
{
    Date d1(2022);  //调用一次构造函数
    // 隐式类型的转换
    Date d2 = 2022;  //调用一次构造函数，再调用一次拷贝构造
 
    const Date& d5 = 2022; //临时变量具有常性，加const避免扩大权限
 
    Date d3(d1);
    Date d4 = d1;
}
```
把2022传参，调用构造函数创建临时变量，再把创建好的临时变量通过拷贝构造创建d2.

这样就会浪费资源，每创建一个对象，就调用两个函数，若是栈类，得浪费多大内存空间！！

优化：直接变成一个构造函数（后面会讲解）

2.多参数的构造函数的类型转化
```
class Date
{
public:
	// 多参数构造
   //Date(int year, int month=2, int day=2)
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
 
	
private:
	int _year;
	int _month;
	int _day;
};
 
int main()
{
   Date d1(2022,10,20);//构造函数
   Date d2={2022,10,20};//构造加拷贝
   const Date& d3={2022,10,20};//const防止扩大临时变量权限（拷贝加构造）
}
```
他们的过程不一样，但结果是相同的。

3.explicit关键字

explicit修饰构造函数，禁止类型转换，explicit去掉之后，代码可以通过编译。
```
class Date
{
public:
	// 多参数构造
	explicit Date(int year, int month, int day)
		, _month(month)
		, _day(day)
	{}
	
private:
	int _year;
	int _month;
	int _day;
};
 
 
int main()
{
    Date d1(2022, 10, 20);
    Date d2 = {2022,10,20 };
    return 0;
}
```
当然，单参数和多参数的构造函数隐式类型转化加explicit是一样的，加了之后，就不会支持隐式类型转化了。

三、static修饰的静态成员

1.static修饰公有成员变量

如果我想解决一个问题，就是统计一个类到底创建了多少个对象，应该怎么办呢？？

首先想到的是，全局变量？在每创建一个类，count++；但是全局变量不好的地方在于他是公开的，随便别人去修改，这会非常的不好，导致致命错误，不建议使用。

那么就想到了静态变量：静态局部变量，静态全局变量，类静态变量

静态局部变量在函数内定义，但不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。

静态局部变量的生存期虽然为整个源程序，但是其作用域仍与自动变量相同，即只能在定义该变量的函数内使用该变量。退出该函数后，尽管该变量还继续存在，但不能使用它。

静态局部变量，静态全局变量，类静态变量：从始至终都存在，且只存在当前文件。且作用域不同。

类中的静态变量存储在静态区，且作用域是类，属于每一个类的对象，我们访问它可以通过创建类，通过类去访问，也可以使用访问限定符A::N来访问。（前提是静态成员变量）

我们来计算创建了多少对象：
```
class A
    {
    public:
    	A(int a = 0)
    		:_a(a)
    	{
    		++N;
    	}
    
    	A(const A& aa)
    		:_a(aa._a)
    	{
    		++N;
    	}
       static int N;
    private:
    	int _a;
    };
 
  int A::N=0;//静态成员变量只能在类外定义初始化，在类内则会频繁初始化，一直改变值。
 
int main()
{
    A aa1(1); //构造函数
    A aa2 = 2; //构造加拷贝  优化为一个构造函数
    A aa3 = aa1;//拷贝
   cout<
}
```
静态成员变量只能在类外定义初始化，在类内则会频繁初始化，一直改变值。

也验证了，编译器对于隐式类型转换的拷贝构造+默认构造会优化为一个拷贝构造。（如果没有优化就是四个），那我们再试传值返回，传引用返回，返回值，返回引用：
```
void f1(A aa)
{
 
}
 
A f2(A aa)
{
    A b = aa;
    return b;
}
int A::N = 0;
int main()
{
    A aa1(1);
    A aa2 = 2;
    A aa3 = aa1;
    f1(aa2);
    f2(aa2);
    cout << A::N << endl;
}
```
答案是：7，说明传值传参确实会调用一次拷贝构造，返回值也会创建临时变量去调用一次拷贝构造。

2.static修饰私有成员变量

为私有成员变量时：我们在类外使用，则需要通过类内的成员函数才可以访问到：
```
class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        ++N;
    }
 
    A(const A& aa)
        :_a(aa._a)
    {
        ++N;
    }
 
    int GetN()
    {
       return N;
    }
private:
    int _a;
    static int N; // 声明
};
 
int main()
{
  A aa();
  cout<GetN()<
}
```
那么访问静态私有变量就需要创建一个对象，可不可以不创建就访问呢？

通过定义静态成员函数，就可以不定义对象直接调用，静态成员变量是没有this指针的，所以也不能调用其他成员变量。静态成员函数不需要this指针，是因为静态成员变量是类的所有对象共享的
只有那么一个，所以不管哪个对象调用返回的是同一个。所以静态不能访问非静态，所以静态成员函数是跟静态成员变量配合起来用的。
```
class A
{
public:
   ......
 
    static int GetN()
    {
       return N;
    }
private:
    int _a;
    static int N; // 声明
};
 
int main()
{
  cout<GetN()<
}
```
当然，私有变量只能获取，不能修改。

当限定了类创建的存储区域时：规定只能存储在栈区，那么创建在堆区等等的创建方式就不可以使用，但是只要创建类，就会调用类的构造函数，为了把对象创建在栈区，就需要把构造函数设置为私有，通过成员函数来访问。但是通过公有的成员函数访问私有构造函数，进而在成员函数中创建类，返回类。
```
 
class A
    {
    public:
    	static A GetObj(int a = 0)
    	{
    		A aa(a);
    		return aa;
    	}
    
    private:
    	A(int a = 0)
    		:_a(a)
    	{}
    
    private:
    	int _a;
    };
    
    int main()
    {
    	//static A aa1;  //静态区
    	//A* ptr = new A;  //堆区
    	//A aa2;   //栈区
        //A aa3=Getobj(10);  错误
    	A aa3 = A::GetObj(10);
    	return 0;
    }
```
但是最重要的一个问题是：你要调用函数，你就得创建对象，你要创建对象，你就得先调用函数，这不是？？？完了！！

那么这时，static作用就大了，因为设置为static静态成员函数，可以不用创建类就调用！

四、友元类和友元函数

在类和对象中，我们就已经接触过了，友元函数作用就是，偷家！！
```
class Date
{
  friend inline ostream& operator<<(ostream& out, Date& d)
    ...
private:
   int _year;
   int _month;
   int _day;
};
 
 
inline ostream& operator<<(ostream& out, Date& d)
{
	out << d._year << " " << d._month << " " << d._day << endl;
	return out;
}
```
当定义在类外的函数要使用私有变量时，就可以通过友元函数来访问。友元函数它就是一个普通函数，他没有this指针。

友元类也是偷家，只不过这次换成了类和类直接：
```
class A
    {
    friend Date B;//友元类
    private:
    	int _a;
    	static int k;
        
    public:
       ...
    };
 
class B
    {
    private:
    	int _c;
    	int k;
        
    public:
       ...
    };
```
B是A的友元类，B能访问A的私有成员变量，但A不能访问B的私有成员变量。（假朋友）

五、内部类（C++中不重要）

就是类套类（类种类）
```
class A
{
private:
    int _a;
    static int k;
 
public:
    // B天生就是A的友元
    class B
    {
            int _b;
         void foo(const A& a)
		{
			cout << k << endl;//OK,可以访问
			cout << a._a << endl;//OK
		}
    };
};
```
1.计算类的内存大小时，sizeof(A)答案是四，因为A对象里没有B，只有自己的成员，这里就可以看作：他们两仅仅是嵌套定义，相当于两个独立的类。

但B类的访问受A类域访问限定符的限制！

A aa; //aa中没有B的对象

如果要创建一个B的对象，需要 A:: B bb;

只是域限定关系!

2.类种类，被套在里面的类天生是外面类的友元类，B可以访问A，但A不能访问B。

所以定义类时，如果有内部类，你就要小心了，小心不注意把你家偷光！

六、匿名对象

创建类有几种方式呢？
```
class A
{
public:
    A(int a=0)
    :N(a)
    {}
 
    int Sum_Solution()
    {
        return N;
    }
private:
    int N;
};
 
int main()
{
	// 有名对象
	A aa0;
	A aa1(1);
	A aa2 = 2;  //单参数创建类隐式类型转化
 
	//A aa3(); //不ok，会与函数声明冲突
 
	// 匿名对象 --生命周期当前这一行
	A();
	A(3);
 
	//A so;
	//A.Sum_Solution(10);
 
	A().Sum_Solution(10);
 
	return 0;
}
```
匿名对象不需要对象名，且生命周期只是当前这一行。

当我们只是为了访问成员函数，而创建类去访问，那可不可以简单一些呢？

A so; A.Sum_Solution(10);

A().Sum_Solution(10); 这两个是一样的，这一行结束，匿名对象会自动调用析构函数。

七、编译器中的一些优化

编译器这些优化，只存在于构造函数和拷贝构造函数之间，且适合一个表达式中的连续步骤，优化的前提当然不能改变原本的正确性！

下面来看几个例子，来了解如何优化，怎么优化：
```
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;
}
 
A f3()
{
	/*A aa(10);
	return aa;*/
 
	return A(10);
}
 
int main()
{
	// 优化场景1
	A aa1 = 1;  // A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)
 
	// 优化场景2
	A aa1(1);
	f1(aa1);
    --------------
	f1(A(1));  // 构造 + 拷贝构造  -> 优化 构造
 
	f1(1);  // 构造 + 拷贝构造  -> 优化 构造
    
    //优化场景3
	f2();	  // 构造+拷贝构造
   
	A ret = f2(); // 构造+拷贝构造+拷贝构造 ->优化 构造+拷贝构造，中间可能对aa还有一些操作， 
                  // 不是连续的一个表达式 ，所以无法直接优化为一个构造
 
    //优化场景4
	A ret;
	ret = f2();
   ----------------
	A ret = f3();  //  构造+拷贝构造+拷贝构造 -> 优化 -> 构造
 
	return 0;
}
```
场景1.

前面的单参数隐式类型创建类：

先拿1构造一个临时变量，再用临时变量拷贝aa1（构造+拷贝构造）

优化方式：直接为：A aa1(1)；就是构造函数

场景2.

A aa1(1); f1(aa1); 定义一个类，传参调用（构造+拷贝构造），无法优化，不保证是否需要对aa1对象进行操作，所以优化都是一个表达式中的连续步骤。

f1(A(1)); 直接利用匿名函数创建类，传值返回。（构造 + 拷贝构造 -> 优化：构造），因为匿名对象创建完自动析构，就相当于直接拿1去构造了f(1)中的形参 aa了

f1(1); 单参数隐式类型创建对象，1去构造临时变量，临时变量去拷贝形参。（构造 + 拷贝构造 -> 优化：构造）

场景3：

f(2)中，先构造一个类，再传值返回，就需要拷贝到临时变量。（构造+拷贝）

A ret = f2();先构造，再拷贝，再拷贝，因为要把返回值拷贝构造到ret对象。（构造+拷贝+拷贝），优化：在拷贝临时变量时，就直接将临时变量当作ret对象拷贝构造了。省略了第三步（构造+拷贝）。

场景4：

A ret; ret = f2();事先创建好了ret对象，ret = f2();不是拷贝构造，是赋值。（构造+拷贝）

A ret = f3();都在一个步骤里。 f3();中创建的是匿名对象，一个构造，后面还是一样，拷贝+拷贝。（构造+拷贝+拷贝）。优化：直接是一个构造函数。

f(3);中，直接创建一个匿名对象，不担心对他有其他操作，就是一个表达式中连续的步骤，直接优化，不会出现错误。

总结：

类和对象到现在就告一段落了，但是在日后的学习我们还是需要不断地回顾，毕竟知识是连续，联系性比较强的，大家继续加油！后面再见！
相关阅读:
Java多线程之：队列同步器AbstractQueuedSynchronizer原理剖析
 掌握这些技巧，让Excel批量数据清洗变得简单高效！
mysql特殊sql总结
 统信系统CEF项目研发环境构建
 DID的使用指南，原理
 开荒手册3——构思一篇小论文
 java中HashMap的实现原理
 scrum｜敏捷开发之任务看板
 微机期末复习指导
 Centos7中安装Jenkins教程
原文地址：https://blog.csdn.net/ChaoFreeandeasy_/article/details/127452954

天空没有极限，我们的的未来无边！破茧的我会飞翔C++更蔚蓝的明天！

前言

一、初始化列表

1.什么是初始化列表

2.为什么要初始化列表

1.const修饰的成员变量

2.没有默认构造函数的自定义类型

3.引用类型

二、隐式类型转化

1.单参数的构造函数支持隐式转换（C++98才支持）

2.多参数的构造函数的类型转化

3.explicit关键字

三、static修饰的静态成员

1.static修饰公有成员变量

2.static修饰私有成员变量

四、友元类和友元函数

五、内部类（C++中不重要）

六、匿名对象

七、编译器中的一些优化

总结：