基础 

让我们从一个非常简单的例子开始，如下åQšÂ?

int n; 

˜q™ä¸ªåº”该被理解äؓ“declare n as an int”（n是一个int型的变量åQ‰ã€‚Â?

接下åŽÀL¥çœ‹ä¸€ä¸‹æŒ‡é’ˆå˜é‡ï¼Œå¦‚下åQšÂ?

int *p; 

˜q™ä¸ªåº”该被理解äؓ“declare p as an int *”（p是一个int *型的变量åQ‰ï¼Œæˆ–者说p是一个指向一个int型变量的指针。我惛_œ¨˜q™é‡Œå±•å¼€è®¨è®ºä¸€ä¸‹ï¼šæˆ‘觉得在声明一个指针（或引用）¾cÕdž‹çš„变量时åQŒæœ€å¥½å°†*åQˆæˆ–&åQ‰å†™åœ¨ç´§é å˜é‡ä¹‹å‰ï¼Œè€Œä¸æ˜¯ç´§è·ŸåŸºæœ¬ç±»åž‹ä¹‹åŽã€‚这样可以避免一些理解上的误区，比如åQšÂ?

int*  p,q; 

½W¬ä¸€çœ¼çœ‹åŽ»ï¼Œå¥½åƒæ˜¯på’Œq都是int*¾cÕdž‹çš„，但事实上åQŒåªæœ‰p是一个指针，而q是一个最½Ž€å•çš„int型变量。Â?

我们˜q˜æ˜¯¾l§ç®‹æˆ‘们前面的话题，再来看一个指针的指针的例子： 

char **argv; 

理论上，对于指针的çñ”数没有限åˆÓž¼Œä½ å¯ä»¥å®šä¹‰ä¸€ä¸ªæÕQ点类型变量的指针的指针的指针的指é’?.. 

再来看如下的声明åQšÂ?

int RollNum[30][4];
int (*p)[4]=RollNum;
int *q[5]; 

˜q™é‡ŒåQŒp被声明äؓ一个指向一ä¸?元素åQˆint¾cÕdž‹åQ‰æ•°¾l„的指针åQŒè€Œq被声明äؓ一个包å?个元素（int¾cÕdž‹çš„指针）的数¾l„。Â?

另外åQŒæˆ‘们还可以在同一个声明中混合实用*å’?amp;åQŒå¦‚下： 

int **p1; // p1 is a pointer  to a pointer  to an int. 
int *&p2; // p2 is a reference to a pointer  to an int. 
int &*p3; // ERROR: Pointer  to a reference is illegal. 
int &&p4; // ERROR: Reference to a reference is illegal. 

注：p1是一个int¾cÕdž‹çš„指针的指针åQ?br />      p2是一个int¾cÕdž‹çš„指针的引用åQ?br />      p3是一个int¾cÕdž‹å¼•ç”¨çš„指针（不合法！åQ‰ï¼›
      p4是一个int¾cÕdž‹å¼•ç”¨çš„引用（不合法！åQ‰ã€‚Â?

const修饰½W?br />当你想阻止一个变量被改变åQŒå¯èƒ½ä¼šç”¨åˆ°const关键字。在你给一个变量加上const修饰½W¦çš„同时åQŒé€šå¸¸éœ€è¦å¯¹å®ƒè¿›è¡Œåˆå§‹åŒ–åQŒå› ä¸ÞZ»¥åŽçš„ä»ÖM½•

时候你ž®†æ²¡æœ‰æœºä¼šå†åŽÀL”¹å˜å®ƒã€‚例如： 

const int n=5;
int const m=10; 

上述两个变量nå’Œm其实是同一¿Uç±»åž‹çš„--都是const intåQˆæ•´å½¢æ’量）。因为C++标准规定åQŒconst关键字放在类型或变量名之前等ä»ïLš„。我个äh

æ›´å–œ‹Æ¢ç¬¬ä¸€¿Uå£°æ˜Žæ–¹å¼ï¼Œå› äؓ它更½Hå‡ºäº†const修饰½W¦çš„作用。Â?

