---

一、函数与参数传递（共23题）

题目文件

函数与参数传递（共23题）

1. 下面有关函数参数的说法，正确的是（ ）。

{{ select(1) }}

• 函数参数传递时，主函数当中采用值传递方式将参数传递给子函数时，若子函数将参数值改变，主函数当中的参数值不变。
• 函数参数传递时，主函数当中采用值传递方式将参数传递给子函数时，若子函数将参数值改变，主函数当中的参数值将随子函数一样改变而改变。
• 函数参数传递时，主函数如果将参数的地址传递给子函数，若子函数将参数值改变，主函数当中的参数值将不改变。
• 函数参数传递可以不满足子函数的参数个数要求。

2. 若函数声明为 int f(int &x){ x += 3; return x; }，则对声明的变量 int a = 3，下面哪个调用能够改变 a 的值（ ）。

{{ select(2) }}

• f(&a);
• f(*a);
• f(a);
• f(a-3);

3. 下面代码执行后输出是（ ）。

int fun1(int *n) { return *n * *n; }
int main() {
    int arr[10] = {2};
    arr[1] = fun1(arr);
    cout << arr[1] << endl;
}

{{ select(3) }}

• 1
• 2
• 4
• 编译错误

4. 在C++中，（）正确定义了一个返回整数值并接受两个整数参数的函数。

{{ select(4) }}

• int add(int a, int b){ return a+b; }
• void add(int a, int b){ return a+b; }
• int add(a,b){ return a+b; }
• void add(int a, int b){ return a-b; }

5. 在C++中，形参与实参的关系描述正确的是（ ）。

{{ select(5) }}

• 形参在函数调用时指定，实参在函数定义时传递
• 形参在函数定义时指定，实参在函数调用时传递
• 形参和实参可以互换
• 形参和实参必须是完全相同的类型，不能有任何差异

6. 运行以下代码，屏幕上将输出（ ）。

int var = 100;
void function() {
    int var = 200;
    cout << var << " ";
    cout << ::var << " ";
}
int main() {
    cout << var << " ";
    function();
    var += 100;
    cout << var << " ";
}

{{ select(6) }}

• 100 200 100 200
• 100 200 100 300
• 100 200 200 200
• 100 200 200 300

7. 下面的语句中，（）正确定义了一个计算浮点数 x 的平方 (x² = x×x) 的函数，并成功调用该函数。

{{ select(7) }}

• float square(float x) { return x * x; }
  float area = square(2);
  

• square(float x) { return x * x; }
  float area = square(2);
  

• void square(float x) { return x * x; }
  area = square(2.0);
  

• void square(float x) { x * x; return; }
  area = square(2);
  

8. 下面代码的描述中，正确的是（ ）。

void n_chars(char c, int n) {
    while (n-- > 0)
        cout << c;
}
char my_char = 'w';
int times = 5;
n_chars(my_char, times);

{{ select(8) }}

• 代码执行结束后，times 的值为 0
• n 是形参，times 是实参
• n 是实参，times 是形参
• 代码最后一行换成 n_chars(times, my_char); 也可以

9. 给定以下代码，执行后变量 a 的值为（ ）。

void func(int& x) { x = x * 2; }
int a = 5;
func(a);

{{ select(9) }}

• 5
• 10
• 15
• 20

10. 关于下述代码，说法错误的是（ ）。

int multiply(int x, int y);
int main() {
    int a = 4, b = 5;
    int result = multiply(a, b);
    cout << "The result is: " << result << endl;
    return 0;
}
int multiply(int x, int y) { return x * y; }

{{ select(10) }}

• 函数 multiply 的定义应该放到函数 main 之前。
• 函数声明 int multiply(int x, int y); 中明确指定了函数 multiply() 的返回值为整数类型。
• 在 main 函数中，函数 multiply 通过 multiply(a, b) 被调用，其中 a 和 b 是实参，传递给形参 x 和 y。
• 运行上述代码，将输出 The result is: 20。

11. 执行下述代码将输出（ ）。

int x = 10;
void func() { int x = 20; std::cout << x; }
int main() {
    func();
    std::cout << x;
    return 0;
}

{{ select(11) }}

• 2020
• 2010
• 1020
• 编译错误

12. 执行下述代码后，变量 a 的值为（ ）。

int a = 10;
int* p = &a;
*p = 20;

{{ select(12) }}

• 10
• 20
• 随机值
• 编译错误

13. 执行下述代码，将输出（ ）。

void swap(int a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}
int main() {
    int x = 1, y = 2;
    swap(x, y);
    std::cout << x << y;
    return 0;
}

{{ select(13) }}

• 12
• 21
• 22
• 11

14. 执行下面程序后，输出为（ ）。

int f(int x = 2) { return x * 3; }
int main() {
    cout << f() << " " << f(4);
}

{{ select(14) }}

• 2 12
• 6 12
• 6 4
• 12 6

15. 执行下面代码后，输出为（ ）。

int main() {
    int a = 5;
    int* p = &a;
    int** q = &p;
    **q += 7;
    cout << a << " " << *p;
}

{{ select(15) }}

• 5 5
• 12 12
• 12 5
• 5 12

16. 执行下面程序后，输出为（ ）。

void fun(int a, int &b, int *c) {
    a += 1;
    b += 2;
    *c += 3;
}
int main() {
    int x = 1, y = 1, z = 1;
    fun(x, y, &z);
    cout << x << " " << y << " " << z;
}

{{ select(16) }}

• 2 3 4
• 1 3 4
• 2 1 4
• 1 1 1

17. 执行下面程序后输出为（ ）。

int x = 3;
void f(int &x) { x += 2; }
int main() {
    int x = 10;
    f(x);
    cout << x << " " << ::x;
}

{{ select(17) }}

• 12 3
• 10 5
• 12 5
• 10 3

18. 下面程序可以正常编译并输出10。（判断题）

int calc(int x, int y = 10);
int calc(int x) { return x * 2; }
int calc(int x, int y) { return x * y; }
int main() { cout << calc(5); }

{{ select(18) }}

• 正确
• 错误

19. 下面代码执行结束时，变量 a 的值变成15。（判断题）

void add10(int &x) { x += 10; }
int main() { int a = 5; add10(a); }

{{ select(19) }}

• 正确
• 错误

20. 引用一旦绑定某个变量，就不能再绑定其他变量。（判断题）

{{ select(20) }}

• 正确
• 错误

21. 两个函数之间可以使用全局变量来传递数据。（判断题）

{{ select(21) }}

• 正确
• 错误

22. 在C++语言中，函数的参数为指针时，可以在函数内部修改该参数的值。（判断题）

{{ select(22) }}

• 正确
• 错误

23. 在C++语言中，try子句里抛出的结构体等类型的异常无法被catch捕获。（判断题）

{{ select(23) }}

• 正确
• 错误