0807指针(2)

指针 操作 一维字符型数组 

 

用函数和指针，完成

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;
}
 

 

总结:  
   1.指针操作一维字符型数组 //字符串
   2.知识点
     //1.指针变量的 类型 是怎么确定的?
     //2.一维字符型数组 字符串 
     //3.处理字符串数据方式
        char s[] = "hello";
        const char *p = "hello"; 
    //4. const 关键字  
         const 关键字使用方法 
         const 形参   

      

const

       const是C语言中的一个关键字，是定义只读变量的关键字。但是一个变量经过const的修饰后，不仅拥有常量的属性，又有变量的属性，所以又说const是定义常变量的关键字。

  1.形参 设计为 const char *
    目的:
        防止函数中的误操作 
  2.好处
    (1).提前发现问题 
        将运行时问题，提前到编译时  
    (2).const char *
        可以接收 
        char *
        const char *

       实参:
         可以 数组名 
         可以 指针变量  char *p //const char *p         
         可以 直接是一个字符串常量 
        提高参数的适用性 
        

 

1、用来修饰变量（指针除外）

        在修饰变量（指针变量除外）的时候，const type name 和 type const name 这两种形式是完全一样的表示 name 是常变量。 此时无法直接修改 num，但是可以通过指针变量的形式来修改。

 

 2、用来修饰指针变量

         const用来修饰指针变量时分为两种情况：一种是const位于' * '的左边，另一种是const位于' * '的右边。

        （1）当const位于' * '的左边，即 const type* name 和 type const *name 这两者是完全一样，无任何区别。这种情况下 const 修饰的是 name 指向的对象无法修改，但可以修改指针变量。

      （2）当const位于' * '的右边，即 type* const name 。这种情况下无法修改指针变量， 但可以修改指针变量指向的对象。

          

举例：
 

int *p; //基类型     //目标类型  
        //指针变量      
        
int a = 10;
//int *p = &a;

const int *p = &a;   //const限定是 基类型 
                     //表示不能通过 *p 的方式 修改基类型数据 
                     
int const *p = &a;   //const限定是 基类型 
                     //表示不能通过 *p 的方式 修改基类型数据 

                     
int * const p = &a; //const限定是 指针变量p 
                    //表示将p限定位只读 
                    //表示p不能被修改 
                    
const int * const p = &a;  //基类型和指针变量 都被限定为只读
                           // p = &b; //不能修改 
                           //*p = b;  //不能修改 

应用:
    1.如果 不想 通过*p方式改变基类型对应的数据 
      const int *p = &a;  
      int const *p = &a;  
    2.如果 指针变量p 定义好后，不想再指向别的变量 
      则 
        int * const p = &a;
                     
原则:
   就近原则  //const 离谁近 就限定谁