Question

可能重复：
What does this C statement mean?

这个表达是什么意思？

char *(*c[10])(int **p);

Answer 1

c是一个包含10个函数指针的数组，它返回char*并以int**作为参数。

(*c[10])
   ^^^^ = array of 10

(*c[10])
 ^ = function pointer

现在我们有一个包含10个函数指针的数组。

char *(*c[10])
^^^^^^ = returns a char*

char *(*c[10])(int** p)
               ^^^^^ = takes a int** as an argument

返回char*并以int**作为参数的10个函数指针的数组。

_{注意：如果你编写这样的代码，你应该被打耳光。}

Answer 2

cdecl是将C乱码翻译成英文的好工具

$ cdecl explain 'char * (*c[10]) (int **)'
declare c as array 10 of pointer to function (pointer to pointer to int) returning pointer to char

Answer 3

一些示例，以及使用decl的代码段。

1。指向函数的指针：

void (*foo)(void);

会给你一个函数指针foo，它不带参数，也不返回任何内容。

<强>实施例。甲

void fun_1(void)
{
    ...
}

foo = fun_1;
foo(); /* this would call fun_1() */

<强>实施例。 B：

char (*bar)(int);

会给你一个函数指针bar，它将1个参数作为整数并返回char。

char fun_2(int x)
{
    if (x == 50)
        return 'a';
    return 'Z';
}

char v;
bar = fun_2;
v = bar(50); /* this would call fun_2() with 50 as parameter and return 'a' */

2。指向指针的指针

int **p;是一个指向int类型指针的指针。

<强>实施例。 C：

int y[3] = {4, 3, 6};
int *w = &y[0];
int **z = &w;

printf("print: %d ", **z);
printf("%d ", *++(*z));
printf("%d\n", *(*z+1));

print: 4 3 6

3。函数返回指针

<强>实施例。 d：

char *zez(char *s)
{
    s = "def";
    return s;
}


char *str = "abc";

printf("%s - ", str);
printf("%s\n", zez(str));

abc - def

4。函数指针指向返回指针的函数

创建指向zez()

的函数指针

<强>实施例。 E：

char *(*ptr_zez)(char *);

ptr_zez = zez;

printf("ptr: %s - ", str);
printf("%s\n", ptr_zez(str));

ptr: abc - def

5。函数指针数组，用于返回char指针，取一个char指针

<强>实施例。 F：

char *(*c[10])(char *);

c[0] = zez;

printf("c[0]: %s - ", str);
printf("%s\n", c[0](str));

c[0]: abc - def

6。 “将c声明为指向函数的指针的数组10（指向int的指针），返回指向char”

的指针

char *cumlade(int **p)
{
    char *c;
    int i;

    if ((c = malloc(sizeof(char) * 7)) == NULL) {
        fprintf(stderr, "Unable to reserve 7 bytes\n");
        exit(0);
    }

    for (i = 0; i < 6; ++i) {
        c[i] = (unsigned char)*(*p+i);
    }
    c[6] = '\0';

    return c;
}

int main(void)
{
    int t[3][3] = {{97 ,98, 99}, {100, 101, 102}};
    int *u = &t[0][0];
    int **v = &u;
    char *ex;
    char *(*c[10])(int **p); /* <-- the fun */

    c[0] = cumlade;
    c[1] = cumlade;    

    ex = c[0](v);
    printf("EX: %s\n", ex);
    free(ex);

    ex = c[1](v);
    printf("AX: %s\n", ex);
    free(ex);

    return 0;
}

EX: abcdef
AX: abcdef

Answer 4

c是一个10指针数组，它指向指向int的指针作为参数并返回指向char的指针。

Answer 5

类型声明涉及三个运算符：数组[SIZE]，指针*和函数(type1 param1, type2 param2, ...)。请记住所有三个运算符都是右关联的。

char *(*c[10])(int **p);

让我们添加更多括号，使关联性更加清晰。

char *((*(c[10]))(int *(*p)))

从变量c开始。

c[10]表示“c是一个包含10个元素的数组，但每个元素都是......”

然后看看旁边的*。 *(c[10])表示“c是一个包含10个元素的数组，每个元素都是指向...的指针”

然后(*(c[10]))(int *(*p))表示“c是一个包含10个元素的数组，每个元素都是一个指向函数的指针，它返回...”使用类似的方法，我们看到该函数接受一个参数，即“指向一个指向int“。

的指针

然后*((*(c[10]))(int *(*p)))表示“c是一个包含10个元素的数组，每个元素都是一个指向函数的指针，它返回一个指向...的指针。”

最后char *((*(c[10]))(int *(*p)))表示“c是一个包含10个元素的数组，每个元素都是一个指向函数的指针，它返回一个指向char的指针”。就是这样。

我发现顺时针/螺旋规则非常有用。见http://c-faq.com/decl/spiral.anderson.html

但我宁愿添加更多括号而不是使用螺旋。

Answer 6

好了，你现在的答案是，它是一个函数指针数组，但是这样编写代码是否干净（呃）？是的，我相信乍看之下可能会理解这些代码：

typedef char *(*weirdFuncPtr)(int **p);
weirdFuncPtr funcPtrArray[10];

顺便说一下。通常我会避免使用typdefs - 我在声明函数指针时使用它们。这样可以更容易理解这种C代码（C是Cryptic的缩写，是吗？）

Answer 7

它声明了一个函数指针数组。数组中有10个元素（来自声明的c [10]部分）。这些指针可以指向的函数将返回char *并且只接受一个参数，即指向指向整数的指针（int ** p）

看看这个问题的第一个答案How can I use an array of function pointers? 在那里你会发现另一个声明函数指针数组的例子，它可能会让你感到困惑。

Answer 8

如果您正在寻找直观的解释， http://www.geeksforgeeks.org/archives/16841

他们使用后缀顺序评估解释了这一点，就像表达式评估一样。

复杂C语法的含义

8 个答案: