嵌入式学习笔记十四——指针操作一维字符型数组

1.const的作用

以puts函数为例，函数原型是int puts(const char *s);

我们写一个自己的Puts函数，从键盘输入字符串，结构大概是

int Puts(const char *s)
{
	while (*s != '\0')
	{
		putchar(*s);
		++s;
	}
	putchar('\n');
	return 0;
}

在这段代码中++s这个操作是指向下一个元素，如果我们误操作将它写成了++（*s）或是*s++，结果就是改变了指针指向地址的内容。但要求我们输出一个字符串，并不希望误操作导致数组内容被改变，这时候const就发挥作用了。

int puts(const char *s)，const表示只读，下面是const的一些用法：

const int a; //a 此时是一个只读的变量 
     		
int a = 10;
//int *p = &a;
const int *p = &a;   //const限定是 基类型 
                     //表示不能通过 *p 的方式 修改基类型数据 	
				 
int const *p = &a;   //const限定是 基类型 
                     //表示不能通过 *p 的方式 修改基类型数据
                     //与const int *p = &a等价
 					 
int * const p = &a; //const限定是 指针变量p 
                    //表示将p限定位只读 
					//表示p不能被修改 			
		
const int * const p = &a;  //基类型和指针变量 都被限定为只读
					       // p = &b; //不能修改 
						   //*p = b;  //不能修改 

2.const限定原则

   就近原则  //const 离谁近 就限定谁 

总结：

1.形参设计为 const char *的目的， 防止函数中的误操作 

2.好处
    (1).提前发现问题 将运行时问题，提前到编译时  
    (2).const char * 可以接收  char *和const char * 提高参数的适用性

注意:形参能写成const的都写const 

应用:

    1.如果 不想 通过*p方式改变基类型对应的数据 可以写成：
      const int *p = &a;  
      int const *p = &a;  

   2.如果 指针变量p 定义好后，不想再指向别的变量则写成
     int * const p = &a;

3.指针操作一维字符数组

练习

用函数和指针，完成

1.Puts/Gets

2.Strlen

3.Strcpy/strncpy

4.strcat /Strncat

5.Strcmp/Strncmp

代码如下：

#include <stdio.h>
#include <string.h>
 
int Puts(const char *s)
{
	if (s == NULL)
		return -1;
	while (*s != '\0')
	{
		putchar(*s);
		++s;
	}
	putchar('\n');
	return 0;
}
 
char *Gets(char *s)
{
	char *ret = s;
 
	while((*s = getchar()) != '\n')
		++s;
	*s = '\0';
	return ret;
}
 
size_t Strlen(const char *s)
{
	const char *ret = s;
	while (*s != '\0')
	{
		s++;
	}
	return s-ret;
}
 
char *Strcpy(char *dest,const char *src)
{
	char *ret = dest; 
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	*dest = '\0';
	return ret;
}
 
char *Strncpy(char *dest,const char *src,int n)
{
	char *ret = dest;
	while (*src != '\0' && n > 0)
	{
		*dest = *src;
		++dest;
		++src;
		--n;
	}
	while (n > 0)
	{
		*dest = '\0';
		++dest;
		--n;
	}
	return ret;
}
char *strcat(char *dest,const char *src)
{
	char *ret = dest;
	while (*dest != '\0')
	{
		++dest;
	}
	while(*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	*dest = '\0';
	return ret;
}
char *Strncat(char *dest,const char *src,size_t n)
{
	char *ret = dest;
	while (*dest != '\0')
		++dest;
	while (*src != '\0' && n != 0)
	{
		*dest = *src;
		++dest;
		++src;
		--n;
	}
	*dest = '\0'; 
	return ret;
}
int Strcmp(const char *s1,const char *s2)
{
	int ret = 0;
	while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0')
	{
		++s1;
		++s2;
	}
	ret = *s1 - *s2;
	return ret;
}
 
 
int Strncmp(const char *s1,const char *s2,size_t n)
{
	int ret = 0;
	while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0' && n-1)
	{
		++s1;
		++s2;
		--n;
	}
	ret = *s1 - *s2;
	return ret;
}
 
void Memcpy(void *dest,const void *src,size_t n)
{
	char *p = dest;
	const char *q = src;
	while (n > 0)
	{
		*p = *q;
		++q;
		++p;
		--n;
	}
}
 
 
int main(void)
{
    char s[20] = "hello";
	char ss[20]= "english";
//	Gets(s);
//	Puts(s);
//	Strncpy(ss,s,5);
//	Puts(ss);
//	int i = 0;
//	for (i = 0;i < 10; ++i)
//	{
//		printf("s[%d] = %c\n",i,s[i]);
//	}
//	printf("%ld\n",Strlen(s));
//	strcat(ss,s);
//    Strncat(ss,s,5);
//	Puts(ss);
//	printf("%d\n",Strncmp(ss,s,3));
 
	long a[5] = {1,2,3,4,5};
	long b[5];
	Memcpy(b,a,5*sizeof(a[0]));
	int i = 0;
	for (i = 0;i < 5;++i)
	{
		printf ("%ld\n",b[i]);
	}
	return 0;
}
 

memcpy函数：

 void *memcpy(void *dest, const void *src, size_t n)
 {
      //一个字节一个字节拷贝 
 }
 void * //NULL 空指针 
        //空类型的指针 --- 万能指针
        //可以接收任意类型的指针  
注意:
    如果用 空类型指针 进行 间接运算，必须 转换成 有明确类型的指针 

总结: 

  1.指针操作一维字符型数组 //字符串
   2.知识点
     //1.指针变量的 类型 是怎么确定的?
     //2.一维字符型数组 字符串 
     //3.处理字符串数据方式
        char s[] = "hello";
        const char *p = "hello"; 
    //4. const 关键字  
         const 关键字使用方法 
         const 形参          
   3.实现字符串相关函数
     gets /puts  
     strlen 
     strcpy /strncpy
     strcat /strncat 
     strcmp /strncmp

4.指针操作二维数组 

int a[2][3];//二维数组 

1.c语言中并不存在，真正的二维数组。
2.二维数组本质 是一维数组的一维数组 
3.二维数组 也 符合数组的特点 //连续性，有序性，单一性 

问题:
1.确定需要定义什么类型的指针?从二维数组的本质出发 
   &a[0]
    //a[0]  --- int[3]
    //&a[0] --- int[3] * 
    //c语言中 不支持 int[3] *  
    //正确写法 int(*)[3]

int(*p)[3] = a; //p指向二维数组 a 
                //p的基类型 int[3]

*p <=> a[0] // 相当于是内部这个一维数组的数组名 
       (*p)[0] 
       *(*p+0) //**p

*(*(p+1)+1) <=> a[1][1]
*(*(p+i)+j) <=> a[i][j]