11.3嵌入式C语言

day3

1、

int a[]={0,1,2,3,4,5,6,7,8,9},*p=a,i;

其中0<=i<=9,则对a数组元素的引用不正确的是：
a[p-a] *(&a[i]) p[i] *(*(a+i))

a[p-a] = a[0] //p-a=? int*-int* =0//0就是整数0，（p地址-a地址《转10》）/类型字节数，p和a可以运算的前提是俩个指针类型相同。
*(&a[i]) = a[i]
p[i]=*(p+1)
 *(*(a+i)):*(a+i)已经对地址解引用了，*(a+i)是数据值，不能再进行解引用

**2、**给数组所有元素输入数据：

int a[10],i=0;
while(i<10)
    scanf("%d",    );

应填入：
a+(i++) &a[i+1] a+i &a[++i]

3、

int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
printf("%d\n",*(p+2));

程序输出结果是
3 4 1 2

4、

int a[]={2,4,6,8,10},y=1,x,*p;  
p=&a[1];
for(x=0;x<3;x++) 
	y+=*(p+x);  
printf("%d\n",y);

程序的输出结果为
17 18 19 20

p=&a[1];//p中存的是元素4的首地址
y+=*(p+x);//y = y+*(p+x);
//y=1;x=0;y=5;
//x=1;y=5+6=11;
//x=2;y=11+8=19;

5、

若有定义int c[4][5],(*cp)[5];和语句cp=c;,
则能正确引用c数组元素的是: 
cp+1        *(cp+3)       *(cp+1)+3              *(*cp+2)√

//c作为指针类型，为数组中第一个元素的地址,类型int [5] *，也就是int (*)[5],将其赋值给变量cp，int (*)[5] cp=c;
//cp+1；第二个元素地址
//*(cp+3)；cp+3为第四个元素地址，*对其解引用，取出其值
//*(cp+1)+3：cp+1为第二个元素的值，对其解引用，再+1，数组+数字（×
//*(*cp+2)：cp为数组首地址，解引用得到第一个元素的值，+2，同上

6、若有定义：int x,*pb;则正确的赋值表达式是：pb=&x

pb=&x     pb=x    *pb=&x      *pb=*x

7、printf(“%d\n”,NULL);输出结果是
因变量无定义输出不定值 0 -1 1

在ASCII码与Unicode码的第一个字符是NULL,它的数值是0。
C语言把它作为字符串的最后一个字符,以表示字符串到此结束。不可见字符通常用反斜杠‘\’+其ASCII码值表示，故NULL常用“\0”表示，另外，在C语言的头文件stdio.h中，NULL被宏定义为0。

8、

void sub(int x,int y,int *z)  
{
	*z=y-x;
}

main()
{
	int a,b,c;
	sub(10,5,&a);//x=10,y=5,z=&a;*z=*(&a)=5-10=-5=a;     
	sub(7,a,&b);//x=7,y=-5,z=&b;*z=*(&b)=-5-7=-12=b;     
	sub(a,b,&c);//x=-5,y=-12,z=&c;*z=*(&c)=-12-(-5)=-7    
	printf("%d,%d,%d\n",a,b,c);
}

程序输出结果是：-5，-12，-7
5,2,3 -5，-12，-7 -5，-12，-17 5，-2，-7

9、

main()
{
	int k=2,m=4,n=6,*pk=&k,*pm=&m,*p;
	n=k*(m); //
    printf("%d\n",n);      
}

程序输出结果为
4 6 8 10

10、

void prtv(int *x)
{
	printf("%d\n",++*x);//x=&a;++*(&a)=++a=26//++*x同级单目，谁挨得近就先算谁。
    										 //*x++一样近，先++，再*
}
main()
{
	int a=25;
	prtv(&a);
}

程序输出结果是：26
23 24 25 26

11、

void sub(double x,double *y,double *z) //x=6.5,y=&a,z=&b
	*y=*y-1.0;    //*(&a)=*(&a)-1.0;a=a-1.0=1.5
	*z=*z+x;  	  //*(&a)=*(&a)+6.5;a=a+6.5=1.5+6.5=8
}
main()
{
	double a=2.5,b=9.0,*pa,*pb;
	pa=&a;   pb=&b;
	sub(b-a,pa,pa);//sub(6.5,&a,&b)× sub(6.5,&a,&a)
    printf("%f\n",a);
}

程序的输出结果是：8.000000
9.000000 1.500000 8.000000 10.500000

12、设有定义语句：char a=‘\72’;，则变量a：
包含1个字符 包含2个字符 包含3个字符 定义不合法

