1.内部类

内部类就是定义在一个类的内部的类，比如

#include<iostream>
using namespace std;
class AA{
public:
	class BB {
	public:
		void print(const AA& A)
		{
			cout << A.aa1 << " " << A.aa2 << endl;
		}
	private:
	};
private:
	int aa1 = 10;
	int aa2 = 20;
};

如上所示

类BB定义在类AA中

BB类虽然定义在AA类中，但BB实际上是存放在静态区中。 

 看代码

#include<iostream>
using namespace std;
class AA{
public:
	class BB {
	public:
		void print(const AA& A)
		{
			cout << A.aa1 << " " << A.aa2 << endl;
		}
	private:
	};
private:
	int aa1 = 10;
	int aa2 = 20;
};
int main(){
	cout << sizeof(AA) << endl;

	return 0;
}

我们看到AA类的大小为8,意思就是AA类大小只包含它的两个int类型的成员，不包含BB类的大小。 

 内部类默认是外部类的友元类

代码解释 

#include<iostream>
using namespace std;
class AA{
public:
	class BB {
	public:
		void print(const AA& A)
		{
			cout << A.aa1 << " " << A.aa2 << endl;
		}
	private:
	};
private:
	int aa1 = 10;
	int aa2 = 20;
};
int main(){
	cout << sizeof(AA) << endl;
	AA::BB B;
	AA A;
	B.print(A);
	return 0;
}

运行结果 

 

 用AA类中的BB类定义了B，B中的内置函数可以调用用AA类定义的A中private的成员

如果将BB类定义在AA类中的private/protect中那么BB类就是AA类的专属类，其它地方都用不了，只有AA类中能使用 

2.匿名对象 

类型  +    (实参)定义出来的叫匿名对象，类型    +    对象名     +     （实参） 定义出来的叫对象，

但是匿名对象的声明周期只有它所处的那一行，那一行结束，它的生命周期结束。

#include<iostream>
using namespace std;
class AA{
public:
	AA(int a = 10)
	{
		cout << "构造函数" << endl;
	}
	~AA()
	{
		cout << "析构函数" << endl;
	}
private:
	int _a;
};
int main(){
	AA();
	AA();
	return 0;
}

结果图

因为它会在那一行结束声明周期也结束，所以我们可以定义两次也不报错。

当然它也可以传实参

#include<iostream>
using namespace std;
class AA{
public:
	AA(int a = 8)
	{
		_a = a;
		cout << _a << endl;
	}
	~AA()
	{
		cout << "析构函数" << endl;
	}
private:
	int _a;
};
int main(){
	AA(10);
	return 0;
}

 

一般匿名函数需要放在一些情况下使用，比如需要调用某个类中某个函数一次 

#include<iostream>
using namespace std;
class AA{
public:
	void solution(int a = 8)
	{
		_a = a;
		cout << _a << endl;
	}
	~AA()
	{
		cout << "析构函数" << endl;
	}
private:
	int _a;
};
int main(){
	AA().solution(10);
	return 0;
}

 一般来说匿名函数需要在上面说的那种情况使用(仅需要调用某个类中某个函数一次)