函数形参（int*a）与（int&a）区别，并且举例说明

函数形参 `int* a` 和 `int& a` 都可以用来传递参数，但它们的本质是不同的：

- `int* a` 表示传递一个指向 `int` 类型的指针，函数内部通过解引用指针获取传递的参数值。
- `int& a` 表示传递一个 `int` 类型的引用，函数内部直接使用引用获取传递的参数值。

下面举例说明它们的区别。

void func1(int* a) {
    *a = 10;
}

void func2(int& a) {
    a = 20;
}

int main() {
    int x = 0;
    func1(&x);
    cout << x << endl; // 输出 10
    func2(x);
    cout << x << endl; // 输出 20
    return 0;
}

在 `main` 函数中，先调用了 `func1(&x)`，通过传递指针的方式将 `x` 的值修改为了 10，因为 `func1` 函数内部使用解引用指针的方式获取传递的参数值。接着调用了 `func2(x)`，通过传递引用的方式将 `x` 的值修改为了 20，因为 `func2` 函数内部直接使用引用获取传递的参数值。

在实际开发中，使用指针作为函数形参的情况更为普遍，因为指针可以为空，而引用则必须指向一个已经存在的对象。但是，如果需要在函数内部修改传递的参数值，使用引用会更加方便和直观。

相关问题

智能指针作为函数形参举例

当智能指针作为函数形参时，可以使用以下示例来说明不同的用法：

1. 使用 `std::unique_ptr`：

void ProcessData(std::unique_ptr<int> data) {
    // 操作 data 指向的资源
    // ...
} 

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    ProcessData(std::move(ptr)); // 传递独占所有权
    // 此时 ptr 不再拥有资源
}

2. 使用 `const std::unique_ptr&`：

void PrintData(const std::unique_ptr<int>& data) {
    // 读取 data 指向的资源
    // ...
} 

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    PrintData(ptr); // 传递常引用，避免拷贝构造
}

3. 使用 `std::shared_ptr`：

void ProcessData(std::shared_ptr<int> data) {
    // 操作 data 指向的资源
    // ...
} 

int main() {
    std::shared_ptr<int> ptr = std::make_shared<int>(42);
    ProcessData(ptr); // 传递共享所有权
    // ptr 仍然拥有资源，直到最后一个引用销毁
}

4. 使用裸指针和 `const MyClass&`：

void PrintData(const MyClass& obj) {
    // 使用 obj 进行操作，不涉及智能指针的所有权管理
    // ...
} 

int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>(args);
    PrintData(*ptr); // 通过解引用传递对象的引用
}

这些示例展示了使用不同类型的智能指针作为函数形参的场景，你可以根据具体的需求选择适合的方式来传递和管理资源的所有权。

C一级函数指针形参和二级函数指针形参，如何使用？分别举例说明

在C语言中，一级函数指针和二级函数指针都是用来作为函数的参数或者返回值，以便动态地传递或调用函数。

**一级函数指针形参**：
一级函数指针是一个指向函数地址的变量。它用于接收一个特定类型的函数作为输入。例如：

#include <stdio.h>

// 定义一个返回整数并接受两个整数的函数
int add(int a, int b) {
    return a + b;
}

void function_with_function_ptr(int (*func)(int, int), int arg1, int arg2) {
    // 调用传入的函数，并打印结果
    printf("Result: %d\n", func(arg1, arg2));
    
    // 使用一级函数指针直接调用add函数
    printf("Add result: %d\n", func(add, 5, 7)); // 此处add被当作一级函数指针传递
}

int main() {
    function_with_function_ptr(add, 3, 4); // 通过函数名作为一级函数指针传递
    return 0;
}

在这个例子中，`function_with_function_ptr`函数接受一个`int(*)`类型的形参`func`，它可以指向任何接受两个`int`参数并返回`int`的函数。

**二级函数指针形参**：
二级函数指针则是指向一级函数指针的指针。这允许我们存储不同类型的一级函数指针，然后根据需要调用它们。例如：

#include <stdio.h>

typedef int(*FuncTypeOne)(int, int);
typedef int(*FuncTypeTwo)(char, char);

void function_with二级_function_ptr(FuncTypeOne primary_func_ptr, FuncTypeTwo secondary_func_ptr) {
    printf("First Function Result: %d\n", primary_func_ptr(5, 6)); // 使用一级函数指针
    printf("Second Function Result: %d\n", secondary_func_ptr('a', 'b')); // 使用二级函数指针间接调用
}

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

char compare(char c1, char c2) {
    return (c1 > c2) ? 1 : -1;
}

int main() {
    function_with二级_function_ptr(add, compare); // 传递两个不同类型的函数指针
    return 0;
}

在这里，`function_with二级_function_ptr`函数接受两个二级函数指针，`primary_func_ptr`和`secondary_func_ptr`，可以分别指向`FuncTypeOne`和`FuncTypeTwo`类型的函数。