C语言使用技巧（十六）：完整解析函数返回二维数组的常用技巧(END)

最新推荐文章于 2024-03-15 01:02:24 发布
最新推荐文章于 2024-03-15 01:02:24 发布
阅读量5.4k 收藏 49
点赞数 7
分类专栏： C/C++ 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41194129/article/details/108815646
版权

在这里插入图片描述

1、结构体返回一维数组

实现源码：

#include <stdio.h>
#include <math.h>
//结构体返回数组
typedef struct arr
{
    double array[5];
} arr;

arr farr(int rr[],int len)
{
    
    int i;
    arr re;//定义结构体
    for (i = 0; i < len; i++)
        re.array[i] = rr[i];//使用结构体
    return re;//返回结构体
}
int main()
{
    //arr[4][3] = {{4, 6, -4}, {0, 1, 3}, {7, 9, 11}, {8, -8, 6}};
    int rr[5] = {4, 6, 8, -8, 3};
    int len_arr = sizeof(rr)/sizeof(int);
    int i;
    arr re_nm;
    re_nm = farr(rr, len_arr);//调用函数
    for (i = 0; i < len_arr; i++)
        printf("%lf\n", re_nm.array[i]);
    system("pause");
    return 0;
}

执行结果：
在这里插入图片描述

2、不需要结构体返回数组方法

