从c中的函数返回两个指针

我知道您可以通过以下操作返回指向c中数组的第一个元素的指针：

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

int *my_func(void);

int main(void)
{
    int *a;
    int i;

    a = my_func();

    for(i = 0; i < 3; i++)
    {
        printf("a[%d] = %d\n", i, a[i]);
    }

    free(a);

    return 0;
}

int *my_func(void)
{
    int *array;
    int i;

    array = calloc(3, sizeof(int));

    for(i = 0; i < 3; i++)
    {
        array[i] = i;
    }

    return array;
}

#包括
#包括
int*my_func（无效）；
内部主（空）
{
int*a；
int i；
a=我的函数（）；
对于（i=0；i<3；i++）
{
printf（“a[%d]=%d\n”，i，a[i]）；
}
免费（a）；
返回0；
}
int*my_func（无效）
{
int*数组；
int i；
数组=calloc（3，sizeof（int））；
对于（i=0；i<3；i++）
{
数组[i]=i；
}
返回数组；
}

但如果我想返回两个指针而不是一个指针，我尝试：

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

int *my_func(int *);

int main(void)
{
    int *a;
    int *b;
    int i;

    a = my_func(b);

    for(i = 0; i < 3; i++)
    {
        printf("a[%d] = %d\n", i, a[i]);
        printf("b[%d] = %d\n", i, b[i]);
    }

    free(a);
    free(b);

    return 0;
}

int *my_func(int *array2)
{
    int *array;
    int i;

    array = calloc(3, sizeof(int));
    array2 = calloc(3, sizeof(int));

    for(i = 0; i < 3; i++)
    {
        array[i] = i;
        array2[i] = i;
    }

    return array;
}

#包括
#包括
int*my_func（int*）；
内部主（空）
{
int*a；
int*b；
int i；
a=我的函数（b）；
对于（i=0；i<3；i++）
{
printf（“a[%d]=%d\n”，i，a[i]）；
printf（“b[%d]=%d\n”，i，b[i]）；
}
免费（a）；
免费（b）；
返回0；
}
int*my_func（int*array2）
{
int*数组；
int i；
数组=calloc（3，sizeof（int））；
array2=calloc（3，sizeof（int））；
对于（i=0；i<3；i++）
{
数组[i]=i；
阵列2[i]=i；
}
返回数组；
}

但是这个seg在b的printf上出现故障。我通过valgrind运行了它，它说在printf中有一个无效的4号读数，这意味着我在用b指针做一些错误的事情。我只是想知道在c中“返回”第二个数组指针的最佳方法是什么？我这样问是因为我想这样做，而不是使用一个全局变量（我并不反对它们，因为它们有时很有用，如果可能的话，我宁愿不使用它们）。我在这个网站上看到的其他问题使用了静态分配的数组，但我还没有偶然发现一个使用动态分配的问题。提前谢谢

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

int *my_func(int **);

int main(void)
{
    int *a;
    int *b;
    int i;

    b=(int *)malloc(sizeof(int));

    a = my_func(&b);


    for(i = 0; i < 3; i++)
    {
        printf("a[%d] = %d\n", i, a[i]);
        printf("b[%d] = %d\n", i, b[i]);
    }

    free(a);
    free(b);

    return 0;
}

int *my_func(int **array2)
{
    int *array;
    int i;


    array = calloc(3, sizeof(int));
    *array2 =calloc(3,sizeof(int));

    for(i = 0; i < 3; i++)
    {
        array[i] = i;
        *((*array2)+i)=i;//or (*array2)[i]

    }

    return array;
}

#包括
int*my_func（int**）；
内部主（空）
{
int*a；
int*b；
int i；
b=（int*）malloc（sizeof（int））；
a=我的函数（&b）；
对于（i=0；i<3；i++）
{
printf（“a[%d]=%d\n”，i，a[i]）；
printf（“b[%d]=%d\n”，i，b[i]）；
}
免费（a）；
免费（b）；
返回0；
}
int*my_func（int**array2）
{
int*数组；
int i；
数组=calloc（3，sizeof（int））；
*array2=calloc（3，sizeof（int））；
对于（i=0；i<3；i++）
{
数组[i]=i；
*（（*array2）+i）=i；//或（*array2）[i]
}
返回数组；
}

通过引用传递指针。因为它的逻辑与相同，要操作整数块，需要向其传递指针。类似地，要操作指针，必须向其传递指针（即指针到指针）。

我可以想出三种（半）简单的方法从C函数返回任意类型的多个项。这些方法描述如下。看起来有很多文本，但这个答案主要是代码，所以请继续阅读：

按您所做的方式传入输出参数，但请正确执行。您必须在

