C 언어 에서 의 함수 포인터 학습 노트

정의 함수 포인터

return_type (*func_pointer)(parameter_list)

일반 포인터 변수의 정의

int * p;
char * pointer;

유형의 한정 은 모두 변수 앞 에 있 습 니 다.
함수 포인터 형식의 한정 은 앞 뒤 가 모두 있 고 앞 은 반환 형식 이 며 뒤 는 입력 매개 변수 입 니 다.

type:def 를 이용 하여 위의 표현 방식 을 간소화 할 수 있 습 니 다.

typedef return_type (*FunctionPointer) (parameter_list);
FunctionPointer func_pointer;

이렇게 하면 쉽게 읽 을 수 있 습 니까?위의 기능 과 마찬가지 로 반환 유형 을 return 로 정의 합 니 다.type,입력 매개 변 수 는 parameterlist 함수 포인터.
2.반환 함수 포인터 의 함수 정의
return_type(*function(func_parameter_list))(parameter_list)

사각형 링 에서 나 온 것 은 반환 형식 을 함수 포인터 로 표시 하고 나머지 부분 은 하나의 function 함 수 를 표시 하 며 입력 매개 변 수 는 func 입 니 다.parameter_list。
그것 은 Function Pointer function(funcparameter_list); 。
다시 보기:

void ( *signal( int sig, void (* handler)( int )))( int );

signal 은 함수 포인터 로 되 돌아 가 는 함수 입 니 다.signal 의 입력 은 int 변수 와 함수 포인터 입 니 다.
3.함수 포인터 의 사용

