深入解析C++函数调用的输入输出机制：从参数传递到返回值优化

1次阅读

没有评论

共计 2720 个字符，预计需要花费 7 分钟才能阅读完成。

函数调用是 C ++ 程序中最基本的操作之一，它的核心流程可以分为以下几个步骤：

参数准备：调用者根据函数声明准备参数
控制权转移：程序计数器跳转到函数入口地址
栈帧创建：为函数调用分配新的栈空间
参数传递：将实参传递给形参
函数执行：执行函数体代码
返回值处理：将返回值传递给调用者
栈帧销毁：释放函数占用的栈空间
控制权返回：程序计数器返回到调用点

这个过程看似简单，但在底层却隐藏着许多值得关注的细节，特别是参数传递和返回值处理这两个关键环节。

C++ 提供了多种参数传递方式，每种方式都有其特点和适用场景。

这是最基本的传递方式，函数获取的是参数的副本。

void func(int x) {  // 值传递
    x = 10;  // 修改的只是副本
}

int main() {
    int a = 5;
    func(a);
    // a 仍然是 5
}

优点：简单直观，不会影响原始数据
缺点：对于大型对象，复制开销较大
适用场景：小型内置类型、需要隔离修改的情况

函数直接操作原始数据，避免了复制开销。

void func(int &x) {  // 引用传递
    x = 10;  // 修改原始数据
}

int main() {
    int a = 5;
    func(a);
    // a 现在是 10
}

优点：无复制开销，可以直接修改原始数据
缺点：可能意外修改调用者数据
适用场景：需要修改原始数据或避免复制的场景

通过指针间接访问原始数据，功能类似于引用但更灵活。

void func(int *x) {  // 指针传递
    *x = 10;  // 通过指针修改原始数据
}

int main() {
    int a = 5;
    func(&a);
    // a 现在是 10
}

优点：可以传递 nullptr，更灵活
缺点：语法稍复杂，需要处理指针有效性
适用场景：可选参数、需要重新指向的场景

结合了引用传递的高效和值传递的安全性。

void func(const std::string &s) {  // const 引用
    // 可以读取但不能修改 s
}

优点：无复制开销且防止意外修改
适用场景：只读访问大型对象

函数通过返回值寄存器或栈空间返回结果，调用者负责接收。

int add(int a, int b) {return a + b;  // 返回值}

int main() {int sum = add(3, 4);  // 接收返回值
}

现代编译器会对返回值进行优化，避免不必要的拷贝：

std::string createString() {return std::string("hello");  // 可能被 RVO 优化
}

std::string s = createString();  // 直接构造到 s

NRVO(Named RVO)：对命名变量的优化
触发条件：返回值类型与接收变量类型一致
注意事项：不要为了优化而牺牲代码清晰度

const std::string &getRef() {return std::string("temp");  // 错误：返回局部临时对象的引用
}

void process(std::vector<int> data) {  // 大型 vector 被复制
    // ...
}

void func(int x);
void func(int &x);

int a = 5;
func(a);  // 调用哪个？

对于内置类型，值传递通常是最佳选择
对于大型对象，优先使用 const 引用传递
需要修改原始数据时使用引用或指针
明确函数是否修改参数，用 const 修饰只读参数
利用移动语义 (move semantics) 优化大型对象返回
保持参数传递方式的一致性
文档化不明显的参数传递约定

#include <iostream>
#include <vector>
#include <chrono>

// 值传递
void byValue(std::vector<int> vec) {vec[0] = 100;
}

// 引用传递
void byRef(std::vector<int> &vec) {vec[0] = 100;
}

// const 引用传递
void byConstRef(const std::vector<int> &vec) {// vec[0] = 100;  // 编译错误
    int x = vec[0];  // 只读访问
}

int main() {std::vector<int> largeVec(1000000, 0);

    auto start = std::chrono::high_resolution_clock::now();
    byValue(largeVec);
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "By value:" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "us" << std::endl;

    start = std::chrono::high_resolution_clock::now();
    byRef(largeVec);
    end = std::chrono::high_resolution_clock::now();
    std::cout << "By reference:" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "us" << std::endl;

    start = std::chrono::high_resolution_clock::now();
    byConstRef(largeVec);
    end = std::chrono::high_resolution_clock::now();
    std::cout << "By const reference:" 
              << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() 
              << "us" << std::endl;
}