引用作为函数形参举例

当我们需要在函数中使用另一个函数的输出值时，可以将该函数作为参数传递给另一个函数。这种函数作为参数传递给另一个函数的方式称为函数引用。

例如，假设我们有一个函数 `square` 用来计算一个数的平方：

def square(x):
    return x * x

现在我们需要编写一个函数，用来计算一组数字的平方和。我们可以将 `square` 函数作为参数传递给这个函数，代码如下：

def sum_of_squares(numbers, square_func):
    total = 0
    for n in numbers:
        total += square_func(n)
    return total

这里的 `sum_of_squares` 函数接受两个参数，一个是列表 `numbers`，另一个是函数 `square_func`。函数的主要逻辑是遍历列表并使用传入的函数 `square_func` 对每个元素进行平方运算，然后将结果累加到 `total` 变量中。最后返回 `total` 的值。

现在我们可以调用 `sum_of_squares` 函数来计算一组数字的平方和，同时传递 `square` 函数作为参数：

numbers = [1, 2, 3, 4, 5]
result = sum_of_squares(numbers, square)
print(result)

这里的输出结果是 `55`，即输入列表中每个数字的平方和。

相关问题

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

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

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); // 通过解引用传递对象的引用
}

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

函数形参（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` 函数内部直接使用引用获取传递的参数值。

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