类成员初始化的两种方法，const,static类成员的初始化

我们已经知道可以用构造函数里的代码来初始化对象，这就是我们要用的第一种初始化方式。

第一种初始化方式

#include<bits/stdc++.h>
using namespace std;
class Entity {
private:
	string m_name;
public:
	Entity() {
		m_name = "Unknown";
	}
	Entity(const string &name) {
		m_name = name;


	}
	string Get_name() const {
		return m_name;

	}
};
int main()
{
	Entity e0;
	cout << e0.Get_name() << endl;
	Entity e1("xiao ming");
	cout << e1.Get_name() << endl;
}

可以发现代码里的构造函数里规定了m_named的值，但如果变量变多，并且要在构造函数里添加函数的话。第一种未免有点繁琐了（对于观看者来讲）像:

Entity() {
    a=0;
    b=0;
	m_name = "Unknown";
    Init();
    Display();
	}

这样在构造函数里面既有函数，又要初始化，会显得杂乱，另外还有一个严重的问题，后面会讲到。

所以出现了第二种初始化方式。

第二种初始化方式

	Entity() :m_name("Unknown") {
	}
	Entity(const string &name):m_name(name) {
	}

这种构造函数后面加冒号的行为来进行初始化，有下面个好处：

1. 代码整洁自然不用说

2. 节约内存空间，防止多次构造函数。

   为什么这么说，直接看代码！

   #include<bits/stdc++.h>
   using namespace std;
   class Example {
   private:
   public:
   	Example() {
   		std::cout << "Created Entity!" << endl;
   
   	}
   	Example(int x) {
   		std::cout << "Created Entity with " << x <<"!"<< endl;
   
   	}
   
   
   };
   class Entity {
   private:
   	string m_name;
   	Example m_example;
   public:
   	Entity(){
   		m_name = std::string("Unknown");
   		m_example=Example(8);
   	}//重点看这里
   	Entity(const string &name):m_name(name) {
   	}
   	string Get_name() const {
   		return m_name;
   
   	}
   };
   int main()
   {
   	Entity e0;
   	cout << e0.Get_name() << endl;
   	
   }
   

结果为:

Created Entity!
Created Entity with 8!
Unknown

看出蹊跷了，他在我们不知道的情况下多生成了默认构造函数，这并不是我们想要的。

这是因为，我们多创立了一个空间来容纳对example的二次初始化。

我们的目的是扔掉它，用一个新的对象覆它，我们创建了两个对象，而不是一个

这时应该这样

Entity():m_example(Example(8)) {
		m_name = std::string("Unknown");
		
	}

或者

Entity():m_example(8) {
		m_name = std::string("Unknown");
		
	}

此时的结果为：

Created Entity with 8!
Unknown

另外冒号标识符非常重要的作用有下面：

以下参考[类的常量成员的初始化]((7条消息) 类的常量成员的初始化_类中常量成员初始化_chengonghao的博客-CSDN博客)

类的成员的初始化：

1. 非static非const成员变量，必须在构造函数中进行初始化;

2. static成员变量，必须在类的外面进行初始化；

3. const成员变量，必须在类的构造函数的初始化列表中初始化；

4. static const成员变量，可以在类的内部声明时初始化。

   class A
   {
      const int Size = 0;
   }
   

   这里会报错，常量成员不能在类中声明的地方初始化，因为此时类并没有进行实例化（创建对象），因此并没有分配内存，不能进行初始化。

上述示例应该写成：

class A
{
public:
   const int Size;
   A() : Size(0){}
}

类常量成员初始化

#include<iostream>
class Circle {
public:
	 const double rad;
	 
	Circle(const double w_rad) :rad(w_rad){}

嗯，以上就是全部喽