八进制72对应十进制58对应ASCII值为":"

13、C语言中，下列不合法的字符常量是
‘\xff’ ‘\65’ ‘&’ ‘\028’

下面三个都是转义字符，'\o'、'\oo'、'\ooo'形式表示与该八进制码对应的ASCII字符，o表示一个八进制数；'\x'开头表示与该十六进制码对应ASCII字符
'\xff' :\x 开头十六进制
'\65' ：八进制
'\028'：不是x开头，那就是八进制，但是八进制数逢8进1，最大为7所以错误

14、C语言中，下列不合法的字符串常量是： ‘y=’
“\121” ‘y=’ “\n\n” “ABCD\x6d”

''里面的值只能是单个字符

**15、**判断char型变量c是否为大写字母的最简单且正确的表达式是
‘A’<=c<=‘Z’ (c>=‘A’)||(c<=‘Z’) (‘A’<=c)AND(‘Z’>=c) (c>=‘A’)&&(c<=‘Z’)

16、char x=‘A’;
x=(x>=‘A’&&x<=‘Z’)?(x+32):x;
printf(“%c\n”,x);
程序的输出结果是： a
A a Z z

大写字母的ASCII码+32就是其对应的小写字母
另：''的ASCII码就是32

17、以下能正确进行字符串赋值、赋初值的语句组是
char s[5]={‘a’,‘e’,‘i’,‘o’,‘u’}; *char s;s=“good!”; char s[5]=“good!”; char s[5];s=“good”；

char s[5]={'a','e','i','o','u'}; //字符串是以'\0'结尾的，这个数组作为字符数组来看没有问题，但不能成为一个字符串
char *s;s="good!";//这里字符串作地址保存在指针变量s中,是一个字符指针。并且不是直接将字符串的值赋值给指针变量s，而是将字符串保存在内存中的常量区，再将其地址赋值给指针变量。由于字符串被保存在常量区，因此不能通过*s[i]的方式修改字符串的值。
char s[5]="good!"; //s为长度为5的字符数组，但是后面的字符串中有6个字符
char s[5];s="good"；//数组在赋值时有几种方式 1）定义时直接赋值 2）定义时部分赋值 3）先定义，后面逐个赋值；不可以先定义，后面再一次性赋值。所以s="good"；或者s[5]="good"；都是不对的。并且数组名是地址常量，不能改变其值。

一个数组在声明未初始化后，只能通过下标进行赋值。

18、

设有定义：char str[]="ABCD",*p=str;则语句printf("%d\n",*(p+4));的输出结果是

68 0 字符D的地址 不确定的值

*p=str;//str作为指针类型，将str（也就是数组中第一个元素的首地址）赋值给指针变量p
*(p+4) //p+4=p[4],为数组中第5个元素的地址，第五个元素是字符'\0',以%d格式输出为0

19、

语句printf("%d\n",strlen("ATS\n012\1\\"));的输出结果是

11 10 9 8

strlen("ATS\n012\1\\");
// \n表示换行符，占一个字节
// \1表示一个八进制数对应的ASCII码的字符，占一个字节
// \\表示\，意思是让'\'就表示'\'，防止其转义，如果只写一个\,strlen("ATS\n012\1\");那么\就和后面的"结合，虽然\"是为了让"不被转义好像也说得通，但是，括号里就少了一个"了，语法就出现错误了。
"ATS\n012\1\\"
 123 4567 8 9

20、

void fun(char *w,int m)//参数（w：数组首地址，m：数组长度）
{
	char s,*p1,*p2;
	p1=w;//数组首地址A
    p2=w+m-1;//数组中G地址
	while(p1<p2)
	{
		s=*p1++;
        *p1=*p2--;
        *p2=s; 
	}
}

//p1:A位置 B位置 C位置
//*p1:	    A   
//s:	    A
//p2:G位置 F位置
//*p2:	   A(G)

main()
{
	char a[]="ABCDEFG";     
	fun(a,strlen(a));
	puts(a);
}

程序运行后的输出结果是
GFEDCBA AGADAGA AGAAGAG GAGGAGA

21、设有定义语句：char * aa[2]={“abcd”,“ABCD”};//字符指针数组，存的是字符串的地址
则以下叙述正确的是
aa数组元素的值分别是字符串“abcd”“ABCD” //值是两个指针
aa是指针变量，他指向含有两个数组元素的字符型一维数组//指针型一维数组
aa数组的两个元素分别存放的是含有四个字符的一维数组的首地址（五个字符）
aa数组的两个元素中各自存放‘a’和‘A’的地址。。

