Question

我有一个函数，我想返回一个int数组，但我不想创建一个变量只是为了这样做，就像这样

 int* foo()
 {
       static int bar[]={1,2,3}; // edit thanks to comments
       return bar;
 }

为了解决这个问题，我尝试了这个：

       return (Uint8Type*)   gAppCanContext.BluetoothMacAddr[0] + MacAddr[1] + '-'\
               + gAppCanContext.BluetoothMacAddr[2] + MacAddr[3] + '-' ;

但它不起作用。我也试过这个：

return (Uint8Type*[]){ MacAddr[0] , MacAddr[1] + '-' MacAddr[3] ... };

它会编译并发出警告，如果我执行该程序，它会冻结。我尝试过使用星号和＆符号，但是我无法让它正常工作。

甚至可能吗？如果是这样，怎么样？

补充：我不能使用malloc - 是一个没有动态分配的嵌入式系统。

Answer 1

它会发出警告并且如果我执行该程序，它会冻结。

该警告告诉您正在返回即将死亡的对象的地址，因此在函数调用结束后访问它是非法的。

甚至可能吗？如果是这样，怎么样？

您可以malloc一些内存并返回指向它的指针
您可以使用Electro。

static

Answer 2

如果foo中的数据不是动态的，你可以试试这个：

const char *foo(void)
{
    static const char *bar[] = {"aa", "bb", "cc"};
    return bar;
}

在'static'的帮助下，当数据超出范围时，数据不会消失。

Answer 3

int* foo()
{
   int bar[]={"aa","bb","cc"};
   return bar;
}

没有办法。 C实际上没有“数组”;当你返回bar时，它实际上只会返回一个指向bar的第一个元素的指针，当你回到调用者时它将会消失。

除此之外，您可能想要决定是否需要数组中的“字符串”或整数： - ）

您可以将数组粘贴到结构

中

struct Weird
{
    int bar[3];
}

并返回：

struct Weird foo(void)
{
    struct Weird bar;
    bar.bar[0]=1;
    bar.bar[1]=5;
    bar.bar[2]=10;
    return bar;
}

不过，我不确定那是你想要的。我的猜测是你真的想熟悉C： - ）

如果你这样做，你也可以得到你的第一个例子

int* foo()
{
   static int bar[]={1,2,3};
   return bar;
}

但是，当然，这只会创建一个数组实例 - 所以如果你要修改它，那么所有这些返回都会被改变。

Answer 4

除非标准已更改，否则C将返回可在寄存器中返回的值。因此，在您的情况下，您的函数将返回指向字符串的指针。

如何创建该字符串取决于您的最佳实践。

您可以在函数中声明一个静态数组并返回指向它的指针：

char * cp1()
{
    static char szForeverBuf[100] = {0};

    return (char * ) &szForeverBuf;
}

这可能是处理事情的好方法，如果cp1在启动时被调用一次，但是多次调用可能并且可能会导致错误，因为该函数只返回在编译时创建的缓冲区的地址。

换句话说，每次调用cp1时，函数cp1都会返回一个字符指针，其值永远不会改变。因此，这就是该功能在启动时可能有用的原因。

你也可以像这样创建动态内存：

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

char * cp2(int nSizeP)
{
    char *pszForeverBuf = NULL;
    int nSize = 0;

    if (0 >= nSizeP)
    {
        nSize = 100;
    }
    else
    {
        nSize = nSizeP + 1;
    }

    pszForeverBuf = (char *) malloc((nSize + 1) * sizeof(char));

    return pszForeverBuf; 
}

您需要在某处存储pszForeverBuf的值，因此当您不再想使用内存时，可以使用pszForeverBuf释放它 - free(pszForeverBuf)。

最后 - 更高级 - 您可以创建一个巨大的静态存储块，然后使用执行内存管理的功能对其进行操作。但是，如果您不想多次调用malloc，则会在高级情况下使用。

Answer 5

首先，C中的函数不能返回数组值，只能返回指针。然后你不能返回一个动态的“堆栈”分配对象，正如其他人已经指出的那样，因为当你从函数返回时这样的对象不再存在。

我发现处理这类事情的最简单方法是将数组（指针）作为参数传递给函数：

int* foo(int bar[3]) {
  // fill the array here

  return bar;
}

这使您可以使用两种不同的分配策略调用您的函数

int* aMalloc = foo(malloc(sizeof(int[3])));
int* aLocal = foo((int[3]){ 0 });

然后你甚至可以将这两个表单包装成宏，以便于编码：

#define fooMalloc() foo(malloc(sizeof(int[3])))
#define fooLocal() foo((int[3]){ 0 })

所以上面的代码会读到

int* aMalloc = fooMalloc();
int* aLocal = fooLocal();

即时返回数组（C）

5 个答案: