类和对象（下）

目录

1. 初始化列表

2. explicit关键字

3. static成员

3.1 概念

3.2 特性

4. 友元

4.1 友元函数

4.2 友元类

5. 内部类

6. 匿名对象

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

---

1. 初始化列表

下面是类的构造函数

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

虽然对象在调用完构造函数后对象中已经有了一个初始值，但是不能将其称为对对象中成员变量 的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始 化一次，而构造函数体内可以多次赋值

初始化列表格式：

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

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. 类中包含以下成员，必须放在初始化列表位置进行初始化：

        引用成员变量

        const成员变量

        自定义类型变量 且没有默认构造 

3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

5.只能是构造函数才可以有初始化列表（构造函数，赋值构造）

6.构造函数的相互调用要函数要写在初始化列表

class Date
{
public:
	Date() :Date(0 ,0 ,0) {}

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

如果写在函数体内

class Date
{
public:
	Date()  
	{
		Date(0, 0, 0);//这里其实是定义了一个匿名对象
	}

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

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date a;
	a.Print();//    -858993460/-858993460/-858993460
	return 0;
}

 这里对象的初始化调用的构造函数无参，但是这个无参的构造函数并没有完成对内置类型做任何处理，所以对象内容会是随机值

7.在构造函数定义和声明分离的情况下，初始化列表要写在定义处

Date.h

#pragma once

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int i = 0);

	Date(int year, int month, int day);

	void Print();
private:
	int _year;
	int _month;
	int _day;
};

Date.cpp

#include"Date.h"

Date::Date(int i) :Date(0, 0, 0)  {}

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

void Date::Print()
{
	cout << _year << "/" << _month << "/" << _day << endl;
}

 默认参数只能写在声明，初始化列表只能写在定义

8.当类的的成员函数中有自定义类型，构造函数会调用它的默认构造函数来初始化，这个工作是由初始化列表完成的

关于初始化列表的细节推荐这个博文

---

2. explicit关键字

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

class A
{
public:
	A(int n = 0)
		:_a(n)
	{
		cout << "A(int n)" << endl;
	}

	A(const A& x)
		:_a(x._a)
	{
		cout << "A(const A& x)" << endl;
	}

private:
	int _a;
};

int main()
{
	A a(1);
	//隐式类型转换
	A b = 1;// 1 -> A类型定义构造函数 temp(1) -> b赋值构造
	//等价于
	A temp(1);
	A d = temp;

	//A& c = 1;
	const A& c = 1;//加const就可以，说明存在temp（1）常性的临时变量，证明发生了隐式类型转换
	return 0;
}

c++ 11 规定了下面这种情况也可以

class A
{
public:
	A(int n = 0, int b = 0)
		:_a(n),
		_b(b)
	{
		cout << "A(int n = 0, int b = 0)" << endl;
	}

	A(const A& x)
		:_a(x._a),
		_b(x._b)
	{
		cout << "A(const A& x)" << endl;
	}

private:
	int _a;
	int _b;
};

int main()
{
	A a(1, 2);
	A b = { 1, 2 };
	return 0;
}

使用花括号{}

explicit修饰构造函数，禁止类型转换

用explicit修饰构造函数，将会禁止构造函数的隐式转换

explicit A(int n = 0, int b = 0)
		:_a(n),
		_b(b)
{
    cout << "A(int n = 0, int b = 0)" << endl;
}

---

3. static成员

3.1 概念

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

用 static修饰的成员函数，称之为静态成员函数。

静态成员变量一定要在类外进行初始化，因为静态成员不属于某一个对象，属于整个类，在类里面初始化，相当于每定义一个对象就要初始化一次，静态成员只能初始化一次

class A
{
public:
	A()	{count++;}

	A(const A& x)	{count++;}

	static int GetCount()	{return count;}//静态成员函数，只能访问静态变量
private://保护
	static int count;//静态成员变量声明
};

int A::count = 0;//静态成员变量定义，A::指明类域

int main()
{
	A a;
	cout << a.GetCount() << endl;
	cout << A().GetCount() << endl;
	cout << A::GetCount() << endl;//静态成员函数的调用

	return 0;
}