char * arr[3];//arr[3]是一个数组，里面存放指针的指针数组
char (*arr)[3];//arr是一个指针，指向某一个数组的数组指针

这两种做+1操作
    char * arr[3]；  arr+1==>char ** +1 ==>跳过一个char *==》arr[1]的地址 arr是数组中第一个元素的地址，第一个元素是char *类型，所以，arr是char **类型
    char (*arr)[3];  arr+1==>char(*)[3]+1==>跳过1个char [3]

**22、**若变量已正确定义，在执行以下while语句时，输入字符A后，ch的值是： 0
while(ch=getchar()==‘A’);

getchar()输入一个字符，返回其对应ASCII码
    输入A，然后按了回车,
1、getchar()先拿到A，getchar()=='A'为真，结果为1，则ch=1，此时while中条件为真，继续循环执行条件判断，输入A后按了回车，getchar()=='A'为假，结果为0，ch=0，while中条件不成立，退出循环，所以ch=0
2、注意while循环是只有当条件不成立是才会跳出循环

23、以下fun函数的功能是将一个字符串的内容颠倒过来，请填空。

#include <stdio.h>
#include <string.h>

void fun(char str[5])//str[5]中的5没有用,不能限制长度欸
{
	int i,j,k;//通过strlen()计算出字符串除'\0'之外的长度，再-1得到最后一个字符的下标
	for(i=0, j=strlen(str)-1 ;i<j;i++, j--)
	{
		k=str[i];//i=0，str[0]字符串的第一个字符，保存到k中
		str[i]=str[j];//j=4,str[3]字符串最后一个字符，赋值给str[0]
		str[j]=k;//k中保存的str[0]再赋值给str[3]
	}
}

24、编写函数，对具有10个整数的数组进行如下操作：从下标为n的元素开始直到最后一个元素，依次向前移动一个位置。输出移动后的结果

  1 #include <stdio.h>                                                          
  2 
  3 void move(int arr[],int num)
  4 {
  5     int i;
  6     for(i=num;i<10;i++)
  7         arr[i-1] = arr[i];
  8 
  9     return;
 10 }
 11 
 12 int main(void){
 13     int arr[10]={1,2,3,4,5,6,7,8,9,10};
 14     int num,i;
 15     scanf("%d",&num);
 16     move(arr,num);
 17     for(i=0;i<10;i++)
 18         printf("%d ",arr[i]);
 19     printf("\n");
 20     return 0;
 21 }

fun(int a[],int n){ 
    int i;
	for(i=n;i<9;i++)
        a=a[i+1];
}

main(){
	int a[10]={0,1,2,3,4,5,6,7,8,9},n,i;
    scanf(“%d”,&n);
    fun(a,n);
	for(i=0;i<9;i++)//为啥i<9?
        printf(“%d ”,a);
}

25、编写函数，对字符数组中的字母按由大到小的字母顺序进行排序。

  1 #include<stdio.h>
  2 #define NUM 6
  3 
  4 void sort(char *a,int n)
  5 {
  6     int i,j,p,t;
  7     for(j=0;j<n-1;j++)
  8     {
  9         p=j;//用来保存当前轮的最大值的下标
 10         for(i=j+1;i<n;i++)
 11         {
 12             if(a[p]<a[i])
 13             {
 14                 p = i;
 15             }
 16 
 17         }
 18         if(p != j)
 19         {
 20             t = a[j];
 21             a[j] = a[p];
 22             a[p]=t;
 23         } 
 24     }
 25 }
 26 void arrout(char *w,int m)
 27 {
 28     int i;                                                                  
 29     for(i=0;i<m;i++)
 30     {
 31         printf("%c ",w[i]);
 32 
 33     }
 34     printf("\n");
 35 
 36 }
 37 int main(void){
 38     char arr[NUM]={'a','b','c','d','e','f'};
 39     arrout(arr,NUM);
 40     sort(arr,NUM);
 41     arrout(arr,NUM);
 42     return 0;
 43 }

26、编写函数，把数组中所有奇数放在另一个数组中返回。

  1 #include<stdio.h>
  2 #define NUM 6
  3 
  4 int jishu(int *w,int *b,int m)
  5 {
  6     int i,n,j=0;
  7     for(i=0;i<m;i++)
  8     {
  9         if(w[i]%2 != 0){
 10             b[j]=w[i];
 11             j++;
 12         }                                                                   
 13     }
 14     return j;
 15 
 16 }
 17 void arrout(int *w,int m)
 18 {
 19     int i;
 20     for(i=0;i<m;i++)
 21     {
 22         printf("%d ",w[i]);
 23 
 24     }
 25     printf("\n");
 26 
 27 }
 28 int main(void){
 29     int arr[NUM]={1,2,3,4,5,6},brr[NUM]={};
 30     int num = jishu(arr,brr,NUM);
 31     arrout(brr,num);
 32     return 0;
 33 }