#include <stdio.h> 
int add(int a, int b); 
void main() 
{ 
  int(*fun1)(int a, int b) = add; 
  int(*fun2)(int a, int b) = &add; 
  int(*fun3)(int a, int b) = *add; 

  printf("%d
", fun1(1, 2)); 
  printf("%d
", fun2(1, 2)); 
  printf("%d
", fun3(1, 2)); 

  char input[10]; 
  gets(input); 
} 
int add(int a, int b) 
{ 
  return a + b; 
}

함수 명 은 암시 적 으로 포인터 로 바 뀌 고 앞 에*와&연산 자 는 모두 작용 하지 않 습 니 다.printf 의 결 과 는 모두 3 입 니 다.
4.신기 한 코드

int (*(*pf())())()
{ return nullptr; }

우 와,이게 무슨 함수 야!틀 을 그 려 서 그것 을 분해 하 다.

작은 상 자 는 함수 지침 을 되 돌려 주 고 큰 상자 에 있 으 며 함수 지침 을 표시 합 니 다.
이 는 pf()가 함수 지침 을 되 돌려 주 는 것 을 나타 낸다.이 함수 지침 은 입력 되 지 않 은 매개 변수 에 대응 하 는 함수 이다.반환 값 도 함수 지침(입력 되 지 않 은 매개 변수 에 대응 하 는 함수,반환 값 은 int 형식)이다.복잡 하 다,어 지 러 워!
type:def 를 이용 하여 간소화 하 세 요.

typedef int(*Fun1) (); 
typedef Fun1(*Fun2) (); 
Fun2 pf() 
{ 
   return nullptr; 
}

이렇게 보면 훨씬 편 하 다.
5.이 건 또 뭐야!

(*(void(*) ())0)();

테 두 리 를 그 려 보 세 요:

작은 상자 에는 함수 포인터 가 있 고 상수 앞 에 괄호 대표 형식의 강제 변환 이 있 습 니 다.어,0 을 함수 포인터 로 강제로 바 꾸 고 실행 합 니 다!이게 무슨 조작 이 야!
검증 코드

#include <stdio.h> 
typedef int Function(int, int); 
typedef int(*FunctionPointer1) (int, int); 
typedef FunctionPointer1(*FunctionPointer2) (); 
int fun1(int a, int b) 
{ 
  return a + b; 
} 

FunctionPointer1 fun2() 
{ 
  return fun1; 
} 
FunctionPointer2 fun3() 
{ 
  return fun2; 
} 
int(*(*fun4())())(int, int) 
{ 
  return fun2; 
} 

void main() 
{ 
  Function* fuction = fun1; 
  FunctionPointer1 fun = fun1; 
  int a = fun3()()(3, 4); 
  int b = fun4()()(5, 6); 
  printf("%d
%d
", a, b); 
  printf("fun1:%d
*fun1:%d
&fun1:%d", fun1, *fun1, &fun1); 
  printf("fun:%d
*fun:%d
&fun:%d", fun, *fun, &fun); 
  char chars[10]; 
  gets(chars); 
}

함수 명 앞 에*,&연산 자 를 추가 하 는 것 은 모두 효과 입 니 다.함수 포인터 앞 에*연산 자 를 추가 하 는 것 은 효과 이지 만&연산 자 를 더 하면 포인터 의 주 소 를 나타 낸다.
type:def int 함수(int,int)를 통 해하나의 유형의 함수 에 별명 을 정의 하지만 사용 할 때 포인터 형식의 변수 만 정의 할 수 있 습 니 다.

Function* fuction = fun1;

질문
stackoverflow 에서 가끔 다음 과 같은 문 제 를 볼 수 있 습 니 다.코드 는 다음 과 같 습 니 다.

#include
void hello() { printf("hello"); }
int hello_1()
{
    printf("hello 1");
    return 0;
}
 
int main(void) {
  (*****hello)();
  (****hello_1)();
}

   실행 결 과 는 hello 앞 에 몇 개의 포인터 기호 가 있 든 지 간 에 hello()함 수 를 실행 하고'hello'를 인쇄 하 는 것 입 니 다.
  왜 이런 결과 가 나 왔 을 까?
    포인터 로 함 수 를 가리 키 는 것 은 OK 이지 만 function pointer 로 바 뀌 어야 합 니 다.사실 함수 하 나 를 가리 키 기 위해*를 사용 합 니 다.따라서 몇 번 을 가리 키 든 지 간 에 이 함 수 를 호출 합 니 다.
왜 하나의 함수 가 하나의 지침 으로 바 뀌 었 습 니까?정 답 은 함수 기본 을 함수 포인터 로 바 꾸 는 것 입 니 다.&사용 을 줄 일 수 있 습 니 다.컴 파일 러 는 기본적으로 함 수 를 함수 포인터 로 바 꾸 고 함수 호출 시*호출 함 수 를 추가 하지 않도록 합 니 다.
  하하,바로 우리 가 전에 말 한 함수 즉 지침 입 니 다.좀 뚜렷 하지 않 은 것 같 습 니 다.다음 예 를 보 세 요.

void foo() {
    printf("Foo to you too!...
");
};
 
int a = 2;
int* test()
{
    return &a;
}
int main()
{
  int i;
  void (*p1_foo)() = foo;
  void (*p2_foo)() = *foo;
  void (*p3_foo)() = &foo;
  void (*p4_foo)() = *&foo;
  void (*p5_foo)() = &*foo;
  void (*p6_foo)() = **foo;
  void (*p7_foo)() = **********************foo;
 
  (*p1_foo)();
  (*p2_foo)();
  (*p3_foo)();
  (*p4_foo)();
  (*p5_foo)();
  (*p6_foo)();
  (*p7_foo)();
  i = *(***test)();
printf("i=%d
",i);
}

위의 열 은 예 외 를 벗 어 나 지 않 고 우리 가 원 하 는 데 이 터 를 정상적으로 인쇄 할 수 있다.
그러나&에 대해 서 는 자세히 분석 해 야 한다.
&한 함수 에 대한 조작 은 하나의 지침 을 되 돌려 주 고 함 수 를 가리 키 는 지침 입 니 다.이 지침 에서&즉&foo 를 실행 하면 error 를 되 돌려 줍 니 다.&foo 는 지침 수치,즉 rvalue 유형 이기 때문에 그 에 게&조작 을 하면 error 를 되 돌려 줍 니 다.

&&foo  //EROOR
&*&*&*&*&*&*foo //OK
&******&foo  //OK