五分钟掌握C++参数传递精髓，从此告别内存泄漏

// 处理用户信息
void processUserInfo(const string& name);     // 👍 name可能很长,用const引用
void processUserInfo(string name);            // 😱 每次都要拷贝name

// 处理坐标
void movePoint(int x, int y);                // 👍 坐标是简单的int,直接传值
void movePoint(const int& x, const int& y);  // 🤦 引用反而增加了开销

// 处理配置
void updateConfig(const vector<int>& config); // 👍 vector可能很大,用const引用
void updateConfig(vector<int> config);        // 😱 拷贝整个vector开销太大

// 处理ID
void processId(int id);                      // 👍 ID就是个数字,传值
void processId(const int& id);               // 🤦 完全没必要用引用
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

// 糟糕:result像个谜一样,不知道是输入还是输出
void calculate_sum(int values[], int count, int* result); 

// 完美:sum像个告示牌,一看就知道会被修改
void calculate_sum(const int values[], int count, int& sum);

// 糟糕:str像个间谍,不知道会不会被暗中修改
void parse_name(char* str);

// 完美:str像个实习生,明确表示要被指导和修改
void parse_name(string& str);
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

class Widget {
    vector<int> data;
public:
    void add(int x) { data.push_back(x); }
};

void process(shared_ptr<Widget> w) 
{
    w->add(42);  // 看似人畜无害的按值传递,实际是个"内鬼"!
}

void update_iterator(vector<int>::iterator it)
{
    *it = 100;  // 迭代器虽然是按值传递,但有"穿墙"特技!
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

class Person {
    string name_;
    int age_;
public:
    // 糟糕:这简直是"夺舍"!完全替换了原对象
    void update(Person& p) { 
        *this = p;  // 危险!像换了个人似的
    }
    
    // 完美:像个温柔的美容师,只改变你想改的部分
    void set_name(const string& new_name) { name_ = new_name; }
    void set_age(int new_age) { 
        if (new_age < 0) throw invalid_argument("年龄不能为负,你想穿越吗?");
        age_ = new_age; 
    }
};
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

string make_greeting(string&& name)  // name说:"请尽管移动我!"
{
    string result = "Hello, ";
    result += std::move(name);      // 直接把name的内容"偷"过来
    return result;                  // result也会被移动返回,超高效!
}

// 使用示例
string name = "Alice";
string greeting = make_greeting(std::move(name)); 
// 现在name变空了,greeting里面有完整的问候语
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

string str = "Hello";
process_string(std::move(str));  // str的内容被移走了
cout << str;          
1.
2.
3.

// 😊 干净利落的返回值方式
vector<Pizza*> find_pizzas(const vector<Pizza>&, Topping t); 

// 😫 麻烦的输出参数方式
void find_pizzas(const vector<Pizza>&, vector<Pizza*>& out, Topping t);
1.
2.
3.
4.
5.

// 钢琴太重了,还是用引用吧
void move_piano(Piano& destination); 
1.
2.

string message;
for(int i = 0; i < 100; i++) {
  // 重复使用message,避免创建新的
  append_to_message(message, i); 
}
1.
2.
3.
4.
5.

Matrix operator+(const Matrix& a, const Matrix& b) {
    Matrix result;
    // 编译器:放心,我会帮你优化掉不必要的拷贝~
    return result; 
}
1.
2.
3.
4.
5.

// 糟糕的写法 🤦
void calculate_stats(const vector<int>& data, 
                    double& mean,    // 输出参数:平均值
                    double& std_dev) // 输出参数:标准差
{
    // 计算平均值
    mean = /* ... */;
    // 计算标准差
    std_dev = /* ... */;
}

// 使用时:
double avg, dev;
calculate_stats(numbers, avg, dev); // 不清楚哪个是输入哪个是输出
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

// 优雅的写法 ✨
struct Stats {
    double mean;    // 平均值
    double std_dev; // 标准差
};

Stats calculate_stats(const vector<int>& data)
{
    double mean = /* ... */;
    double std_dev = /* ... */;
    return {mean, std_dev}; // 清晰地返回所有结果
}

// 使用时:
auto stats = calculate_stats(numbers); // 一目了然!
cout << "平均值:" << stats.mean << "\n";
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

auto [mean, std_dev] = calculate_stats(numbers);
cout << "平均值:" << mean << "\n";
1.
2.

// 这样写是合适的 👍
bool read_record(istream& in,      // 输入输出流
                Record& record)    // 输出:读取的记录
{
    // 读取记录...
    return true; // 返回是否成功
}

// 使用示例:
Record r;
while (read_record(file, r)) {
    process(r);
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

// 表示地理位置
struct Location {
    double latitude;   // 纬度
    double longitude;  // 经度
    double altitude;   // 海拔(米)
    
    string toString() const {
        return fmt::format("({:.2f}, {:.2f}, {:.2f}m)", 
                          latitude, longitude, altitude);
    }
};

// 使用示例
Location get_current_location() {
    // ... 获取GPS数据 ...
    return {37.7749, -122.4194, 0}; // 旧金山
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

// 不好的写法 👎
tuple<double,double,double> get_position() {
    return {37.7749, -122.4194, 0};
}

// 使用时不知道各个值的含义
auto [x, y, z] = get_position(); 
1.
2.
3.
4.
5.
6.
7.

struct QueryResult {
    int status_code;     // HTTP状态码
    bool has_data;       // 是否找到数据
    string error_msg;    // 错误信息
};
1.
2.
3.
4.
5.

struct HugeResult {
    vector<double> data;  // 可能很大的数据
    string metadata;
};

HugeResult process_data(const string& input) 
{
    HugeResult result;
    result.data = /* ... 大量计算 ... */;
    result.metadata = /* ... */;
    return result;  // 编译器会自动使用移动语义
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

// 相亲角色: 顾客类
class Customer { /*...*/ };

// 场景1: 处理VIP折扣
class Order {
    // 错误写法: 用引用妹,显得太强势了!
    void process_discount(Customer& vip) { /*...*/ }
    
    // 正确写法: 用指针君,比较随意自然
    void process_discount(Customer* maybe_vip) {
        if(maybe_vip) {  // 有VIP就打折
            give_discount();
        } else {         // 没VIP就原价
            normal_price(); 
        }
    }
};
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

void process_order(not_null<Customer*> customer) {
    // 这位指针君保证有对象,超级可靠!
    customer->validate();
}
1.
2.
3.
4.