[따배씨] 14.24 복잡한 선언 Declaration 을 해석하는 요령

[따배씨] 14.24 복잡한 선언 Declaration 을 해석하는 요령

따배씨 - 따라하며 배우는 C언어

14강 구조체_2

14.24 복잡한 선언 Declaration 을 해석하는 요령

• 실무에서는 직관적이지 않은 선언을 사용하지 않음
• typedef 를 사용해서 이해하기 쉬운 형태로 사용

 

#include <stdio.h>

int temp(int a){
    return 0;
}

int (*g(int a))(int){
    return temp;
}

int main(){
    
    /*
        *   indicates a pointer
        ()  indicates a function
        []  indicates a array
     */
    
    
    /*
        Deciphering Complex Declarations
        - Always read declarations from the inside out.
        - When there's a choice, always favor [] and () over *(asterisk).
     */
    
    int* ap[10];    // Identifier ap is an array of pointers
    // int 포인터의 배열
    
    typedef int* pint;
    pint ap2[10];
    
    
    float* fp(float);   // fp is a function that returns a pointer
    // float을 매개변수를 갖고 return 값을 float 의 포인터로 갖는 함수의 포인터
    
    typedef float* pfloat;
    pfloat fp2(float);
    
    void (*pf)(int);
    /*
        void (*pf)(int);
               1            1. pointer to
                    2       2. function with int argument
          3                 3. returning void
     */
    // 정수형을 매개변수로 갖고 return 값이 없는 함수에 대한 포인터
    
    int* (*x[10])(void);
    /*
        int* (*x[10])(void);
                 1              1. array of
              2                 2. pointers to
                        3       3. functions with no arguments
        4                       4. returning pointer to int
     */
    // 매개변수가 없고 return 값이 int 의 포인터 값인 함수에 대한 포인터의 배열
    
    
    
    /* A Function can't return an array */
    
    // int f(int)[];    //Wrong
    
    /* BUT it can return a pointer to an array */
    
    int(*f(int))[];
    // ??
    
    
    
    /* A function can't return an function */
    
    //int g(int)(int);  //Wrong
    
    /* BUT it can return a pointer to a function */
    
    int (*g(int))(int);
    // 함수의 포인터 리턴 가능
    
    
    
    
    /* An array of functions aren't possible */
    
    //int a[10](int);   //Wrong
    
    /* BUT an array of function pointers are possible */
    
    int* (*x2[10])(int);
    // 함수의 포인터의 배열은 리턴 가능
    
    
    
    /* Using typedef to simplify declarations */
    
    typedef int* FCN(int);
    typedef FCN* FCN_PTR;
    typedef FCN_PTR FNC_PTR_ARRAY[10];
   FNC_PTR_ARRAY x3;
    
    return 0;
}

 

 

 

// More Examples
int board[6][4];    // an array of arrays of int
int** ptr;
    
int* risks[10];     // A 10-element array of pointers to int
int(*rusk)[10];     // A pointer to an array of 10 ints

int* off[3][4];     // A 4X3 array of pointers to int
// int pointer 들의 [3][4] 배열
int(*uff)[3][4];    // a pointer to a 3X4 array of ints
// int [3][4] 배열에 대한 포인터
int(*uof[3])[4];    // a 3-element array of pointers to 4-element arrays of int


char* fump(int);        // function returning pointer to char
char (*frump)(int);     // pointer to a function that returns type char
char(*flump[3])(int);   // array of 3 pointers to functions that return type char

typedef int arr5[5];
typedef arr5* p_arr5;
typedef p_arr5 arrp10[10];

arr5 togs;
p_arr5 p2;
arrp10 arp;

 

 

 

---

이 글의 모든 사진과 내용의 출처는 홍정모 교수님께 있음을 알려드립니다.

http://blog.naver.com/atelierjpro

실리콘 밸리의 프로그래머 : 네이버 블로그

http://www.inflearn.com/course/following-c

홍정모의 따라하며 배우는 C언어 - 인프런 | 강의