main（）

中为

int*

分配空间，然后将指向该空间的指针传递到

my\u func

在

main（）

中：

my_func（）

变成：

int *my_func(int **array2)
{
    int *array;
    int i;

    array = calloc(3, sizeof(int));
    *array2 = calloc(3, sizeof(int));

    for(i = 0; i < 3; i++)
    {
        array[i] = i;
        (*array2)[i] = i;
    }

    return array;
}

my_func（）

然后变成：

int main(void)
{
    int **ab;
    int i;

    ab = my_func(b);

    for(i = 0; i < 3; i++)
    {
        printf("a[%d] = %d\n", i, ab[0][i]);
        printf("b[%d] = %d\n", i, ab[1][i]);
    }

    free(ab[0]);
    free(ab[1]);
    free(ab);

    return 0;
}

int **my_func(void)
{
    int **arrays;
    int i, j;

    arrays = calloc(2, sizeof(int *));
    arrays[0] = calloc(3, sizeof(int));
    arrays[1] = calloc(3, sizeof(int));

    for(j = 0; j < 2; j++)
    {
        for(i = 0; i < 3; i++)
        {
            arrays[j][i] = i;
        }
    }

    return arrays;
}

然后，您可以将当前的功能重新表述为以下三个选项之一：

直接通过结构（不建议一般使用）：

对于这里显示的所有示例，不要忘记更新文件顶部的

my_func

声明，尽管我相信任何合理的编译器都会在您忘记时提醒您

---

请记住，这仅仅是我一经发现就从脑海中抽出的三个选项。虽然它们很可能涵盖您可能很快遇到的任何用例的99%，但还有（可能有很多）其他选项。

函数参数是它的局部变量。函数处理所提供参数值的副本

您可以按照以下方式想象您的函数定义及其调用

a = my_func(b);


int *my_func( /* int *array2 */ )
{
    int *array2 = b;
    //...
}

因此，函数内部局部变量

array2

的任何更改都不会影响原始参数

b

对于这样的函数定义，您必须通过引用传递参数，即函数应该像

int *my_func( int **array2 );
                  ^^

有许多方法可以实现该功能。例如，您可以定义两个指针的结构

struct Pair
{
    int *a;
    int *b;
};

并将其用作函数的返回类型

struct Pair my_func( void );

另一种方法是向函数传递指向原始指针的指针数组

该函数可以如演示程序所示

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

size_t multiple_alloc( int ** a[], size_t n, size_t m )
{
    for ( size_t i = 0; i < n; i++ ) *a[i] = NULL;

    size_t k = 0;

    for ( ; k < n && ( *a[k] = malloc( m * sizeof( int ) ) ) != NULL; k++ )
    {
        for ( size_t i = 0; i < m; i++ ) ( *a[k] )[i] = i;
    }

    return k;
}

#define N   2
#define M   3

int main(void) 
{
    int *a;
    int *b;

    multiple_alloc( ( int ** [] ) { &a, &b }, N, M );

    if ( a )
    {
        for ( size_t i = 0; i < M; i++ ) printf( "%d ", a[i] );
        putchar( '\n' );
    }

    if ( b )
    {
        for ( size_t i = 0; i < M; i++ ) printf( "%d ", b[i] );
        putchar( '\n' );
    }

    free( a );
    free( b );

    return 0;
}

---

int*array2

-->

int**array2

，

*array2=calloc（3，sizeof（int）），
（*array2）[i]=i和
a=my_func（&b）a = my_func(b);


int *my_func( /* int *array2 */ )
{
    int *array2 = b;
    //...
}

int *my_func( int **array2 );
                  ^^

struct Pair
{
    int *a;
    int *b;
};

struct Pair my_func( void );

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

size_t multiple_alloc( int ** a[], size_t n, size_t m )
{
    for ( size_t i = 0; i < n; i++ ) *a[i] = NULL;

    size_t k = 0;

    for ( ; k < n && ( *a[k] = malloc( m * sizeof( int ) ) ) != NULL; k++ )
    {
        for ( size_t i = 0; i < m; i++ ) ( *a[k] )[i] = i;
    }

    return k;
}

#define N   2
#define M   3

int main(void) 
{
    int *a;
    int *b;

    multiple_alloc( ( int ** [] ) { &a, &b }, N, M );

    if ( a )
    {
        for ( size_t i = 0; i < M; i++ ) printf( "%d ", a[i] );
        putchar( '\n' );
    }

    if ( b )
    {
        for ( size_t i = 0; i < M; i++ ) printf( "%d ", b[i] );
        putchar( '\n' );
    }

    free( a );
    free( b );

    return 0;
}

0 1 2 
0 1 2