冰冰学习笔记：类与对象（下）

欢迎各位大佬光临本文章！！！

还请各位大佬提出宝贵的意见，如发现文章错误请联系冰冰，冰冰一定会虚心接受，及时改正。

本系列文章为冰冰学习编程的学习笔记，如果对您也有帮助，还请各位大佬、帅哥、美女点点支持，您的每一分关心都是我坚持的动力。

我的博客地址：bingbing~bang的博客_CSDN博客https://blog.csdn.net/bingbing_bang?type=blog

我的gitee：冰冰棒 (BingbingSuperEffort) - Gitee.comhttps://gitee.com/BingbingSuperEffort

---

系列文章推荐

冰冰学习笔记：《类与对象（上）》

冰冰学习笔记：《类与对象（中）》

---

目录

系列文章推荐

前言

1.初始化列表

1.1初始化列表的引入

1.2初始化列表的定义

1.3初始化列表的特点

2.explicit关键字和匿名对象

3.static成员

4.友元和内部类

4.1友元函数

4.2友元类

4.3内部类

---

前言

        上节中我们详细介绍了类中的6个默认成员函数，本节我们对类中经常使用的一些特殊成员和语法进行简单介绍。

1.初始化列表

1.1初始化列表的引入

        在创建对象的时候，编译器通过使用构造函数对对象的成员变量进行初始化，但是我们写的构造函数真的是在初始化吗？并不是，我们只是将成员变量在函数体中进行了赋值，而不是初始化。

        例如在下面的例子中，我们没有办法让Time类型的变量进行初始化赋值。

class Time
{
public:
	Time(int hour)
	{
		_hour = hour;
	}
private:
	int _hour;
};
class Date
{
public:
	Date(int year)
	{
		_year = year;
	}
private:
	int _year;
	Time _hour;
};

        原因在于Time类中不存在默认构造函数，使用Date创造对象无法完成初始化。 

        那我们若想在创建对象时就让对象中的变量附上我们指定的值，只能使用下面的方式。

        首先需要确保自定义类型变量有默认构造函数，然后在日期类中的构造函数显示创建Time类型的变量，然后进行赋值。

        此种方式虽然能达到我们预想的状况，单这并非对变量进行初始化，而是先对自定义类型的Time进行调用默认构造函数进行初始化后，在使用赋值。初始化只能进行一次赋值，但是函数体内的赋值却能进行多次。

1.2初始化列表的定义

        那有没有什么办法进行一步到位的初始化呢？

        C++为了解决这一问题引入了初始化列表的概念：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

class Date
{
public:
	Date(int year, int hour)
		:_year(year)//初始化列表
		,_hour(hour)
	{
	}
private:
	int _year;
	Time _hour;
};

        使用初始化列表后，我们就不用在显示的进行拷贝构造，初始化列表就会搞定。我们还可以将Date类型中的构造函数全部设置为全缺省类型，这样即便Time类中的默认构造函数并不存在也可使用Date类中的缺省值初始化。

1.3初始化列表的特点

        初始化列表实际就是成员变量定义的地方，无论我们写不写，函数都会先去初始化列表中进行初始化，如果没有定义，则再去函数体中寻找。C++11中打的补丁，可以在声明时赋缺省值，实际也是给初始化列表使用。

初始化列表还具备下列特点：

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

（2）类中包含下列成员，必须放在初始化列表中：引用成员变量，const成员变量，自定义类型成员（且类中没有默认构造）。因为引用只能在初始化时进行一次赋值，const成员只能在定义的地方进行初始化，其他情况下无法更改。

（3）成员变量在类中的声明顺序就是成员变量初始化的顺序，与列表中的顺序无关。

        那初始化列表这么有用，那所有的初始化都使用初始化列表多好。当然我们推荐是能使用初始化列表的情况就使用，但是有些情况用函数体内定义也可以。

class A
{
public:
	/*A(int N)
		:_a((int*)malloc(sizeof(int)*N))//使用初始化列表不方便，需要分开写
		, _N(N)
	{
		if (_a == NULL)
		{
			perror("malloc fail");
		}
		memset(_a, 0, sizeof(int)*N);
	}*/

