类和对象下（内部类，匿名对象，对象拷贝时的编译器优化）

晴天的雨.9922026-08-31 9:26

5. 内部类

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

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

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

• 代码示例：

cpp 复制代码 
#include <iostream>
using namespace std;

class Outer {
public:
    // 内部类定义在外部类内部
    class Inner
    {
    public:
        void show() 
        {
            cout << "Inner class method" << endl;
        }
    };

    void useInner() 
    {
        Inner in;
        in.show();
    }
};

int main() {
    Outer::Inner obj;  // 通过外部类访问内部类
    obj.show();
    return 0;
}

• 内部类默认是外部类的友元类，因此内部类可以直接访问外部类的私有成员：

cpp 复制代码 
#include <iostream>
using namespace std;

class Outer    
{
private:
    int value = 100;
public:
    class Inner 
    {
    public:
        void accessOuter(Outer& o)    
          {
            // 内部类作为友元，可直接访问外部类的私有成员
            cout << "Outer private value: " << o.value << endl;
          }
    };
};

int main() 
{
    Outer o;
    Outer::Inner in;
    in.accessOuter(o);
    return 0;
}

6.匿名对象

• 用类型(实参)定义出来的对象叫做匿名对象，匿名对象的特点不用取名字，例如A();相比之前我们定义的类型对象名(实参)定义出来的叫有名对象。

• 匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

• 代码示例：

cpp 复制代码 
#include <iostream>
using namespace std;

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

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

    void show() const 
    {
        cout << "x = " << _x << endl;
    }

private:
    int _x;
};

// 匿名对象作为函数参数
void func(const A& a)    
{
    cout << "func called" << endl;
}

int main()    
{
    // 匿名对象：A(10) 没有名字，生命周期仅限当前这一行
    A(10).show();          // 临时调用成员函数，行末即析构

    func(A(20));           // 匿名对象作为函数实参，函数调用结束后析构

    cout << "main continues" << endl;
    return 0;
}

• 上例中 A(10) 和 A(20) 都是匿名对象，它们没有对象名，生命周期只持续到当前语句结束。当该行执行完毕后，编译器会立即调用析构函数释放资源，因此匿名对象适合"临时用一下"的场景。

• 下面通过一个对比示例，直观展示有名对象和匿名对象在生命周期与资源释放时机上的差异：

cpp 复制代码 
#include <iostream>
using namespace std;

class A {
public:
    A(int x = 0) : _x(x) 
    {
        cout << "A(int) 构造 _x = " << _x << endl;
    }

    ~A() 
    {
        cout << "~A() 析构 _x = " << _x << endl;
    }

    void show() const 
    {
        cout << "show() _x = " << _x << endl;
    }

private:
    int _x;
};

void func(const A& a)    
{
    cout << "func 调用中" << endl;
}

int main() 
{
    cout << "--- 有名对象 ---" << endl;
    A named(1);            // 有名对象，生命周期从定义处开始
    named.show();          // 可以多次使用
    named.show();          // 作用域结束前一直有效

    cout << "--- 匿名对象 ---" << endl;
    A(2).show();           // 匿名对象，仅当前这一行有效，行末立即析构
    func(A(3));            // 匿名对象作为实参，函数调用结束后析构

    cout << "--- main 结束前 ---" << endl;
    // 此时 named 仍存活，直到 main 结束才析构
    return 0;
}
// 输出结果：
// --- 有名对象 ---
// A(int) 构造 _x = 1
// show() _x = 1
// show() _x = 1
// --- 匿名对象 ---
// A(int) 构造 _x = 2
// show() _x = 2
// ~A() 析构 _x = 2        // 匿名对象 A(2) 行末立即析构
// A(int) 构造 _x = 3
// func 调用中
// ~A() 析构 _x = 3        // 匿名对象 A(3) 函数调用结束后析构
// --- main 结束前 ---
// ~A() 析构 _x = 1        // 有名对象 named 在 main 结束时才析构

• 对比可见：有名对象 named 从定义处开始存活，直到其作用域（这里是 main 函数）结束才调用析构函数释放资源，期间可以反复使用；而匿名对象 A(2)、A(3) 没有名字，生命周期只持续到当前语句结束，行末或函数调用结束后编译器会立即调用析构函数释放资源。因此，如果只是临时用一下对象，使用匿名对象可以更及时地释放资源、减少内存占用。

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

• 现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会尽可能减少一些传参和传返回值的过程中可以省略的拷贝。

• 如何优化 C++ 标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新更"激进"的编译器还会进行跨行跨表达式的合并优化。

• 不同编译器对拷贝优化的典型行为对比如下：

