c - 函数返回指针数组后赋值

Question

这是我感到困惑的代码。如果有人更正此代码，会有很大帮助吗？

 int (*(x)())[2];
int main()
{
   int (*(*y)())[2]=x;

   x();
   return 0;
}

int (*(x)())[2]
{
  int **str;
  str=(int*)malloc(sizeof(int)*2);
  return str;
}

如何在 x 返回时分配指针数组？仅使用 malloc 解决方案吗？

提前致谢

Answer 1

尚不完全清楚您想要实现的目标，因此我将介绍不止一种可能性。

首先回顾一下如何在 C 中读写复杂的声明:

请记住()和[]优先级高于一元 * ，所以*a[]是一个指针数组，而 (*a)[]是指向数组的指针；类似地，*f()是一个返回指针的函数，而 (*f)()是指向函数的指针。

当您尝试阅读复杂的声明时，请从最左边的标识符开始，然后逐步解决，记住上面的规则。因此，

 int (*(x)())[2];

读作

        x            -- x
       (x)           -- x
       (x)()         -- is a function
      *(x)()         -- returning a pointer
     (*(x)())[2]     -- to a 2-element array
 int (*(x)())[2]     -- of int

在本例中，括号紧邻x是多余的，可以删除:int (*x())[2]; 。

以下是如何编写和使用此类函数:

int (*x())[2]
{
  int (*arr)[2] = malloc(sizeof *arr);  // alternately, you could simply write
  return arr;                           // return malloc(sizeof (int [2]));
}                                       // type of *arr == int [2]

int main(void)
{
  int (*p)[2] = NULL;                   // alternately, you could write
  ...                                   // int (*p)[2] = x();
  p = x();
  ...
  free(p);
}

请注意 arr 的声明, p ，和x()看起来都一样——它们都符合模式int (*_)[2]; 。 这很重要。如果您将一件事声明为 T (*p)[N]另一件事是 T **q ，那么它们的类型不同并且可能不兼容。指向 T 数组的指针与指向 T 的指针是不同的类型。

如果您的目标是创建一个指向函数的指针数组，返回 int ，那么您的类型将类似于 int (*f[2])(); ，读作

      f          -- f
      f[2]       -- is a 2-element array
     *f[2]       -- of pointers
    (*f[2])()    -- to functions
int (*f[2])();   -- returning int

看起来像下面这样:

int foo() {...}
int bar() {...}

int main(void)
{
  int (*f[2])() = {foo, bar};
  ...
}

如果你想要一个返回 f 的函数，这有点棘手。 C 函数不能返回数组类型；它们只能返回指向数组的指针，因此您的函数声明将构建为

        g            -- g
        g()          -- is a function
       *g()          -- returning a pointer
      (*g())[2]      -- to a 2-element array
     *(*g())[2]      -- of pointers
    (*(*g())[2])()   -- to functions
int (*(*g())[2])()   -- returning int

这样的野兽会被这样使用:

int foo() {...}
int bar() {...}

int (*(*g())[2])()
{
  int (*(*f)[2])() = malloc(sizeof *f);
  (*f)[0] = foo;     // the type of the *expressions* foo and bar
  (*f)[1] = bar;     // is `int (*)()`, or pointer to function
  return f;          // returning int
}

int main(void)
{
  int (*(*p)[2])();
  int x, y;
  ...
  p = g();
  x = (*(*p)[0])();
  y = (*(*p)[1])();
  ...
  free(p);
  ...
}

请注意，您还可以使用替换方法从外到内构建毛茸茸的声明。所以，

int x();                   -- x is a function returning int
int (*p)();                -- replace x with (*p) to get a pointer to a function
                                 returning int
int (*a[2])();             -- replace p with a[2] to get an array of pointers 
                                 to functions returning int
int (*(*q)[2])();          -- replace a with (*q) to get a pointer to an array
                                 of pointers to functions returning int
int (*(*g())[2])();        -- replace q with g() to get a function returning
                                 a pointer to an array of pointers to functions
                                 returning int.

相同的结果，不同的路径。我更喜欢第一种方法，但任何一种都应该有效。

很多人推荐使用typedef使内容更容易阅读:

typedef int ifunc();        // ifunc is a synonym for "function returning int"
typedef ifunc *pifunc;      // pifunc is a synonym for "pointer to function
                            //   returning int
typedef pifunc farr[2];     // farr is a synonym for "2-element array of
                            //   pointer to function returning int
typedef farr *pfarr;        // pfarr is a synonym for "pointer to 2-element
                            //   array of pointer to function returning int

pfarr g() 
{
  pfarr f = malloc(sizeof *f);
  (*f)[0] = foo;
  (*f)[1] = bar;
  return f;
}

int main(void)
{
  pfarr p = g();
  int x, y;
  x = (*(*p)[0])();
  y = (*(*p)[1])();
  ...
}

是的，声明更容易阅读，但是 p 的声明之间没有任何联系。和表达式 (*(*p)[1])() 。你必须卑躬屈膝地浏览所有typedefs理解为什么这个表达式是这样写的，为每个 typedef 建立一个思维导图。

是的，类似 int (*(*g())[2])() 的声明旨在让您的目光呆滞，将所有一切隐藏在 typedef 后面在我看来，情况变得更糟。