27、请编写函数，其功能是对传送过来的两个浮点数求出和值与差值，并通过形参传送回调用函数。

  1 #include<stdio.h>                                                           
  2 void fun(double a,double b,double *x,double *y)
  3 {
  4     *x = a + b;
  5     *y = a - b;
  6 }
  7 
  8 int main(void){
  9     double a,b,x,y;
 10     scanf("%lf %lf",&a,&b);//输入两个浮点数
 11     fun(a,b,&x,&y);//&x,&y用来保存两个结果的地址
 12     printf("%f %f\n",x,y);
 13     return 0;
 14 }

28、请编写函数，对传送过来的三个数选出最大数和最小数，并通过形参传回调用函数。

  2 #include<stdio.h>
  3 void fun(double a,double b,double c,double *max,double *min)
  4 {
  5     *max = a > b?(a>c?a:c):(b>c?b:c);
  6     *min = a < b?(a<c?a:c):(b<c?b:c);
  7 }
  8 
  9 int main(void){
 10     double a,b,c,max,min;
 11     scanf("%lf %lf %lf",&a,&b,&c);
 12     fun(a,b,c,&max,&min);
 13     printf("max=%f min=%f\n",max,min);
 14     return 0;
 15 }

29、请编写程序，输入一行字符，输出每个字符以及与之对应的ASCII代码值，每行输出三对。

  1 #include <stdio.h>
  2 
  3 int main(void){                                                             
  4     char ch;
  5     int i = 0;
  6     while((ch=getchar())!='\n'){
  7         printf("%c--%d ",ch,ch);
  8         i++;
  9         if(i%3==0)
 10             printf("\n");
 11     }
 12     printf("\n");
 13     return 0;
 14 }

30、请编写程序统计输入的行数，用!号结束输入，！号所在行不计入行数

  1 #include <stdio.h>
  2 int main(void)
  3 {
  4     char x;
  5     int k = 0;                                                            
  6     while((x=getchar()) != '!')
  7     {
  8         if(x == '\n')
  9             k++;
 10     }
 11     printf("%d行\n",k);
 12     return 0;
 13 }

31、请编写程序统计输入的一行中小写字母的个数

  1 #include<stdio.h>
  2 #include<ctype.h>
  3 int main(void){
  4     char ch;
  5     int n=0;
  6     while((ch = getchar())!='\n'){
  7         if(islower(ch)){
  8             n++;
  9         }
 10     }
 11     printf("小写字母的个数：%d\n",n);                                       
 12 
 13     return 0;
 14 }

32、请编写输出以下图案的程序，图案的行数由输入的整数值确定。
A
BBB
CCCCC
DDDDDDD
EEEEEEEEE
…

#include <stdio.h>

int main(void)
{
	int i, j, n;
	printf("请输入图案的行数：");
	scanf("%d", &n);

	for (i = 1; i <= n; i++)
	{
		for (j = 0; j < n-i; j++)
		{
			printf("%c", '\0');
		}
		for (j = 0; j < 2*i-1; j++)
		{
			printf("%c", 64+i);
		}
		printf("%c", '\n');
	}
	return 0;
}

33、请编写输出以下图案的程序。
A
ABA
ABCBA
ABCDCBA

34、请编写函数mygets和myputs，其功能分别与gets和puts相同，函数中用getchar和putchar读入和输出字符。

getchar()并不是直接从键盘读取数据，用户输入数据时，getchar()处于待命状态。这些数据会先被暂存于缓冲区，当用户输入“\n”,即按下回车键时，getchar()开始从缓冲区读取数据，只读取一个字符，getchar()可以读取“\n”。
    用户输入字符串，并按下回车键之后，getchar才开始工作，他会从缓冲区读取用户刚才输入的字符串的第一个字符。
    getchar()函数的一个应用，弥补scanf()存在的问题。
    当用户按下回车键，scanf()函数接到“\n”作为信号开始接收完全部字符串后，它并不会接收“\n”本身，该字符仍留在缓存中。由此可以扩展出getchar()函数的新用法：清理缓冲区中多余的字符。程序会使用getchar()函数不断读取缓冲区中的字符到tmp中，直到缓冲区中没有字符为止。

