1

我有一个函数，我想返回一个 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 - 是一个没有动态分配的嵌入式系统。

4

5 回答 5

3

它编译时发出警告，如果我执行程序，它会冻结。

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

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

  • 您可以malloc获取一些内存并返回指向它的指针
  • static正如 Electro 所提到的，您可以使用对象。
于 2012-07-04T14:41:14.580 回答
0

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

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

在“静态”的帮助下，数据在超出范围时不会消失。

于 2012-07-04T14:44:15.500 回答
0

除非标准已更改，否则 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 时。

于 2012-07-04T15:47:51.023 回答
0 
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;
}

但是，当然，这只会创建数组的一个实例——因此，如果您正在修改它，所有这些返回都将被更改。

于 2012-07-04T14:48:31.940 回答
0

首先，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();
于 2012-07-04T18:58:15.870 回答