从数组中输出数组大小，使用malloc（）函数，这里有该函数的用法：《完美解析C语言(char*）malloc(x*sizeof(char))》
下面的函数中的max函数不仅能够返回一个数组的最大值，还能够显示这个最大值maxNum在数组中的位置maxIndex。

#include "stdio.h"
#include "stdlib.h"

int *Max(int *arr, int n)
{
    int *a = (int *)malloc(3 * sizeof(int));
    int maxNum = 0, maxIndex, i;
    for (i = 0; i < n; i++)
        if (arr[i] > maxNum)
        {
            maxNum = arr[i];
            maxIndex = i + 1;
        }
    a[0] = maxNum;
    a[1] = maxIndex;
    a[2] = 3;
    return a;
}

void main()
{
    int a[3] = {5, 2, 3}; //a[0]=5,a[1]=2;
    int *b = Max(a, 3);
    int i;
    for (i = 0; i < 3; i++)
        printf("b[%d]=%d\n", i, b[i]);
    system("pause");
    free(b);
}

执行结果;

在这里插入图片描述
下面换一个简单的数组试一试：
实现源码：

#include "stdio.h"
#include "stdlib.h"

int *Max(int *arr, int n)
{
    int i;
    int *a = (int *)malloc(3 * sizeof(int));

    for (i = 0; i < n; i++)
    {
        a[i] = arr[i];
    }
    
    return a;
}

void main()
{
    int a[3] = {5, 2, 3}; //a[0]=5,a[1]=2;
    int *b = Max(a, 3);
    int i;
    for (i = 0; i < 3; i++)
        printf("b[%d]=%d\n", i, b[i]);
    system("pause");
    free(b);
}

执行结果：
在这里插入图片描述

3、函数返回二维数组

实现源码：

#include <stdio.h>
#include <stdlib.h>

char **Function1()
{
    char **Arr = NULL;
    char i = 0, j = 0;
    char Brr[3][3] = {"123", "456", "789"};

    Arr = (char **)malloc(sizeof(char *) * 3);
    for (i = 0; i < 3; i++)
    {
        Arr[i] = (char *)malloc(sizeof(char) * 3);
        for (j = 0; j < 3; j++)
        {
            Arr[i][j] = Brr[i][j];
        }
    }
    return Arr;
}

int main(int argc, const char *argv[])
{
    char **p = NULL;
    int i = 0, j = 0;

    p = Function1();
    printf("Arr[0][0] = %c\n", *(*p));       // 1
    printf("Arr[0][1] = %c\n", *(*(p) + 1)); // 2
    printf("Arr[0][2] = %c\n", *(*(p) + 2)); // 3

    printf("Arr[1][0] = %c\n", *(*(p + 1)));     // 4
    printf("Arr[1][1] = %c\n", *(*(p + 1) + 1)); // 5
    printf("Arr[1][2] = %c\n", *(*(p + 1) + 2)); // 6

    printf("Arr[2][0] = %c\n", *(*(p + 2)));     // 7
    printf("Arr[2][1] = %c\n", *(*(p + 2) + 1)); // 8
    printf("Arr[2][2] = %c\n", *(*(p + 2) + 2)); // 9
                                                 // 将保存每一行的指针先释放掉
    for (i = 0; i < 3; i++)
    {
        if (*(p + i) != NULL)
        {
            free(*(p + i));
            *(p + i) = NULL;
            printf("free *(p + %d) success!!!\n", i);
        }
    }
    // 最后将保存整个二维数组的指针释放掉
    if (p != NULL)
    {
        free(p);
        printf("free p success!!!\n");
    }
    system("pause");
    return 0;
}

执行结果：
在这里插入图片描述
参考文献

下面是参数放置的另一种方法：
数组作为参数放在函数里面，主函数直接调用即可:

#include <stdio.h>
#include <stdlib.h>

char **Function1(char Brr[3][3])
{
    char **Arr = NULL;
    char i = 0, j = 0;


    Arr = (char **)malloc(sizeof(char *) * 3);
    for (i = 0; i < 3; i++)
    {
        Arr[i] = (char *)malloc(sizeof(char) * 3);
        for (j = 0; j < 3; j++)
        {
            Arr[i][j] = Brr[i][j];
        }
    }
    return Arr;
}

int main(int argc, const char *argv[])
{
    char **p = NULL;
    int i = 0, j = 0;
    char brr[3][3] = {"123", "456", "789"};

    p = Function1(brr);
    printf("Arr[0][0] = %c\n", *(*p));       // 1
    printf("Arr[0][1] = %c\n", *(*(p) + 1)); // 2
    printf("Arr[0][2] = %c\n", *(*(p) + 2)); // 3

    printf("Arr[1][0] = %c\n", *(*(p + 1)));     // 4
    printf("Arr[1][1] = %c\n", *(*(p + 1) + 1)); // 5
    printf("Arr[1][2] = %c\n", *(*(p + 1) + 2)); // 6

    printf("Arr[2][0] = %c\n", *(*(p + 2)));     // 7
    printf("Arr[2][1] = %c\n", *(*(p + 2) + 1)); // 8
    printf("Arr[2][2] = %c\n", *(*(p + 2) + 2)); // 9
                                                 // 将保存每一行的指针先释放掉
    for (i = 0; i < 3; i++)
    {
        if (*(p + i) != NULL)
        {
            free(*(p + i));
            *(p + i) = NULL;
            printf("free *(p + %d) success!!!\n", i);
        }
    }
    // 最后将保存整个二维数组的指针释放掉
    if (p != NULL)
    {
        free(p);
        printf("free p success!!!\n");
    }
    system("pause");
    return 0;
}

执行结果与上面一样。

4、实现整型二维数组的函数返回

下面更换为整型数据类型来测试该方法的有效性，提升编码的可读性。

实现源码：

#include <stdio.h>
#include <stdlib.h>

int **Function1(int Brr[4][3])
{
    int **Arr = NULL;
    int i = 0, j = 0;

    Arr = (int **)malloc(sizeof(int *) * 4);
    for (i = 0; i < 4; i++)
    {
        Arr[i] = (int *)malloc(sizeof(int) * 3);
        for (j = 0; j < 3; j++)
        {
            Arr[i][j] = Brr[i][j];
        }
    }
    return Arr;
}

int main(int argc, const int *argv[])
{
    int **p = NULL;
    int i = 0, j = 0;
    int i0, j0;
    int brr[4][3] = {{4, 6, -4}, {0, 1, 3}, {7, 9, 11}, {8, -8, 6}};

    p = Function1(brr);

    for (i0 = 0; i0 < 4; i0++)
    {
        for (j0 = 0; j0 < 3; j0++)
        {
            printf("Arr[%d][%d] = %d\n", i0, j0, *(*(p + i0) + j0));
        }
    }


    for (i = 0; i < 4; i++)
    {
        if (*(p + i) != NULL)
        {
            free(*(p + i));
            *(p + i) = NULL;
            printf("free *(p + %d) success!!!\n", i);
        }
    }
    // 最后将保存整个二维数组的指针释放掉
    if (p != NULL)
    {
        free(p);
        printf("free p success!!!\n");
    }
    system("pause");
    return 0;
}

执行结果：
在这里插入图片描述

下列程序返回一个二维数组，求出一个二维数组各行的最大值以及所在位置。

实现源码：

#include "stdio.h"
#include "stdlib.h"

int **Max(int **arr, int n, int m)
{
    int i, j;
    int **data;
    data = (int **)malloc(n * sizeof(int *));
    for (i = 0; i < n; i++)
        data[i] = (int *)malloc(2 * sizeof(int));
    for (i = 0; i < n; ++i)
    {
        int maxNum = 0;
        for (j = 0; j < m; ++j)
        {
            //printf("arr[%d][%d]=%d ",i,j,*((int *)arr+m*i+j));
            if (*((int *)arr + m * i + j) > maxNum)
            {
                maxNum = *((int *)arr + m * i + j);
                data[i][0] = maxNum;
                data[i][1] = j;
            }
        }
        //printf("\n");
    }
    return data;
}

void main()
{
    int i;
    int a[2][3] = {{4, 6, 3}, {9, 7, 1}};
    int **b = Max((int **)a, 2, 3);
    for (i = 0; i < 2; i++)
    {
        printf("the maximum num for row %d is %d\n", i + 1, b[i][0]);
        printf("the maximum num for row %d is in %d", i + 1, b[i][1] + 1);
        printf("\n");
    }
    for (i = 0; i < 2; i++)
        free(b[i]);
    free(b);
    system("pause");
    return 0;
}

执行结果：
在这里插入图片描述
第一维数的最大值是6位置是2，第二维数的最大值是9位置是1.

5、函数的数组参数的多层用法

实现源码：

#include <stdio.h>
//指针导入两个数组参数
void fun(int *p1, int (*p2)[3], int row, int col)
{
    int i, j;
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 4; j++)
        {
            printf("数组元素为：%d ", p1[i * col + j]);//输出结果的方式
            p2[j][i] = p1[i * col + j];
        };
        printf("\n");
    };
}
int main()
{
    int a[3][4], b[4][3];
    int i, j;
    for (i = 0; i < 3; i++)
        for (j = 0; j < 4; j++)
            a[i][j] = (i + 1) * 10 + j;
    fun(&a[0][0], &b[0], 3, 4);
    printf("\n");
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 3; j++)
            printf("%d ", b[i][j]);
        printf("\n");
    }
    system("pause");
    return 0;
}