getchar()是一个一个读取字符
scanf("%s",arr);//可以直接输入字符串对数组进行赋值。因此数组里含有字符串的最后一个元素'\0'i

  1 #include <stdio.h>                                                          
  2 #include <string.h>
  3 void mygets(char *s){
  4     char c;//保存每次读入的字符
  5     //通过getchar函数读入字符
  6     //因为getchar一次只读取一个字符，所以要对此操作进行循环，直到用户回车为>    止。使用while循环，当用户输入数据并按下回车键后，数据保存在缓冲区，getchar会
    不断读取缓冲区中的字符到tmp中，直到遇到'\n'退出循环。（getchar从缓冲区读取到
    一个字符后，该字符就从缓冲区清除了）
  7     while((c=getchar())!='\n')
  8         *s++ = c;
  9 
 10     //全部读出之后要给字符串加上'\0'
 11     *s = '\0';
 12 }
 13 void myputs(const char *s){
 14     //通过putchar进行输出，函数的参数为字符数组的元素，从第一个元素开始，只>    要输出的字符不为0（为0说明到了字符串末尾'\0'，同时结果为0，为假，此时结束循>    环），条件成立就会继续循环，直到遇到'\0'结束循环。
 15     while(putchar(*s++) != '\0');
 16 
 17 }
 18 int main(void){
 19     char arr[50]={0};
 20     mygets(arr);//向mygets函数传入数组地址，用于输入字符后保存在数组
 21     printf("myputs:\n");
 22     myputs(arr);//将保存字符后的数组传入myputs函数输出字符
 23     myputs("\n");
 24     printf("arr_len:%lu\n",strlen(arr));
 25     printf("arr:%s\n",arr);
 26     return 0;
 27 }

35、请编写函数，判断一字符串是否是回文。若是回文，函数返回值为1；否则返回值为0.回文是顺读和倒读都一样的字符串。

  1 #include <stdio.h>
  2 #include<string.h>
  3 int huiwen(char *s){
  4     int i,j;//i字符串中第一个实际元素下标，j最后一个
  5     for(i=0,j=strlen(s)-1;i<j;i++,j--){
  6         if(s[i]==s[j])
  7             return 1;
  8         else
  9             return 0;
 10     }
 11 
 12 }
 13 
 14 int main(void){
 15     char s[80]={0};
 16     scanf("%s",s);
 17     int res = huiwen(s);
 18     printf("%d\n",res);
 19                                                                           
 20     return 0;
 21 }

36、请编写函数，删除字符串中指定位置（下标）上的字符。删除成功函数返回被删字符；否则返回空值。

  1 #include<stdio.h>                                                           
  2 #include<string.h>
  3 char delete(char *arr,int num)
  4 {
  5     int i;
  6     char ch = arr[num];
  7     if(num > strlen(arr)-1||num < 0)
  8         return 0;
  9     for(i = num;arr[i];i++){
 10         arr[i]=arr[i+1];
 11         return ch;
 12     }
 13 }
 14 
 15 int main(void)
 16 {
 17     int num;
 18     char arr[]="helloworld";
 19     scanf("%d",&num);
 20     char del = delete(arr,num);
 21     if(del == 0)
 22         printf("%d\n",del);
 23     else
 24         printf("%c\n",del);
 25 
 26     return 0;
 27 }

ppt_day3

1、假如有如下定义：

int grid[30][100];
a. 用1种方法表示grid[22][56]的地址。//*(grid+22)+56
b. 用2种方法表示grid[22][0]的地址。 //1)*(grid+22)+0 2)0[22[grid]]
c. 用3种方法表示grid[0][0]的地址。
    //1)*(grid+0)+0 2)0[0[grid]] 3)0+*(0+grid)

3、用变量a给出下面的定义

a) 一个整型数 int a

b) 一个指向整型数的指针 int * a

c) 一个指向指针的的指针，它指向的指针是指向一个整型 int **

d) 一个有10个整型数的数组 int a[10]

e) 一个有10个指针的数组，该指针是指向一个整型数的int * a[10]

f) 一个指向有10个整型数数组的指针 int (*p)[10]

g) 一个指向函数的指针，该函数有一个整型参数并返回 一个整型数

h) 一个有10个指针的数组，该指针指向一个函数，该函 数有一个整型参数并返回一个整型数

8、在x86平台下，分析以下代码的输出结果：

#include <stdio.h>
int main(void)
{
	int a[4] = {1, 2, 3, 4};
	int *ptr1=(int *)(&a+1);
	int *ptr2=(int *)((int)a+1);
	printf("%x, %x\n", ptr1[-1], *ptr2);
	return 0;
}