编写一个c++程序，设计一个函数 add_array 对数组中的元素求和，函数原型为： int add_array(int *a); 该函数可以计算一个数组的元素之和，使用参数a接收一个数组，函数内部该数组的元素值进行求和，用return语句返回计算出来的和。

#include <stdio.h>

int add_array(int *a, int len) {
    int sum = 0;
    for (int i = 0; i < len; i++) {
        sum += a[i];
    }
    return sum;
}

int main() {
    int a[] = {1, 2, 3, 4, 5};
    int len = sizeof(a) / sizeof(int);
    int sum = add_array(a, len);
    printf("The sum of the array is %d\n", sum);
    return 0;
}

相关问题

编写一个类模板对数组元素进行遍历输出，数组求和的函数程序

好的，下面是对应的类模板和函数程序：

#include <iostream>
#include <numeric>

template<typename T, size_t N>
class Array {
private:
    T data[N];
public:
    Array(std::initializer_list<T> list) {
        std::copy(list.begin(), list.end(), data);
    }

    void print() {
        for (size_t i = 0; i < N; ++i) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }

    T sum() {
        return std::accumulate(data, data + N, static_cast<T>(0));
    }
};

int main() {
    Array<int, 5> a{1, 2, 3, 4, 5};
    a.print();
    std::cout << "sum = " << a.sum() << std::endl;
    return 0;
}

这里使用了类模板 `Array` 对数组进行操作，其中：

- 构造函数使用了 C++11 新特性中的 `std::initializer_list`，允许使用花括号 `{}` 进行数组初始化；
- `print()` 函数使用循环对数组元素进行遍历输出；
- `sum()` 函数使用了 `<numeric>` 头文件中的 `std::accumulate` 函数，对数组求和。

在主函数中，我们实例化了一个 `Array<int, 5>` 类型的数组，使用 `print()` 和 `sum()` 函数分别进行遍历输出和求和，并输出结果。

程序定义了一个名为 square_array 的 GPU 内核函数，解释这个函数

`square_array` 是一个 GPU 内核函数，它的作用与上面提到的 `square_array` 函数相同，即将输入的整数数组中的每个元素都平方，并将结果存储在一个新的数组中。但是，与 CPU 上的函数不同的是，这个函数是在 GPU 上执行的，并使用 CUDA C / C++ 编写。

下面是一个可能的 `square_array` GPU 内核函数的示例代码：

__global__ void square_array(int *arr, int *result, int n)
{
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n)
    {
        result[idx] = arr[idx] * arr[idx];
    }
}

该函数使用 CUDA C / C++ 语法定义，并且带有 `__global__` 修饰符，表明它是一个 GPU 内核函数。该函数接受三个参数：

- `arr`：指向输入整数数组的指针。
- `result`：指向输出整数数组的指针。
- `n`：输入数组中的元素数量。

该函数使用了 CUDA 的线程模型，其中每个线程都负责处理输入数组中的一个元素。具体来说，每个线程的索引计算如下：

int idx = blockIdx.x * blockDim.x + threadIdx.x;

其中，`blockIdx.x` 是当前线程块的索引，`blockDim.x` 是每个线程块中的线程数量，`threadIdx.x` 是当前线程在线程块内的索引。由于线程块和线程的数量都是可以配置的，因此可以通过修改这些值来优化函数的性能。

在主体部分，该函数检查当前线程的索引是否小于输入数组的长度，如果是，则将对应的输入数组元素平方，并将结果存储在输出数组中：

if (idx < n)
{
    result[idx] = arr[idx] * arr[idx];
}

这个函数的执行需要在 GPU 上启动，类似于下面的示例代码：

int n = 1024;  // 数组长度
int *arr, *result;
cudaMalloc(&arr, n * sizeof(int));
cudaMalloc(&result, n * sizeof(int));
// 初始化 arr 数组
// ...
int blockSize = 256;
int numBlocks = (n + blockSize - 1) / blockSize;
square_array<<<numBlocks, blockSize>>>(arr, result, n);
// 处理完毕后，将结果从 GPU 复制回 CPU
// ...

其中，`numBlocks` 和 `blockSize` 变量用于配置线程模型，`<<<numBlocks, blockSize>>>` 表示在 GPU 上启动 `square_array` 函数的执行。