当const与指针一起ä‹É用时åQŒå®¹æ˜“让人感到迷惑。例如，我们来看一下下面的på’Œq的声明： 

const int *p;
int const *q; 

他们当中哪一个代表const int¾cÕdž‹çš„指针（const直接修饰intåQ‰ï¼Œå“ªä¸€ä¸ªä»£è¡¨int¾cÕdž‹çš„const指针åQˆconst直接修饰指针åQ‰ï¼Ÿå®žé™…上，på’Œqéƒ?

被声明äØ“const int¾cÕdž‹çš„指针。而int¾cÕdž‹çš„const指针应该˜q™æ ·å£°æ˜ŽåQšÂ?

int * const r= &n; // n has been declared as an int 

˜q™é‡ŒåQŒpå’Œq都是指向const int¾cÕdž‹çš„指针，也就是说åQŒä½ åœ¨ä»¥åŽçš„½E‹åºé‡Œä¸èƒ½æ”¹å?p的倹{€‚而r是一个const指针åQŒå®ƒåœ¨å£°æ˜Žçš„时候被初始化指

向变量nåQˆå³r=&n;åQ‰ä¹‹åŽï¼Œr的值将不再允许被改变（ä½?r的值可以改变）。Â?

¾l„合上述两种const修饰的情况，我们来声明一个指向const int¾cÕdž‹çš„const指针åQŒå¦‚下： 

const int * const p=&n // n has been declared as const int
//------------------------------------------------------------------------
下面¾l™å‡ºçš„一些关于const的声明，ž®†å¸®åŠ©ä½ å½Õdº•ç†æ¸…const的用法。不˜q‡è¯·æ³¨æ„åQŒä¸‹é¢çš„一些声明是不能被编译通过的，因äؓ他们需要在声明

的同时进行初始化。äؓ了简‹zè“v见，我忽略了初始化部分；因äؓ加入初始化代码的话，下面每个声明都将增加两行代码。Â?

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 

注：
p1是指向char¾cÕdž‹çš„指针的指针åQ?br />p2是指向const char¾cÕdž‹çš„指针的指针åQ?br />p3是指向char¾cÕdž‹çš„const指针åQ?br />p4是指向const char¾cÕdž‹çš„const指针åQ?br />p5是指向char¾cÕdž‹çš„指针的const指针åQ?br />p6是指向const char¾cÕdž‹çš„指针的const指针åQ?br />p7是指向char¾cÕdž‹const指针的const指针åQ?br />p8是指向const char¾cÕdž‹çš„const指针的const指针ã€?br />//------------------------------------------------------------------------
typedef的妙ç”?br />typedef¾l™ä½ ä¸€¿Uæ–¹å¼æ¥å…‹æœâ€?只适合于变量而不适合于类型”的弊端。你可以如下使用typedefåQšÂ?

typedef char * PCHAR;
PCHAR p,q; 

˜q™é‡Œçš„på’Œq都被声明为指针。（如果不ä‹É用typedefåQŒqž®†è¢«å£°æ˜Žä¸ÞZ¸€ä¸ªchar变量åQŒè¿™è·Ÿæˆ‘们的½W¬ä¸€çœ¼æ„Ÿè§‰ä¸å¤ªä¸€è‡ß_¼åQ‰ä¸‹é¢æœ‰ä¸€äº›ä‹É用typedef

的声明，òq¶ä¸”¾l™å‡ºäº†è§£é‡Šï¼šÂ 

typedef char * a; // a is a pointer to a char 

typedef a b();   // b is a function that returns 
          // a pointer to a char 

typedef b *c;   // c is a pointer to a function 
          // that returns a pointer to a char 

typedef c d();   // d is a function returning 
          // a pointer to a function 
          // that returns a pointer to a 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 var[10];     // var is an array of 10 pointers to 
          // functions returning pointers to 
          // functions returning pointers to chars. 

typedef¾lå¸¸ç”¨åœ¨ä¸€ä¸ªç»“构声明之前，如下。这æ øP¼Œå½“创建结构变量的时候，允许你不使用关键字structåQˆåœ¨C中，创徏¾l“构变量时要求ä‹É用str

uct关键字，如struct tagPOINT aåQ›è€Œåœ¨C++中，struct可以忽略åQŒå¦‚tagPOINT båQ‰ã€‚Â?

typedef struct tagPOINT
{
  int x;
  int y;
}POINT; 

POINT p; /* Valid C code */
//------------------------------------------------------------------------
函数指针 

函数指针可能是最å®ÒŽ(gu¨©)˜“引è“v理解上的困惑的声明。函数指针在DOS时代写TSR½E‹åºæ—¶ç”¨å¾—最多；在Win32å’ŒX-Windows时代åQŒä»–们被用在需要回è°?函数的场合。当ç„Óž¼Œ˜q˜æœ‰å…¶å®ƒå¾ˆå¤šåœ°æ–¹éœ€è¦ç”¨åˆ°å‡½æ•°æŒ‡é’ˆï¼šè™šå‡½æ•°è¡¨åQŒSTL中的一些模板，Win NT/2K/XP¾pȝ»ŸæœåŠ¡½{‰ã€‚让我们来看一个函数指é’?

的简单例子： 

int (*p)(char); 

˜q™é‡Œp被声明äؓ一个函数指针，˜q™ä¸ªå‡½æ•°å¸¦ä¸€ä¸ªchar¾cÕdž‹çš„参敎ͼŒòq¶ä¸”有一个int¾cÕdž‹çš„返回倹{€‚另外，带有两个float¾cÕdž‹å‚数、返回值是char

¾cÕdž‹çš„指针的指针的函数指针可以声明如下： 

char ** (*p)(float, float); 

那么åQŒå¸¦ä¸¤ä¸ªchar¾cÕdž‹çš„const指针参数、无˜q”回值的函数指针又该如何声明呢？参考如下： 

void * (*a[5])(char * const, char * const); 

“右左法则”[重要åQï¼åQ] 

The right-left rule: 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. 

˜q™æ˜¯ä¸€ä¸ªç®€å•çš„法则åQŒä½†èƒ½è®©ä½ å‡†¼‹®ç†è§£æ‰€æœ‰çš„声明。这个法则运用如下：从最内部的括号开始阅è¯Õd£°æ˜Žï¼Œå‘右看，然后向左看。当你碰åˆîC¸€

个括åäh—¶ž®Þp°ƒè½¬é˜…è¯Èš„方向。括号内的所有内定wƒ½åˆ†æžå®Œæ¯•ž®ÞpŸ©å‡ºæ‹¬åïLš„范围。这æ ïL‘ô¾l­ï¼Œç›´åˆ°æ•´ä¸ªå£°æ˜Žéƒ½è¢«åˆ†æžå®Œæ¯•ã€‚Â?

对上˜q°â€œå³å·¦æ³•åˆ™â€åšä¸€ä¸ªå°ž®çš„修正åQšå½“你第一‹Æ¡å¼€å§‹é˜…è¯Õd£°æ˜Žçš„时候，你必™åÖM»Žå˜é‡åå¼€å§‹ï¼Œè€Œä¸æ˜¯ä»Žæœ€å†…部的括受÷€‚Â?

下面¾l“合例子来演½CÞZ¸€ä¸‹â€œå³å·¦æ³•åˆ™â€çš„使用。Â?

int * (* (*fp1) (int) ) [10]; 

阅读步骤åQ?br />1. 从变量名开å§?-------------------------------------------- fp1 2. 往右看åQŒä»€ä¹ˆä¹Ÿæ²¡æœ‰åQŒç¢°åˆîCº†)åQŒå› æ­¤å¾€å·¦çœ‹åQŒç¢°åˆîC¸€ä¸? ------ 一个指é’?br />3. è·›_‡ºæ‹¬å·åQŒç¢°åˆîCº†(int) ----------------------------------- 一个带一个int参数的函æ•?br />4. 向左看，发现一ä¸? --------------------------------------- åQˆå‡½æ•ŽÍ¼‰˜q”回一个指é’?br />5. è·›_‡ºæ‹¬å·åQŒå‘右看åQŒç¢°åˆ°[10] ------------------------------ 一ä¸?0元素的数¾l?br />6. 向左看，发现一ä¸? --------------------------------------- 指针
7. 向左看，发现int ----------------------------------------- int¾cÕdž‹Â 

æ€È»“åQšfp1被声明成ä¸ÞZ¸€ä¸ªå‡½æ•°çš„指针,该函数返回指向指针数¾l„的指针. 

再来看一个例子： 

int *( *( *arr[5])())(); 

阅读步骤åQ?br />1. 从变量名开å§?-------------------------------------------- arr 2. 往右看åQŒå‘现是一个数¾l?---------------------------------- 一ä¸?元素的数¾l?br />3. 向左看，发现一ä¸? --------------------------------------- 指针
4. è·›_‡ºæ‹¬å·åQŒå‘右看åQŒå‘çŽ?) -------------------------------- 不带参数的函æ•?br />5. 向左看，¼„°åˆ°* ------------------------------------------- åQˆå‡½æ•ŽÍ¼‰˜q”回一个指é’?br />6. è·›_‡ºæ‹¬å·åQŒå‘叛_‘çŽ?) ------------------------------------ 不带参数的函æ•?br />7. 向左åQŒå‘çŽ? --------------------------------------------- åQˆå‡½æ•ŽÍ¼‰˜q”回一个指é’?br />8. ¾l§ç®‹å‘å·¦åQŒå‘现int --------------------------------------- int¾cÕdž‹Â 