执行结果：
在这里插入图片描述

6、函数导入二维数组参数实现更改数组元素

实现源码：

#include <stdio.h>
void fun(int (*pIntPtr)[3])
{
    *(*pIntPtr + 0) = 16;       //将a[0][0]改为16
    *(*(pIntPtr + 3) + 1) = 25; //将a[3][1]改为25
}
int main()
{
    int A[4][3] = {{10, 2, 3}, {12, 4, 5}, {14, 7, 8}, {15, 9, 2}};
    int i, j;
    fun(A);
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 3; j++)
            printf("%4d", A[i][j]);
        printf("\n");
    }
    system("pause");
}

执行结果：
在这里插入图片描述

备注：

函数通过数组作为参数

如果想通过一个一维数组作为函数的参数，就必须声明函数形式参数，使用以下三种方式与所有三个声明方法之一产生类似的结果，因为每一种方式告诉编译器，一个整数指针将会要被接收。类似的方式，可以使用多维数组形式参数。

方式-1：形式参数为指针如下。在下一章将学习什么是指针。

void myFunction(int *param)
{
.
.
.
}

方式-2：如下形式数组参数的大小：

void myFunction(int param[10])
{
.
.
.
}

方式-3：如下形式数组参数作为可变大小：

void myFunction(int param[])
{
.
.
.
}
源代码杀手
关注
  • 7
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
请编写函数fun，该函数的功能是：删去一维数组中所有相同的数，使之只剩一个。数组中的数已按由小到大的顺序排列，函数返回删除后数组中数据的个数。
一键难忘的博客
04-30 467
请编写函数fun，该函数的功能是：删去一维数组中所有相同的数，使之只剩一个。数组中的数已按由小到大的顺序排列，函数返回删除后数组中数据的个数。首先，我们可以使用两个指针来遍历数组。一个指针（称为“读指针”）用于遍历整个数组，另一个指针（称为“写指针”）用于记录当前不重复的元素的位置。 我们从数组的第二个元素开始，依次与前一个元素比较。如果当前元素与前一个元素相同，则跳过；如果不同，则将当前元素复制到写指针所指向的位置，并将写指针向后移动一位。最后，写指针的位置即为不重复元素的个数，返回该位置即可。 这种
C语言提高-32讲： 二维数组
Osseyda's Nation
10-27 1339
知识点总结：                一：二维数组及其定义               初始化              1）分行给二维数组赋初值              2）将所有数据写在一个花括号内              3）只对部分元素赋初值，其他元素值自动置零              二维数组定义中缺省行数（列数不可省），例：
c++return返回二维数组
01-06
在c++中，经常调用函数，而子函数经常要返回的值是数组，无论一维数组还是二维数组都需要运用到指针的知识。一维数组不再过多叙述，给了一个实例如何返回二维数组，希望对大家有帮助（主要用到指针的知识，看不懂的可以先学一下指针）
关于C语言函数返回二维数组的做法
Sun_tester的专栏
11-07 9603
在C语言中，有时我们需要函数的返回值为一个二维数组。这样外部函数接收到这个返回值之后，可以把接收到的二维数组当成矩阵操作（外部函数不可用普通的一级指针接收返回值，这样的话，外部函数将不知道它具有二维性）。方法如下： 法1.没有使用typedef类型定义 #include int (*fun(int b[][2]))[2] { return b; } int main() { int
C语言 函数返回二维数组
m0_60178310的博客
07-30 3567
#include <stdio.h> #include <stdlib.h> #include <string.h> #define N 5 double** Link(double a, double b, double c, double d) { double** T = NULL; T = (double**)malloc(sizeof(double*)*N); if (NULL == T) return NULL; // 定义一个二维数组，为.
c语言返回一个二维数组
weixin_45986454的博客
10-24 3919
标题：c语言返回一个二维数组 参考blog：c语言返回一个二维数组 #include<stdio.h> #include<stdlib.h> int ** getInfo(){ int ** b; //定义一个二维数组 b = (int **)malloc(3 * sizeof(int *)); for(int i = 0; i < 3; i++){ b[i] = (int *)malloc(4 * sizeof(int)); } int t = 0;
函数返回二维数组
最新发布
3000bookworm
03-15 802
在C语言中，函数不能直接返回二维数组，因为数组名作为函数参数或返回值时，会退化为指向数组首元素的指针。此外，C语言不支持返回局部数组的引用，因为局部数组在函数返回后其内存会被释放。
C语言如何将二维数组作为函数的参数
weixin_42899816的博客
08-23 1030
C语言如何将二维数组作为函数的参数？以下用一个例子来说明 //一、以下头文件，未及清理 #include “stdafx.h” #include #include #include <time.h> #include <tchar.h> #include <conio.h> #include “stdio.h” #include “stdlib.h” #include “windows.h” #include using namespace std; //二、函数如
c语言传递二维字符串数组指针,C语言之对于将二维数组作为参数传递的思考
weixin_39996096的博客
05-17 894
这两天在学习扫地僧的课程(二级指针三种内存模型)时，最后的作业是把“第一种内存模型和第二种内存模型的内容复制到第三种内存模型中，并进行排序”。老师预定义了前两种内存模型的内容，和对应的函数实现接口，如下：char *p1[] = { "aaaaa", "cccccc", "bbbbb" };char buf2[10][30] = { "111111", "3333333", "2222222" }...
C语言：求出二维数组每列中最小元素，并依次放入p，p所指一维数组中。二维数组中的数已在主函数中赋
11-01 3886
请编一个函数： void fun(int tt[M][N],int pp[N])，tt指向一个M行N列的二维数组，求出二维数组每列中最小元素，并依次放入pp所指一维数组中。二维数组中的数已在主函数中赋予。 #include<conio.h> #include<stdio.h> #define M 3 #define N 4 void fun(int tt[M][N],int pp[N]) { /**********Begin**********/ int i,j;
C语言-----二维数组
04-26
C语言的二维数组课件，对初学者是不错的选择
c语言二维数组的传递
04-21
c语言二维数组的传递，很适合初学者以及对指针有所迷惑的同学。 本程序已经在VC++6.0里面编译通过
C语言返回二维数组
肥仔的博客
09-14 2952
以计算两个2×2矩阵的矩阵乘法为例： int ** matrixmulti(int a[][2],int b[][2]){ int **c=(int **)malloc(2*sizeof(int *)); int i=0,j=0,k=0; for(;i<2;i++){ for(;j<2;j++){ c[i][j]=0; for(;k<2;k++){ c[i][j]+=a[
c语言 函数返回值 二维数组,从函数返回一个二维数组
weixin_34768234的博客
05-20 3134
anatolyg..19C语言有一个基本缺陷:不可能从函数返回数组.这有很多变通方法; 我将描述三个.用指向数组的指针替换返回指针而不是数组本身.这导致了C中的另一个问题:当一个函数返回指向某个东西的指针时,它通常应该动态地分配一些东西.你不应该忘记稍后解除分配(当不再需要数组时).typedef int (*pointer_to_array)[6][6];pointer_to_array wor...
C语言子函数返回二维数组讨论
weixin_42487618的博客
08-22 3742
C语言中，在子函数中将一个二维数组返回 都知道，在子函数中，一定不能返回一个局部变量的指针，局部变量在子函数中进行创建，子函数调用结束后，该指针将被释放掉。 如果被指针所指向的该内存空间被别的程序占用着，由于指针已将被释放掉了，结果在后续程序中还接着用该指针，就会造成程序崩溃。 这里用字符型二维数组举例来讨论 例如：我们定义一个二维数组 Arr[3][3] = {{1, 2, 3}, {1, 2, 3}, {1, 2 ,3}}; 将这个三行三列的整形数组从子函数中创建出来，在主函数中进行遍历，将所有的元素打
C 返回二维数组
u013838434的博客
03-29 1423
为了让C语言函数返回一个二维数组，有些人这样定义函数： int **foo(int rows, int columns)11 然后在函数中费劲心机拼出来一个这样的malloc语句： int (*result)[columns] = (int (*)[columns])malloc(rows * columns * sizeof(int));11 在函数内读写这个数组发现很正常，等把
C语言中函数返回数组(一维和二维)
热门推荐
西岸贤
06-15 1万+
本文的内容是介绍C语言中函数正确返回一维数组和二维数组的问题，文中通过一个简单的例子和运行结果进行了说明。
C语言函数返回一维，二维数组
qq_38240445的博客
05-14 1228
C语言函数返回一维，二维数组 参考这位大佬思路：https://blog.csdn.net/earbao/article/details/53401800 最近在学习C语言时遇到这样一个问题，如何利用函数返回一个数组（要想一个函数执行后返回多个数据，或者是对数组操作之后返回数组） C语言是不允许直接返回数组的，要想返回数组中的数据，必须使用指针。 由于函数执行后，会进行弹栈操作，在函数中定义的指针指向地址的空间会被释放，指针变成了野指针，所以不能返回指针指向 函数中定义的数组，可以进行以下操作正确的
c 函数返回一维，二维数组
m0_59802969的博客
12-06 565
可以返回全局数组，static数组，函数参数传入的数组，malloc 内存。c 不能直接返回函数内定义的数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

源代码杀手

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值