: How to interpret complex C/C++ declarations (http://www.codeproject.com/cpp/complex_declarations.asp)
int * (* (*fp1) (int) ) 10; 하 해한 회 ? C/C++
했 해하 한 . 평한 해 한
. 흔히 해 히 킬 const typedef 함
포 " " .
히 한 해할 .
한 하 해하 하 .
int a;
' n int 형 한' 해할 .
포 ,
int *p;
' p int *형 한' 해할 하 ' p int형 키 포 한' 할
. 포 (*) (&) 형 (int) (p) 항
. 하 하 할한 . (: C++ Bjarne
Stroustrup 형 호한 했.) (: 히 B. S. 호했 하 한
한 하 해 합. 크 하 한 . http://www.research.att.com/~bs/bs_faq2.html#whitespace )
int* p,q;
p q int 키 포형 (int *) . 하
p int 키 포형 q int형 . (: int *p; int *q;
하 히 편하.)
한 포 키 포 할 .
char **argv;
한히 . float형 키 포 키 포 키 포
할 . 해 .
. (: 해 호 . 한 표하
.)
int *q5;
p int형 하 크 4 키 포(a pointer to an array of 4 ints), q int형 포
하 크 5 (an array of 5 pointer to integers) .
const ( <-> 할 ? ) 하 해 하 키. const
하 화 해. 하 화할 .
const int n = 5;
int const m = 10;
n m const 형 . C++ 표 하
const 한 호합.
const 포 합 해. p, q .
const int *p;
int const *q;
, const int형 키 포 int형 키 const 포 해.
const int 키 포. int 형 키 const 포 .
int * const r = &n; // n int형
p q const int형 *p *q 할 . r const 포
r = &m 할하 합. ( m int형 ) *r
합.
합하 const int 형 키 const 포 하 하 .
const int * const p = &n; // n const int형
한 const 해할 하 . 하
화해 파 할 해할 하. (파 )
char ** p1; // pointer to pointer to char
const char **p2; // pointer to pointer to const char
char * const * p3; // pointer to const pointer to char
const char * const * p4; // pointer to const pointer to const char
char ** const p5; // const pointer to pointer to char
const char ** const p6; // const pointer to pointer to const char
char * const * const p7; // const pointer to const pointer to char
const char * const * const p8; // const pointer to const pointer to const char
typedef typedef "* & 형 " 하 해. typedef 하
typedef char * PCHAR;
PCHAR p,q;
p, q char 키 포 . typedef q char 키 포 char 형 텐 히 하 .
typedef 한 함 해.
typedef char * a; // a is a pointer to a char
//
// a
// char형 키 포
typedef a b(); // b is a function that returns
// a pointer to a char
//
// b
// char형 키 포 하
// 함
typedef b *c; // c is a pointer to a function
// that returns a pointer to a char
//
// c
// char형 키 포 하
// 함 키
// 포
typedef c d(); // d is a function returning
// a pointer to a function
// that returns a pointer to a char
//
// d
// char형 키 포 하
// 함 키
// 포 하
// 함
typedef d *e; // e is a pointer to a function
// returning a pointer to a
// function that returns a
// pointer to a char
//
// e
// char형 키 포 하
// 함 키
// 포 하
// 함 키
// 포
e var10; // var is an array of 10 pointers to
// functions returning pointers to
// functions returning pointers to chars.
//
// var
// char형 키 포 하
// 함 키
// 포 하
// 함 키
// 포 하 크 10
typedef 통 한 struct . struct 하 C++ C
struct 할 .
typedef struct tagPOINT
{
int x;
int y;
}POINT;
POINT p; /* C 효 */
해하 하 함 포 . 함 포 DOS
(TSR) 하 했 Win32 X-Windows callback 함 하 .
함 포 . 함 테, STL 템플 Win NT/2K/XP 템
. 한 해.
int (*p)(char);
p char 하 int 하 함 키 포(a pointer to a function that takes a char
argument and return an int) 합.
float 하 char 키 포 키 포 하 함 키 포(a pointer to a
function that take two floats and returns a pointer to a pointer to a char) 합.
char ** (*p)(float, float);
char 키 const 포 void 포 하 함 키 포 하 크 5
(an array of 5 pointers to functions that receive two const pointers to chars and return void pointer) 하
?
void * (*a5)(char * const, char * const);
하 한 한 해할 해.
호 한. 호 해 합. 호
합. ( : " " 확히 하 파하 . 함 포함하 호 ). 호 해 호 해 확
합. 해 합.
"Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the
direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole
declaration has been parsed."
항: 할 호 하
합.
합.
int * (* (*fp1) (int) ) 10;
1. 합. --- fp1
2. ) * --- 포. 포 3. 킵.
3. 호 (int) . --- 함 int .
4. * . - 함 포 하 포 4. 킵.
5. 호 10 . --- 크 10 .
6. * . --- 포 포 7. 킵.
7. int . --- 포 int형 킵.
표하 한 표하 힘. 합하 .
"fp1 int형 키 포 하 크 10 키 포 하 int 함
키 포".
1. Start from the variable name -------------------------- fp1
2. Nothing to right but ) so go left to find * -------------- is a pointer
3. Jump out of parentheses and encounter (int) --------- to a function that takes an int as argument
4. Go left, find * ---------------------------------------- and returns a pointer
5. Jump put of parentheses, go right and hit 10 -------- to an array of 10
6. Go left find * ----------------------------------------- pointers to
7. Go left again, find int -------------------------------- ints.
.
int *( *( *arr5)())();
1. 합. --- arr
2. 5 . --- 크 5 .
3. * . --- 포 4. 킵.
4. 호 () . --- 함 .
5. * . --- 함 포 하 포 6. 킵.
6. 호 () . --- 함 .
7. * . --- 함 포 하 포 8. 킵.
8. int . --- 포 int형 킵.
"arr int형 키 포 하 함 키 포 하
함 키 포 하 크 5 ".
1. Start from the variable name --------------------- arr
2. Go right, find array subscript --------------------- is an array of 5
3. Go left, find * ----------------------------------- pointers
4. Jump out of parentheses, go right to find () ------ to functions
5. Go left, encounter * ----------------------------- that return pointers
6. Jump out, go right, find () ----------------------- to functions
7. Go left, find * ----------------------------------- that return pointers
8. Continue left, find int ----------------------------- to ints.
( : - 해 해 한
.)
float ( * ( *b()) [] )(); // b is a function that returns a
// pointer to an array of pointers
// to functions returning floats.
//
// () b 함 포 합.
// 포 키 포.
// 포 함 키 함 float 합.
//
// () b float 하 함
// 키 포 하 키 포
// 하 함.
void * ( *c) ( char, int (*)()); // c is a pointer to a function that takes
// two parameters:
// a char and a pointer to a
// function that takes no
// parameters and returns
// an int
// and returns a pointer to void.
//
// () c 포 포 함 킵.
// 함 char형
// int형 하 함 키 포 합.
// 함 포 포 void 킵.
//
// () c void 키 포 하
// char형 int 하 함 키 포
// 함 키 포.
void ** (*d) (int &,
char **(*)(char *, char **)); // d is a pointer to a function that takes
// two parameters:
// a reference to an int and a pointer
// to a function that takes two parameters:
// a pointer to a char and a pointer
// to a pointer to a char
// and returns a pointer to a pointer
// to a char
// and returns a pointer to a pointer to void
//
// () d 포 포 함 킵.
// 함 int형 함 키 포 .
// 포 키 함
// char 키 포
// char 키 포 키 포
// char 키 포 키 포 합.
// 함 void 키 포 키 포 합.
//
// () d void 키 포 키 포 하
// int형
// char 키 포
// char 키 포 키 포
// char 키 포 키 포 하
// 함 하 함
// 키 포.
// ~~~
float ( * ( * e10)
(int &) ) 5; // e is an array of 10 pointers to
// functions that take a single
// reference to an int as an argument
// and return pointers to
// an array of 5 floats.
//
// () e 크 10 포.
// 포 함 키 함 int형
// 포 합.
// 포 크 5 키 float.
//
// () e float 하 크 5 키
// 포 하
// int형 하 함 키 포 하
// 크 10 .
클 함 포 .
해.
// that takes no argument and return an int
//
// () p 포 포 CFoo 클 함 킵.
// 함 int 해.
//
// () p int 해
// CFoo 클 함 키 포.
호 합.
int (__stdcall* q)(); // q is a pointer to a __stdcall function
// that takes no argument and return int
//
// () q 포 포 __stdcall 함 킵.
// 함 int 해.
//
// () q int 해
// __stdcall 함 키 포.
|}}
|}}
