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 only解决方案吗？

提前致谢

Answer 1

我们并不完全清楚你要完成什么，所以我将涵盖多种可能性。

首先，回顾一下如何在C：

中读写复杂的声明

请注意，()和[]的优先级高于一元*，因此*a[]是一个指针数组，而{{1}是一个指向数组的指针;类似地，(*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的parens是多余的，可以删除：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}; ... }的函数，这有点棘手。 C函数不能返回数组类型;它们只能返回指向数组的指针，因此您的函数声明将构建为

f

这样的野兽会用到这样的东西：

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])()背后的一切，使情况变得更糟IMO。

Answer 2

不明白你想做什么，也许这可以帮助

#include<stdio.h>      // printf
#include<stdlib.h>     // malloc free

int *x();              // forward declaration because used before definition

int main() {
    int *y=x();        // y is a pointer on int 
    printf ("%d %d\n", y[0], y[1]);
    free(y);           // must call free because dynamic allocation
    return 0;
}

int *x() {
    int *res;
    res=(int*)malloc(sizeof(int)*2);   // dynamic allocation of an array of two int
    // should check res != NULL
    res[0]=10;
    res[1]=20;
    return res;
}

Answer 3

以下代码将为您提供一系列函数指针，并指定分配，传递数组的标准过程。

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

typedef int (*XFunc())();

XFunc *x[2]; /* array of XFunc pointers */

int f1()
{
    printf("1\n");
    return 1;
}

int f2()
{
    printf("2\n");
    return 2;
}

int main()
{
    x[0] = (XFunc*)f1;
    x[1] = (XFunc*)f2;

    x[0]();
    x[1]();    

    return 0;
}

上面的指针x将指向（固定）数组中的第一个元素，此指针值是将分配给另一个变量的值。

函数返回指针数组后的赋值

3 个答案: