这是我感到困惑的代码。如果有人更正了此代码，那会很有帮助吗？
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解决方案？
提前致谢
问问题
199 次
3 回答
1
目前尚不清楚您要完成什么，因此我将介绍不止一种可能性。
首先，复习一下如何在 C 中读写复杂的声明：
请记住，()and[]比 unary 具有更高的优先级，指针数组也是*如此，while*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])();
...
}
是的，声明更容易阅读，但声明 ofp和表达式之间没有联系(*(*p)[1])()。你必须回过头typedefs来理解为什么这个表达式是这样写的，为每个typedef.
是的，诸如此类int (*(*g())[2])()的声明旨在使您的眼睛呆滞，将所有内容隐藏在 a 后面typedef会使情况变得更糟 IMO。
于 2012-06-26T18:16:47.493 回答
0
不明白你想做什么，也许这可以帮助
#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;
}
于 2012-06-26T12:41:11.047 回答
0
下面的代码将为您提供一个指向函数的指针数组，并且适用于分配、传递数组的标准过程。
#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将指向（固定）数组中的第一个元素，这个指针值是将分配给另一个变量的值。
于 2012-06-26T12:58:43.680 回答