【C++】类和对象4（初始化列表、静态成员、内部类）

逃离我推掉我的手 2021-09-09 00:18 348阅读 0赞

### 文章目录 ###

*  一、再谈构造函数
 *   *  1.构造函数体内赋值
     *  2.初始化列表
     *   *  （1）格式
         *  （2）用处
     *  3.静态成员
 *  二、类成员默认值（C++11）
 *  三、内部类
 *  感谢阅读，如有错误请批评指正

--------------------

# 一、再谈构造函数 #

## 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）格式 ###

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

代码如下（示例）：

class Date
    { 
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{ 
    		//函数体内仍可进行其它操作
    		//...
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };

**注意：每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。**

--------------------

### （2）用处 ###

从使用的角度来看，似乎在构造函数体内赋值和用初始化列表初始化成员变量都可以实现功能，那么初始化列表的用处在哪呢？

**类中包含以下成员，必须放在初始化列表位置进行初始化：引用成员变量、const成员变量、自定义类型成员(该类没有默认构造函数)。**

可以这样理解：这三种变量都必须**在定义的时候直接初始化**。

初始化列表无论写不写编译器都会运行这一步来定义一个对象内的各个变量，但是上面三种变量如果在这时（定义的时候）没有初始化，之后运行的时候就会有问题。大概类似下面的这种写法。

代码如下（示例）：

class A
    { 
    public:
    	A(int x)
    	{ 
    		_x = x;
    	}
    private:
    	int _x;
    };
    
    int main()
    { 
    	//下面的写法都是不正确的
    	const int n;//相当于不在初始化列表初始化
    	n = 10;//然后在构造函数体内赋值
    
    	int& r;
    	r = n;
    
    	A a;
    	a(10);
    	return 0;
    }

下面的代码是正确的：

代码如下（示例）：

class Date
    { 
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    		, _n(10)
    		, _ref(_year)
    		, _a(1)
    	{ }
    
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	const int _n;
    	int& _ref;
    	A _a;
    };

注意：

（1）**尽量使用初始化列表初始化，因为不管是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。**  
（2）**成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。建议类中成员变量声明顺序与初始化列表出现顺序一致。**

--------------------

## 3.静态成员 ##

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

代码如下（示例）：

class A
    { 
    private:
    	static int _n;
    };
    
    //虽然是private，但是静态成员变量必须在类外初始化
    //否则就无法对其初始化
    int A::_n = 0;

（1）静态成员被所有类对象共享，存储在静态区。它不属于某个具体的对象，这一点与成员函数相同，所以计算类的大小时不包括静态成员。  
（2）静态成员变量必须在类外定义，定义时不添加static关键字  
（3）类静态成员即可用类名::静态成员或者对象.静态成员来访问  
（4）静态成员函数没有隐藏的this指针，因此无法访问任何非静态成员  
（5）静态成员和普通成员一样，也有public、protected、private之分，静态成员函数可以具有返回值

--------------------

# 二、类成员默认值（C++11） #

C++11支持**非静态成员变量**在**声明**时进行赋值，但是要注意这里**不是初始化**，这里是给声明的成员变量默认值。

但静态成员依然要像上面那样处理。

代码如下（示例）：

class A
    { 
    public:
    	//...
    	
    private:
    	int a = 20;
    	int* p = (int*)malloc(sizeof(int)* 4);
    	double pi = 3.14;
    	static int _n;
    };
    
    int A::_n = 0;

--------------------

# 三、内部类 #

如果一个类B定义在另一个类A的内部，这个类B就叫做内部类。注意此时这个内部类B是一个独立的类，它不属于外部类A，更不能通过外部类A的对象去调用内部类B。内部类B可以通过外部类A的对象参数来访问外部类B中的所有成员。但是外部类A不能访问内部类B的成员。

代码如下（示例）：

class A
    { 
    public:
    	class B
    	{ 
    	public:
    		void f1(const A& a)
    		{ 
    			cout << a._a << endl;
    			cout << _b << endl;
    		}
    	private:
    		int _b;
    	};
    
    	void f2(const B& b)
    	{ 
    		//cout << b._b << endl;//报错
    		cout << _a << endl;
    	}
    
    private:
    	int _a;
    };

注意：  
（1）内部类定义在外部类的public、protected、private都是可以的。  
（2）内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。  
（3）外部类的带下与内部类没有任何关系。

--------------------

# 感谢阅读，如有错误请批评指正 #