编译器 默认优化行为 关闭优化的编译选项
GCC 默认开启拷贝省略（copy elision），对连续表达式中的拷贝进行合并优化；在 C++17 下对按值返回的临时对象保证省略拷贝。 -fno-elide-constructors
Clang 默认行为与 GCC 基本一致，开启拷贝省略；对临时对象和按值返回的优化较为积极。 -fno-elide-constructors
MSVC 默认开启返回值优化（RVO）和命名返回值优化（NRVO），但具体行为受 /O1、/O2 等优化级别影响。 /Zc:noElideConstructors（或使用 /Od 关闭优化）

• 下面通过一个具体示例，直观对比开启优化（默认）和关闭优化（-fno-elide-constructors）时，传参和返回值过程中的拷贝次数差异。

cpp 复制代码 
#include <iostream>
using namespace std;
class A {
public:
A(int x = 0) : _x(x) {
cout << "A(int)" << endl;
}
A(const A& a) : _x(a._x) {
    cout << "A(const A&) 拷贝构造" << endl;
}

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

int _x;
};
// 传参：按值接收，会触发拷贝构造
void func(A a) {
cout << "func 内 _x = " << a._x << endl;
}
// 返回值：返回局部对象，可能触发拷贝构造
A getA() {
A tmp(10);
return tmp;
}
int main() {
cout << "--- 传参 ---" << endl;
A obj1(1);
func(obj1);          // 把 obj1 拷贝给形参 a
cout << "--- 返回值 ---" << endl;
A obj2 = getA();     // 把 getA 的返回值拷贝给 obj2

cout << "--- main 结束 ---" << endl;
return 0;
}

• 编译运行对比：

bash 复制代码 
# 默认开启优化（拷贝省略生效）
g++ test.cpp -o test_default
./test_default
关闭拷贝优化
g++ test.cpp -fno-elide-constructors -o test_noelide
./test_noelide

• 开启优化（默认）时，编译器会尽量省略中间拷贝，输出大致如下：

text 复制代码 
--- 传参 ---
A(int)
func 内 _x = 1
--- 返回值 ---
A(int)
--- main 结束 ---
~A()
~A()
~A()

• 关闭优化（-fno-elide-constructors）时，传参和返回值过程中的拷贝不会被省略，输出大致如下：

text 复制代码 
--- 传参 ---
A(int)
A(const A&) 拷贝构造
func 内 _x = 1
--- 返回值 ---
A(int)
A(const A&) 拷贝构造
--- main 结束 ---
~A()
~A()
~A()
~A()

• 对比可见：开启优化后，传参时省略了形参的拷贝构造，返回值时也省略了临时对象的拷贝构造，整体少调用了两次拷贝构造，析构次数也随之减少，程序运行效率更高。

• Linux 下可以将上面代码拷贝到 test.cpp 文件，编译时用 g++ test.cpp -fno-elide-constructors 的方式关闭构造相关的优化。

相关推荐
91刘仁德6 分钟前
C++ 继承和多态 设计模式
c语言·c++·笔记
码行山野赴时序归途12 分钟前
链表家族收官篇：循环链表
c语言·开发语言·数据结构·链表
景熙552325 分钟前
单体项目编写思路和落地形式
java·开发语言
库玛西1 小时前
哈夫曼树与前缀编码：数据压缩的贪心核心
c语言·c++·笔记·考研
别动我齐刘海1 小时前
ROS2 Jazzy + C++ 实战路线——进阶学习3
c++·人工智能·vscode·python·算法·机器学习·机器人
zhangfeng11331 小时前
《从“人工适配“到“智能生成“：KernelSwift 跨国产芯片算子迁移全栈方案解读》 —— 强调范式跃迁和跨硬件属性，适合偏架构分析的写法
人工智能·算法·华为·ai编程·npu
0+1111 小时前
算法 --滑动窗口
c++·算法·leetcode
计算机毕设定制辅导-无忧学长1 小时前
《基于SpringBoot的未成年人健康知识科普平台的设计与实现》
java·开发语言·vue.js·spring boot·未成年人健康知识科普平台
stolentime1 小时前
（有原题）CSP-S2026第一轮试题（附答案解析、markdown源码）
c++·csp
Ivanqhz1 小时前
Ping-Pong 双缓冲
开发语言·人工智能·python·深度学习·mlir
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接03GitHub 镜像站点04历年考研数学一、数学二、数学三真题试卷及答案PDF05人工智能（AI）发展史：详细里程碑06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08ZCode 周末送额度活动开启：3 亿 Token 免费领取092026 爱知・名古屋亚运会怎么看？直播平台+赛程安排分享10数学公理体系大全:第六章 选择公理的等价形式及证明