typedef

int inc(int a)
{
　return(++a);
}
int multi(int*a,int*b,int*c)
{
　return(*c=*a**b);
}
typedef int(FUNC1)(int in);
typedef int(FUNC2) (int*,int*,int*);
 
void show(FUNC2 fun,int arg1, int*arg2)
{
　FUNC1 * p=&inc;
　int temp =p(arg1);
　fun(&temp,&arg1, arg2);
　printf("%d
",*arg2);
}
 
main( )
{
　int a;
　show(multi,10,&a);
　return 0;
}

 

typedef int(FUNC1)(int in); 
定义了一个函数类型 FUNC1，该函数类型参数是int in，返回值是int型！

#include<stdio.h>
int inc(int a)
{
 return(++a); //计算a+1
} 
int multi(int*a,int*b,int*c)
{
 return(*c=*a**b); //返回a×b 
} 
typedef int(FUNC1)(int in); //定义函数
typedef int(FUNC2) (int*,int*,int*); 

void show(FUNC2 fun,int arg1, int*arg2)
{
 FUNC1* p=&inc; //这里应该是你复制的有错误，定义函数指针p，指向inc。
 int temp =p(arg1); //arg1=10 所以temp=10+1=11
 fun(&temp,&arg1, arg2); //fun就是multi函数，计算*arg2=11*10=110
 printf("%d
",*arg2);//这里输出110
} 
main()
{ 
 int a;
 show(multi,10,&a);
 return 0;
}

typedef与using有什么区别？

using 是C++11用来扩展typedef 的， 不在typedef上扩展是为了尽可能保持C语言的兼容性。

定义模板的别名，只能使用using

 have a series of functions with the same prototype, say

int func1(int a, int b) {
  // ...
}
int func2(int a, int b) {
  // ...
}
// ...

Now, I want to simplify their definition and declaration. Of course I could use a macro like that:

#define SP_FUNC(name) int name(int a, int b)

But I'd like to keep it in C, so I tried to use the storage specifier typedef for this:

typedef int SpFunc(int a, int b);

This seems to work fine for the declaration:

SpFunc func1; // compiles

but not for the definition:

SpFunc func1 {
  // ...
}

which gives me the following error:

error: expected '=', ',', ';', 'asm' or '__attribute__' before '{' token

Is there a way to do this correctly or is it impossible? To my understanding of C this should work, but it doesn't. Why?

---

Note, gcc understands what I am trying to do, because, if I write

SpFunc func1 = { /* ... */ }

it tells me

error: function 'func1' is initialized like a variable

Which means that gcc understands that SpFunc is a function type.

You cannot define a function using a typedef for a function type. It's explicitly forbidden - refer to 6.9.1/2 and the associated footnote:

The identifier declared in a function definition (which is the name of the function) shall have a function type, as specified by the declarator portion of the function definition.

The intent is that the type category in a function definition cannot be inherited from a typedef:

typedef int F(void); // type F is "function with no parameters
                     // returning int"
F f, g; // f and g both have type compatible with F
F f { /* ... */ } // WRONG: syntax/constraint error
F g() { /* ... */ } // WRONG: declares that g returns a function
int f(void) { /* ... */ } // RIGHT: f has type compatible with F
int g() { /* ... */ } // RIGHT: g has type compatible with F
F *e(void) { /* ... */ } // e returns a pointer to a function
F *((e))(void) { /* ... */ } // same: parentheses irrelevant
int (*fp)(void); // fp points to a function that has type F
F *Fp; //Fp points to a function that has type F