3.2 特性

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

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

3. 类静态成员(public)即可用 类名::静态成员 或者 对象.静态成员来访问

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

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

注意：

        非静态成员函数可以调用静态成员函数

        静态成员函数不可以调用非静态成员函数

下面的代码讨论：

class A
{
public:
	A(int i = 0)	{count++;}
	A(const A& x)	{count++;}
//private:
	static int count;
	int i = 0;
};
int A::count = 0;

int main()
{
	A a(1);
	cout << A::count << endl;
	//cout << A::i << endl;//报错

	A* p = nullptr;
	cout << p->count << endl;
	//cout << p->i << endl;//崩溃

	return 0;
}

 count是定义在静态区，属于A类域，所以可以用A::count 访问的，但i不是，它属于某个对象

p是A类型的指针，指向nullptr 

p->count 本质是在表明count属于A类域，并没有发生解引用

p->i 需要访问p指针指向对象的成员，需要解引用获取内容

---

4. 友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以 友元不宜多用。

4.1 友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在 类的内部声明，声明时需要加friend关键字。

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

说明:

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

友元函数不能用const修饰（被const修饰的是*this指针，友元函数定义在类外当然没有）

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

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

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

4.2 友元类

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

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

友元关系是单向的，不具有交换性。

比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接 访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递 如果C是B的友元， B是A的友元，则不能说明C时A的友元。

友元关系不能继承，在继承位置再给大家详细介绍。

---

5. 内部类

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

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访 问外部类中的所有成员。但是外部类不是内部类的友元。（“寄生虫”）

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

3. sizeof(外部类)=外部类，和内部类没有任何关系。

---

6. 匿名对象

类名()

匿名对象的特点不用取名字， 但是他的生命周期只有这一行

下一行他就会自动调用析构函数

class Solution {
public:
    int Sum_Solution(int n) {
        //...
        return n;
    }
};

int main()
{
    cout << Solution().Sum_Solution(10) << endl;
    return 0;
}

---

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

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还 是非常有用的。

class A
{
public:
	A(int n = 0):_a(n)
	{
		cout << "A(int n)" << endl;
	}

	A(const A& x):_a(x._a)
	{
		cout << "A(const A& x)" << endl;
	}

	A& operator=(const A& x)
	{
		_a = x._a;

		cout << "A& operator=(const A& x)" << endl;
		return *this;
	}

private:
	int _a;
};

void func1(A a1){}

int main()
{
	//隐式类型转换
	A b = 1;// 1 -> A类型定义构造函数 temp(1) -> b赋值构造
	cout << "------------------------------" << endl;
	//等价于
	A temp(1);
	A d = temp;

	return 0;
}

按道理来说，上下应该是一样的，但这是实际却并不是我们想的那样

A b = 1;

应该是一个构造函数+拷贝构造函数

编译器直接优化成构造函数，减少了中间过程

int main()
{
	func1(1);//隐形类型转换构造+拷贝构造
	cout << "------------------------------" << endl;
	func1(A(1));//构造+拷贝构造
	cout << "------------------------------" << endl;
    //等价于
	A temp(1);
	func1(temp);

	return 0;
}

func1(1) -> func1(A(1)) -> A temp(1) ; func1(temp);

构造函数+拷贝构造 优化成 直接构造

A func2()
{
	return 1;
}

A func3()
{
	return A(1);
}

A func4()
{
	A temp(1);
	int a = 0;
	return temp;
}

int main()
{
	func2();//隐形类型转换构造+拷贝构造
	cout << "------------------------------" << endl;
	A ref1 = func2();//隐形类型转换构造+拷贝构造+拷贝构造
	cout << "------------------------------" << endl;
	A ref2 = func3(); //构造 + 拷贝构造 + 拷贝构造
	cout << "------------------------------" << endl;
	A ref3 = func4(); //构造 + 拷贝构造 + 拷贝构造

	return 0;
}

在旧版编译器上func4函数的构造+拷贝构造是不优化的，但在新的编译器上都被优化成直接构造。

这些连续的构造+多次拷贝构造都被优化成直接构造。

完。