二、类与对象（四）

22 内部类

22.1 内部类的概念

如果一个类定义在另一个类的内部，这个类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员，外部类对内部类没有任何优越的访问权限，也就是说它和定义在一个全局的类没有什么区别，只是受外部类的类域限制。

例：

#include <iostream>
using namespace std;
class A
{
private:
    int h;
public:
    class B
    {
    private:
        int b;
    };
};
int main()
{
    //B bb; //错误代码
    A::B bb;//B受A的类域限制
    return 0;
}

22.2 内部类的特性

1. 内部类天生就是外部类的友元，即内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

例：

#include <iostream>
using namespace std;
class A
{
private:
    static int k;
    int h;
public:
    class B // B天生就是A的友元
    {
    public:
        void foo(const A& a)
        {
            //B可以访问A的私有成员
            cout << k << endl;//OK
            cout << a.h << endl;//OK
        }
    };
};
int A::k = 1;
int main()
{
    A::B b;
    b.foo(A());
    return 0;
}

运行结果：

2. 内部类可以定义在外部类的public、protected、和private也就是任何位置。

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

例：

#include <iostream>
using namespace std;
class A
{
private:
    int h;
public:
    class B
    {
    private:
        int b;
    };
};
int main()
{
    A aa;
    cout << sizeof(aa) << endl;
    return 0;
}

运行结果：

23 匿名对象

23.1 匿名对象的引入及特性

以往我们调用成员函数的时候，通常的做法是会先定义一个对象，然后再通过这个对象去调用函数，但是有些时候比如我们在做题目，某个函数只需要被调用一次就可以了，如果定义一个对象才能调用就有些麻烦了，这个时候我们就可以通过匿名对象来对函数进行调用。

以往我们说不能用A aa1();这样的方式来定义对象，因为编译器无法识别这是一个函数声明，还是对象定义。

定义匿名对象的方式和上面的方式类似，但是它不用取名字，而且匿名对象的生命周期只在它出现的那一行。

例：

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A();
	cout << "-----" << endl;
	cout << Solution().Sum_Solution(10) << endl;
	return 0;
}

运行结果：

从输出结果可以看到，27行的时候定义了一个匿名对象，到了28行后它就自动调用了析构函数。

除此之外，29行还展示了匿名对象的应用场景，即对于那些需要通过对象来调用函数但对象本身并不重要的情况，就可以通过匿名对象进行调用。当然还有一些其他使用场景，这个等以后遇到再说。

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

在传参和传返回值的过程中，为减少对象的拷贝，通常编译器会对以下场景做一些优化：

23.1 连续构造和拷贝构造时的优化

#include <iostream>
using namespace std;
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;
};

int main()
{
	A aa1 = 1;//构造+拷贝构造
    
	return 0;
}

运行结果：

从输出结果可以看到，35行代码本来应该涉及一个构造和一个拷贝构造，但被编译器优化后只涉及一个构造。

23.2 参数类型为引用时的优化

#include <iostream>
using namespace std;
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 Fun2(const A& aa)
{

}
int main()
{
	A aa1 = 1;
	cout << "-----" << endl;
	Fun2(aa1);//aa只是aa1的别名，无优化
	cout << "-----" << endl;
	Fun2(2);//构造一个临时变量后给别名，无优化
	cout << "-----" << endl;
	Fun2(A(3));//

	return 0;
}

运行结果：

从输出结果可以看到， 当函数参数类型为引用时，因为形参只是实参的一个别名，所以不需要做任何优化。

结论：尽量使用const &传参。

23.3 传值返回时的优化

#include <iostream>
using namespace std;
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 Fun1(A aa)
{

}
void Fun2(const A& aa)
{

}
A Fun3()
{
	A aa;//构造
	return aa;//拷贝构造
}
A Fun4()
{
	return A();
}
int main()
{
	A aa1 = 1;
	cout << "-----" << endl;
	Fun3();//无优化
	cout << "-----" << endl;
	A aa2 = Fun3();//本来应该是一个构造，两个拷贝构造，但被编译器优化为一个构造和一个拷贝构造
	cout << "-----" << endl;
	Fun4();//构造+拷贝构造->优化为直接构造
	A aa3 = Fun4();//构造+拷贝构造+拷贝构造->优化为直接构造
	cout << "-----" << endl;
	return 0;
}

运行结果：

从输出结果可以看到，51行代码本来应该涉及一个构造和两个拷贝构造，但被编译器优化为和49行代码一样，只涉及一个构造和一个拷贝构造。除此之外，58行代码直接返回一个匿名对象时，本来应该涉及一个构造和两个拷贝构造，但被编译器优化后，只涉及一个构造。

需要注意的是，下面这种情况无法优化：

A aa1;
aa1 = Fun4();

原因在于，和A aa3 = Fun4();相比，aa1 = Fun4();还涉及到赋值运算符的重载，这将干扰优化的进行。

结论：

1. 接收返回值对象，尽量以拷贝构造的方式接收，不要赋值接收。
2. 函数中返回对象时，尽量返回匿名对象。