a=7;b=8; c=max(a,b);

printf(\}

max(int x, int y) { int z;

z=x>y? x : y; return(z) ; }

运行结果为： Max is 8

指针 1.

# include < stdio .h > main ( )

{ int x[ ] = {10, 20, 30, 40, 50 }; int *p ; p=x;

printf ( ?%d?, *(p+2 ) ); } 运行结果为： 30

首先定义一个整型数组x，x的长度为5;然后定义一个指针变量p;对p进行初始化，将数组x的地址赋给p。因此此时p中存放的数组x的首地址，即数组中第一个元素x[0]的地址。 然后执行printf语句，输出表达式*(p+2)的值。p+2表示以p当前指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值30,因此输出30

2.

#include main( )

{ char s[]=?abcdefg?; char *p; p=s;

printf(?ch=%c\\n?,*(p+5)); }

运行结果为： ch=f

首先定义一个字符型数组s，并用字符串abcdefg对s进行初始化; 然后定义一个字符型指针

变量p; 对p进行初始化，将数组s的地址赋给p。因此此时p中存放的数组s的首地址，即数组中第一个元素s[0]的地址。

然后执行printf语句，输出表达式*(p+5)的值。p+5表示以p当前指向的位置起始，之后第5个元素的地址，即a[5]的地址。*(p+5)则表示该地址内所存放的内容，即a[5]的值f, 因此输出ch=f

3.

#include main ( )

{ int a[]={1, 2, 3, 4, 5} ； int x, y, *p； p=a；

x=*(p+2)；

printf(\：%d \\n\； }

运行结果为: 1:3

首先定义一个整型数组a，并对a进行初始化; 然后定义整型变量x,y，整型指针变量p; 再将数组a的地址赋给p。因此此时p中存放的数组a的首地址，即数组中第一个元素a[0]的地址。执行x=*(p+2)；p+2表示以p当前所指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值3，然后再把3赋给x

然后执行printf语句，先输出表达式*p的值。此时*p表示的是p所指向变量的内容，即a[0]的值1。再输出一个冒号。然后再输出x中的值3。

4.

#include main()

{ int arr[ ]={30,25,20,15,10,5}, *p=arr; p++;

printf(?%d\\n?,*(p+3)); }

运行结果为：10

首先定义一个整型数组arr，并对arr进行初始化; 然后定义整型指针变量p; 再将数组arr的地址赋给p。因此此时p中存放的数组arr的首地址，即数组中第一个元素a[0]的地址。

执行p++，即p=p+1。p+1表示以p当前所指向的位置起始，之后第1个元素的地址，即arr[1]的地址，然后再将arr[1]的地址赋给p，执行完此语句后，p不再指向arr[0]，而是指向arr[1]。 然后执行printf语句，输出表达式*(p+3)的值。p+3表示以p当前指向的位置起始(此时p指向arr[1])，之后第3个元素的地址，即arr[4]的地址。*(p+3)则表示该地址内所存放的内容，即arr[4]的值10, 因此输出10

5.

#include main( )

{ int a[ ]={1, 2, 3, 4, 5, 6}; int x, y, *p; p = &a[0]; x = *(p+2); y = *(p+4);

printf(?*p=%d, x=%d, y=%d\\n?, *p, x, y); }

运行结果为： *p=1, x=3, y=5

首先定义一个整型数组a，并对a进行初始化; 然后定义整型变量x,y，整型指针变量p; 再将数组元素a[0]的地址赋给p。

执行x=*(p+2)；p+2表示以p当前所指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值3，然后再把3赋给x 执行y = *(p+4); p+4表示以p当前所指向的位置起始，之后第4个元素的地址，即a[4]的地址。*(p+4)则表示该地址内所存放的内容，即a[4]的值5，然后再把5赋给y 执行printf语句，先输出表达式*p的值。此时*p表示的是p所指向变量的内容，即a[0]的值1。再输x的值3。再输出y的值5。

6.

#include main( )

{ static char a[ ]=?Program?, *ptr; for(ptr=a, ptr

运行结果为： Porm

首先定义一个字符型数组a，并对a进行初始化; 然后定义字符型指针变量p;

执行for语句 ptr=a为表达式1，将数字a的地址赋给ptr；表达式2（循环条件）ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第1个元素，即 a[0],因此*ptr表示a[0]中的值，即’P’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位 置起始，之后第2个元素的地址,即a[2]的地址，然后将a[2]的地址赋给ptr。a[2]的地 址等价于a+2，因此循环条件ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第3个元素，即 a[2],因此*ptr表示a[2]中的值，即’o’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位

置起始，之后第2个元素的地址,即a[4]的地址，然后将a[4]的地址赋给ptr。a[4]的地 址等价于a+4，因此循环条件ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第5个元素，即 a[4],因此*ptr表示a[4]中的值，即’r’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位

置起始，之后第2个元素的地址,即a[6]的地址，然后将a[6]的地址赋给ptr。a[6]的地址等价于a+6，因此循环条件ptr

执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第7个元素，即 a[6],因此*ptr表示a[6]中的值，即’m’.

执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位

置起始，之后第2个元素的地址,即a[8]的地址，然后将a[8]的地址赋给ptr。a[6]的地址等价于a+8，因此循环条件ptr

#include char s[]=?ABCD?; main()

{ char *p;

for(p=s;p

printf(?%c %s\\n?,*p,p);

}

运行结果为： A ABCD B BCD C CD D D

首先定义一个字符型数组s，并对s进行初始化; 数组s是全局变量，其有效范围从其定义开始至整个程序结束。

执行main函数

定义一个字符型指针p。

执行for语句 p=s为表达式1，将数字s的首地址赋给p；表达式2（循环条件）p

第1次执行循环体

执行printf(?%c %s\\n?,*p,p);即以字符%c形式输出*p所对应的字符。此时p指

向数组中的第1个元素，即s[0],因此*p表示a[0]中的值，即’A’. 然后再以字 符串%s的形式输出以p中地址为首地址的整个字符串，即输出ABCD

执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的

位置起始，之后1个元素的地址,即s[1]的地址，然后将a[1]的地址赋给p。 s[1]的地址等价于s+1，因此循环条件p