C++中实参与形参同名是否会引发问题？引用传递与值传递存在差异吗？

1. Will same-named actual and formal parameters cause runtime problems? #

Great news—this won’t lead to runtime errors or crashes, and compilers handle this perfectly fine. The key here is scope:

• Actual parameters (the ones you pass when calling a function) live in the caller’s scope (like main() in most examples).
• Formal parameters (the ones defined in the function’s signature) live in the function’s own scope.

Compilers treat these as completely separate variables, even if they share the same name. Here’s a quick example to prove it:

#include <iostream>

void greet(int age) { // Formal parameter: age
    std::cout << "Formal age: " << age << "\n";
}

int main() {
    int age = 25; // Actual parameter: age
    greet(age);
    std::cout << "Actual age: " << age << "\n";
    return 0;
}

Running this will output:

Formal age: 25
Actual age: 25

No confusion, no issues—just two distinct variables doing their own thing.

2. Reference vs. Value Passing: Differences with same-named parameters? #

Now this is where things get interesting. Let’s break down each case:

Value Passing #

When you pass by value, the formal parameter is a copy of the actual parameter. Even if they have the same name, they’re totally independent—modifying one won’t affect the other.

Example:

#include <iostream>

void doubleNum(int num) { // Formal num is a copy
    num *= 2;
    std::cout << "Inside function: " << num << "\n";
}

int main() {
    int num = 10;
    doubleNum(num);
    std::cout << "In main: " << num << "\n";
    return 0;
}

Output:

Inside function: 20
In main: 10

The formal num is a separate copy, so changing it doesn’t touch the original num in main(). Same name, zero problems.

Reference Passing #

Passing by reference means the formal parameter is an alias for the actual parameter—they point to the exact same memory location. The name overlap doesn’t cause runtime errors, but it can lead to accidental bugs if you’re not paying attention.

Because modifying the formal parameter (same name or not) directly changes the original actual parameter. Here’s what that looks like:

#include <iostream>

void doubleNum(int &num) { // Formal num is a reference to the actual num
    num *= 2;
    std::cout << "Inside function: " << num << "\n";
}

int main() {
    int num = 10;
    doubleNum(num);
    std::cout << "In main: " << num << "\n";
    return 0;
}

Output:

Inside function: 20
In main: 20

The same name here doesn’t break anything, but it’s easy to forget that you’re working with the original variable. If you didn’t intend to modify the actual parameter, this could lead to unexpected behavior in your code.

Quick Recap #

• Value passing: Same names = totally safe, no side effects.
• Reference passing: Same names = no runtime errors, but watch out for accidental modifications to the original variable.

内容的提问来源于stack exchange，提问作者solopolo