æ€È»“åQšï¼ŸåQŸÂ?

˜q˜æœ‰æ›´å¤šçš„例子： 

float ( * ( *b()) [] )();       // b is a function that returns a 
                            // pointer to an array of pointers 
                            // to functions returning floats. 

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. 

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 

float ( * ( * e[10]) 
  (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.  

上例中的scanf()函数先读一个整型数, 然后把接着输入的逗号剔除� 最
后读入另一个整型数。如果â€?”这一特定字符没有扑ֈ°, scanf()函数ž®Þq»ˆæ­¢ã€‚è‹¥
参数之间的分隔符为空æ ? 则参æ•îC¹‹é—´å¿…™å»è¾“入一个或多个½Iºæ ¼ã€?br />说明:
(1). 对于字符串数¾l„或字符串指针变é‡? ç”׃ºŽæ•°ç»„名和指针变量名本íw«å°±
是地址, 因此使用scanf()函数� 不需要在它们前面加上�amp;”操作符�br />�
mian()
{
char *p, str[20];
scanf(â€?sâ€? p); /*从健盘输入字½W¦ä¸²*/
scanf(�s� str);
printf(â€?s\nâ€? p); /*向屏òq•è¾“出字½W¦ä¸²*/
printf(�s\n� str);
}

(2). 可以在格式化字符串中的�”各格式化规定符之间加入一个整� 表示
ä»ÖM½•è¯ÀL“ä½œä¸­çš„最大位数ã€?br />如例3中若规定只能输入10字符¾l™å­—½W¦ä¸²æŒ‡é’ˆp, 则第一条scanf() 函数语句
变äØ“
scanf(�10s� p);
½E‹åº˜qè¡Œæ—¶ä¸€æ—¦è¾“入字½W¦ä¸ªæ•°å¤§äº?0, pž®×ƒ¸å†ç‘ô¾l­è¯»å…? 而后面的一个读
入函数即scanf(â€?sâ€? str)ž®×ƒ¼šä»Žç¬¬11个字½W¦å¼€å§‹è¯»å…¥ã€?br />实际使用scanf()函数时存在一个问é¢? 下面举例˜q›è¡Œè¯´æ˜Ž:
当ä‹É用多个scanf()函数˜qžç®‹¾l™å¤šä¸ªå­—½W¦å˜é‡è¾“入时, 例如:
main()
{
char c1, c2;
scanf(�c� &c1);
scanf(�c� &c2);
printf(”c1 is %c, c2 is %c� c2\1, c2);
}

˜qè¡Œè¯¥ç¨‹åº? 输入一个字½W¦A后回è½?(要完成输入必™åÕd›žè½?, 在执行scanf
(â€?câ€? &c1)æ—? ¾l™å˜é‡c1赋值”Aâ€? 但回车符仍然留在¾~“冲区内, 执行输入语句
scanf(â€?câ€? &c2)æ—? 变量c2输出的是一½Iø™¡Œ, 如果输入AB后回è½? 那么输出¾l?br />æžœäØ“: c1 is A, c2 is Bã€?br />要解决以上问é¢? 可以在输入函数前加入清除函数fflush()( ˜q™ä¸ªå‡½æ•°çš„ä‹É
用方法将在本节最后讲˜q?。修改以上程序变æˆ?
#include<stdio.h>
main()
{
char c1, c2;
scanf(�c� &c1);
fflush(stdin);
scanf(�c� &c2);
printf(”c1 is %c, c2 is %c� c1, c2);
}

1.1.2 非格式化输入输出函数
非格式化输入输出函数可以ç”׃¸Šé¢è®²˜q°çš„标准格式化输入输出函æ•îC»£æ›? ä½?br />˜q™äº›å‡½æ•°¾~–译后代码少, 相对占用内存也小, 从而提高了速度, 同时使用也比è¾?br />方便。下面分别进行介¾lã€?br />一、puts()å’Œgets()函数
1. puts()函数
puts()函数用来向标准输å‡ø™®¾å¤?屏幕)写字½W¦ä¸²òq¶æ¢è¡? 其调用格式äØ“:
puts(s);
其中s为字½W¦ä¸²å˜é‡(字符串数¾l„名或字½W¦ä¸²æŒ‡é’ˆ)ã€?br />puts()函数的作用与语printf(â€?s\nâ€? s)相同ã€?br />ä¾?:
main()
{
char s[20], *f; /*定义字符串数¾l„和指针变量*/
strcpy(s, “Hello! Turbo C2.0â€?; /*字符串数¾l„变量赋å€?/
f=”Thank you� /*字符串指针变量赋�/
puts(s);
puts(f);
}

说明:
(1). puts()函数只能输出字符ä¸? 不能输出数值或˜q›è¡Œæ ¼å¼å˜æ¢ã€?br />(2). 可以ž®†å­—½W¦ä¸²ç›´æŽ¥å†™å…¥puts()函数中。如:
puts(”Hello, Turbo C2.0�;

2. gets()函数
gets()函数用来从标准输入设å¤?键盘)è¯Õd–字符串直到回车结æ? 但回车符
不属于这个字½W¦ä¸²ã€‚其调用格式ä¸?
gets(s);
其中s为字½W¦ä¸²å˜é‡(字符串数¾l„名或字½W¦ä¸²æŒ‡é’ˆ)ã€?br />gets(s)函数与scanf(â€?sâ€? &s)ç›æ€¼¼, 但不完全相同, 使用scanf(â€?sâ€? &s)
函数输入字符串时存在一个问é¢? ž®±æ˜¯å¦‚果输入了空æ ég¼šè®¤äؓ输入字符串结æ?
½Iºæ ¼åŽçš„字符ž®†ä½œä¸ÞZ¸‹ä¸€ä¸ªè¾“入项处理, 但gets() 函数ž®†æŽ¥æ”¶è¾“入的整个字符
串直到回车äØ“æ­¢ã€?br />ä¾?
main()
{
char s[20], *f;
printf(”What’s your name?\n�;
gets(s); /*½{‰å¾…输入字符串直到回车结æ?/
puts(s); /*ž®†è¾“入的字符串输å‡?/
puts(”How old are you?�;
gets(f);
puts(f);
}