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

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