C++_类和对象（下篇）—— 内部类、匿名对象、对象拷贝时的编译器优化

四、类和对象（下篇）

5、内部类

6、匿名对象

7、对象拷贝时的编译器优化

四、类和对象（下篇）

5、内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
内部类默认是外部类的友元类。

内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。B类受到A类域的作用影响与限制。

#include<iostream>
using namespace std;

class A
{
private:
    static int _k;
    int _h = 1;

public:
    class B // B默认就是A的友元
    {
    public:
        void foo(const A& a)
        {
            cout << _k << endl; //OK
            cout << a._h << endl; //OK
        }
    };
};

int A::_k = 1;

int main()
{
    cout << sizeof(A) << endl;
    A::B b;
    A aa;
    b.foo(aa);

    return 0;
}

思考：求1+2+3+...+n_牛客题霸_牛客网

上一篇博客C++_类和对象（中、下篇）中的一道牛客网站中的题目也可以使用内部类来实现：C++_类和对象（中、下篇）—— const成员函数、取地址运算符的重载、深入构造函数、类型转换、static成员、友元-CSDN博客

使用内部类的方法代码实现如下：

class Solution 
{
    // 内部类
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            ++_i;
        }
    };

    static int _i;
    static int _ret;

public:
    int Sum_Solution(int n) 
    {
        // 变⻓数组
        Sum arr[n];
        return _ret;
    }
};

int Solution::_i = 1;
int Solution::_ret = 0;

对比两种方法，内部类直接将Sum类转化为Solution类，使其成为一部分，可以直接通过友元关系直接调用，可访问对方的类，拥有权限访问。总的来说，C++的代码实现很少使用内部类这种方法。

6、匿名对象

用类型(实参) 定义出来的对象叫做匿名对象，相比之前我们定义的类型对象名(实参) 定义出来的叫有名对象。
有名对象的生命周期是在当前函数结束之后才会结束，与匿名对象的区别是生命周期的不同。
匿名对象生命周期只在当前一行，⼀般临时定义⼀个对象当前用⼀下即可，就可以定义匿名对象。

匿名对象有参或无参的时候一定要加上括号，不然无参的时候不加括号就会变成一个定义类。

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

    // 不能这么定义对象，因为编译器⽆法识别下⾯是⼀个函数声明，还是对象定义
    //A aa1();

    // 但是我们可以这么定义匿名对象，匿名对象的特点不⽤取名字，
    // 但是他的⽣命周期只有这⼀⾏，我们可以看到下⼀⾏他就会⾃动调⽤析构函数
    A();
    A(1);//匿名对象

    A aa2(2);

    //没用匿名对象之前，我们需要使用两行的代码来表示，如：
    //Solution s1;
    //cout << s1.Sum_Solution(10) << end1;
    //使用之后为：
    //cout << Solution().Sum_Solution(10) << end1;

    // 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这个我们以后遇到了再说
    Solution().Sum_Solution(10);

    return 0;
}

扩展：第一，某个函数给缺省值，使用匿名对象是一个很好的选择。

void func(A aa = A(1))
{}

第二，匿名对象可以引用，但是它跟静态变量一样具有常性，要加上const来修饰，但是加上const会延长临时对象的生命周期，直到引用完（即跟着r变量来走），即构造之后马上析构，现用现销毁。

const A& r = A()

7、对象拷贝时的编译器优化

#include<iostream>
using namespace std;

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

    A(const A& aa)
            :_a1(aa._a1)
    {
        cout << "A(const A& aa)" << endl;
    }

    A& operator=(const A& aa)
    {
        cout << "A& operator=(const A& aa)" << endl;

        if (this != &aa)
        {
            _a1 = aa._a1;
        }

        return *this;
    }

    ~A()
    {
        cout << "~A()" << endl;
    }

private:
    int _a1 = 1;
};

void f1(A aa)
{}

A f2()
{
    A aa;
    return aa;
}

int main()
{
    // 传值传参
    A aa1;
    f1(aa1);
    cout << endl;

    // 隐式类型，连续构造+拷⻉构造->优化为直接构造
    f1(1);

    // ⼀个表达式中，连续构造+拷⻉构造->优化为⼀个构造
    f1(A(2));
    cout << endl;

    cout << "***********************************************" << endl;

    // 传值返回
    // 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
    // ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug）
    f2();
    cout << endl;

    // 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
    // ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug）
    A aa2 = f2();
    cout << endl;

    // ⼀个表达式中，连续拷⻉构造+赋值重载->⽆法优化
    aa1 = f2();
    cout << endl;

    return 0;
}

现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会尽可能减少⼀些传参和传返回值的过程中可以省略的拷贝。
如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新⼀点的编译器对于连续⼀个表达式步骤中的连续拷贝会进行合并优化，有些更新更"激进"的编译器还会进行跨行跨表达式的合并优化。