C语言：利用指向行的指针变量求5*3数组各行元素之和

可以使用如下代码实现：

#include <stdio.h>

int main() {
    int arr[5][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}};
    int *p;
    int sum;
    for (int i = 0; i < 5; i++) {
        p = arr[i];
        sum = 0;
        for (int j = 0; j < 3; j++) {
            sum += *(p + j);
        }
        printf("第%d行元素之和：%d\n", i+1, sum);
    }
    return 0;
}

在上述代码中，我们定义了一个二维整型数组 `arr`，并初始化了它的元素。

然后，我们定义了一个整型指针变量 `p`，用于指向数组的行。

接着，我们使用循环遍历数组的每一行，将指针 `p` 指向当前行的首元素。

在内层循环中，我们使用指针访问当前行的每一个元素，并将它们累加到变量 `sum` 中。

最后，我们输出每一行元素之和的结果。

运行上述程序，输出结果如下：

第1行元素之和：6
第2行元素之和：15
第3行元素之和：24
第4行元素之和：33
第5行元素之和：42

相关问题

c语言利用指针数组求5*3数组每行元素之和

可以使用以下代码：

#include <stdio.h>

int main() {
    int arr[5][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}};
    int sum[5] = {0};
    int i, j;
    int *ptr[5];  // 定义指针数组

    // 初始化指针数组
    for (i = 0; i < 5; i++) {
        ptr[i] = arr[i];
    }

    // 计算每行元素之和
    for (i = 0; i < 5; i++) {
        for (j = 0; j < 3; j++) {
            sum[i] += *(ptr[i] + j);  // 指针访问数组元素
        }
    }

    // 输出每行元素之和
    for (i = 0; i < 5; i++) {
        printf("第%d行元素之和为：%d\n", i + 1, sum[i]);
    }

    return 0;
}

代码解释：

1. 定义一个二维数组 `arr` 存储数据。
2. 定义一个一维数组 `sum` 存储每行元素之和。
3. 定义一个指针数组 `ptr` 存储二维数组每行的首地址。
4. 使用循环将 `ptr` 中的元素指向 `arr` 中每行的首地址。
5. 使用双重循环遍历 `arr` 中的每个元素，累加每行元素之和并存储到 `sum` 数组中。
6. 使用循环输出每行元素之和。

利用指向行的指针变量求5×3数组各行元素之和。

### 回答1：
可以用指针变量来遍历数组的每一行,然后累加每行的元素之和。

示例代码:

#include <iostream>
using namespace std;

int main()
{
    int a[5][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, 12 }, { 13, 14, 15 } };
    int *p, sum = 0;
    for (int i = 0; i < 5; i++)
    {
        p = a[i];
        for (int j = 0; j < 3; j++)
        {
            sum += *(p + j);
        }
    }
    cout << "Sum = " << sum << endl;
    return 0;
}

输出: Sum = 75

说明:这段代码中,每次循环都将指针p指向数组a的下一行,然后累加这一行中所有元素的值。

### 回答2：
首先我们需要知道什么是指向行的指针变量。在C语言中，我们可以使用二维数组表示一个矩阵，也可以通过指向行的指针来表示矩阵。

比如我们有一个5×3的矩阵，可以使用指向行的指针声明如下:

int arr[5][3] = { {1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}, {13,14,15} };
int (*p)[3] = arr; //指向行的指针变量

这里p是一个指向行的指针变量，它指向arr数组的第一行，每次加1时指向下一行。从数组的角度来看，它是一个指向长度为3的int数组的指针。

对于一个5×3的数组，我们可以通过循环计算每行元素之和，代码如下:

#include <stdio.h>

int main()
{
    int arr[5][3] = { {1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}, {13,14,15} };
    int (*p)[3] = arr; //指向行的指针变量
    int row_sum[5] = {0}; //存放每行元素之和

    for(int i=0; i<5; i++)
    {
        for(int j=0; j<3; j++)
            row_sum[i] += *(*(p+i)+j); //计算每行元素之和
    }

    for(int i=0; i<5; i++)
        printf("第%d行元素之和为%d\n", i+1, row_sum[i]);

    return 0;
}

此处我们使用双重循环，外层循环遍历每一行，内层循环遍历该行的所有元素，使用指向行的指针变量p加上行偏移量i和列偏移量j来访问每个元素。最后将每行元素之和存储在row_sum数组中，便于输出。

输出结果如下:

第1行元素之和为6
第2行元素之和为15
第3行元素之和为24
第4行元素之和为33
第5行元素之和为42

以上是利用指向行的指针变量求5×3数组各行元素之和的方法。它比使用二维数组遍历更加高效，在处理大型数组时尤其有优势。

### 回答3：
5×3数组中有5行3列，要求各行元素之和。可以利用指向行的指针变量来实现。

首先，定义数组并初始化：

int arr[5][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
    {10, 11, 12},
    {13, 14, 15}
};

然后，定义一个指向行的指针变量row_ptr，并遍历每一行，求出每行元素之和，存储到sum数组中：

int sum[5] = {0}; // 存储每行元素之和
int *row_ptr; // 指向行的指针变量

for (int i = 0; i < 5; i++) {
    row_ptr = arr[i]; // 将指针指向当前行
    for (int j = 0; j < 3; j++) {
        sum[i] += *(row_ptr + j); // 求出当前行元素之和
    }
}

最后，输出每行元素之和：

for (int i = 0; i < 5; i++) {
    printf("第%d行元素之和为：%d\n", i + 1, sum[i]);
}

完整代码如下：

#include <stdio.h>

int main() {
    int arr[5][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
        {10, 11, 12},
        {13, 14, 15}
    };

    int sum[5] = {0}; // 存储每行元素之和
    int *row_ptr; // 指向行的指针变量

    for (int i = 0; i < 5; i++) {
        row_ptr = arr[i]; // 将指针指向当前行
        for (int j = 0; j < 3; j++) {
            sum[i] += *(row_ptr + j); // 求出当前行元素之和
        }
    }

    for (int i = 0; i < 5; i++) {
        printf("第%d行元素之和为：%d\n", i + 1, sum[i]);
    }

    return 0;
}