	// 有些初始化工作还是必须在函数体内完成
	A(int N)
		:_N(N)
	{
		_a = (int*)malloc(sizeof(int)*N);//直接写在函数体中易读
		if (_a == NULL)
		{
			perror("malloc fail");
		}
		memset(_a, 0, sizeof(int)*N);
	}
private:
	// 声明
	int* _a;
	int _N;
};

2.explicit关键字和匿名对象

explicit关键字修饰的构造函数禁止进行类型转换。

        什么意思呢？当我们使用构造函数初始化对象时，对于单参数或者除第一个参数无默认值其余均有默认值的构造函数，其具有类型转换的作用。

        通常情况下下面的代码中我们传参时会出现隐式类型转换。

class Date
{
public:
	//explicit Date(int year)
	Date(int year)
		:_year(year)
	{
		cout << "	Date(int year)" << endl;
	}

	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl;
	}

	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
};
int main()
{
	Date d1(2002);//直接调用构造
	Date d2 = 2003;//隐式类型转换+拷贝构造+优化-->直接调用构造
	return 0;
}

        我们在创建d1时是直接调用构造函数进行构造，但是在创建d2时，2003并非是日期类类型，而是整型，这会发生类型转换，创建一个临时变量tmp存放的是类型转换后的2003，然后在调用拷贝构造，将tmp中的值拷贝给d2。当然编译器通过优化后会直接调用构造。

        当我们加上explicit修饰后，d2的创建将不被允许。

        匿名对象通常使用在变量只使用一次的情况下，生命周期只有一行。

3.static成员

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

static成员具备以下特点：

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

（2）类中只能声明，类外才能定义，定义时不添加static关键字。

（3）静态成员函数可以不使用对象进行访问，只要突破类域就可以调用，可以使用类名::静态成员或者对象.静态成员来访问。

（4）静态成员函数没有this指针，不能访问非静态成员。

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

静态成员使用实例：

（1）设计一个只能在栈上定义对象的类

class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		StackOnly so;
		return so;
	}

private:
	StackOnly(int x = 0, int y = 0)
		:_x(x)
		, _y(y)
	{}
private:
	int _x = 0;
	int _y = 0;
};

        这里就巧妙的使用了静态成员变量，构造函数开辟的普通变量是在栈上，所以我们将构造函数私有，外部无法访问，然后用静态函数提供一个接口，在函数内部创建对象并返回，那么得到的一定是栈上开辟的对象。

（2）限制条件求解n项和

class Sum
{
public:
    Sum()
    {
        i++;
        sum+=i;
    }
    static int get()
    {
        return sum;
    }
private:
static int i;
static int sum;
};
int Sum::i=0;
int Sum::sum=0;
class Solution {
public:
    int Sum_Solution(int n) {
        Sum a[n];
        return Sum::get();
    }
};

        静态变量 i 和sum声明在类内，定义在类外，每个成员都能共享。那么使用Sum类创建一个n个大小的数组就会调用n次构造函数，通过静态变量计算出n项和。

4.友元和内部类

4.1友元函数

        友元函数我们在重载cout和cin的时候进行过讲解。友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明中添加friend关键字。

特点：

（1）友元函数可以访问类的私有和保护成员，但不是类的成员函数。

（2）友元函数不能用const修饰

（3）友元函数可以在类中任何地方声明，不受类访问限定符限制

（4）一个函数可以是多个类的友元函数

（5）友元函数的调用与普通函数的调用原理相同

4.2友元类

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

(1)友元关系是单向的，不具有交换性

class Time
{
	friend class Date; 
	// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{
	}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}

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

        日期类是时间类的友元类，日期类中可以直接访问时间类中的成员，但是时间类不能访问日期类的成员。

（2）友元关系不能传递，B是A的友元，A是C的友元，但是B不是C的友元。

（3）友元关系不能继承。

4.3内部类

        如果一个类定义在另一个类的内部，这个内部的类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。与普通类没有太大的差别。

        内部类天生是外部类的友元类，可以访问外部类的所有成员，但是外部类不是内部类的友元，不能访问内部类的成员。

        内部类的访问需要外部类的域限定符，计算外部类的大小并不包含内部类中的大小，内部类可以直接访问外部类的static成员。