51单片机第5步_string.h库函数

本章介绍string.h库函数的使用;

#include <REG51.h>    //包含头文件REG51.h,使能51内部寄存器;

//#include <intrins.h>  //包含头文件intrins.h,要放在stdio.h的头文件之前;

//使能函数: _nop_();  相当于汇编的NOP指令;

//使能函数: bit  _testbit_( bit bit_value ); 对bit_value进行测试,若bit_value=1,返回1,

//否则返回0;

//使能函数: unsigned char _cror_( unsigned char x, unsigned char n ); 将字节型变量x的值,向

//右循环移动n位,相当于汇编的RR A命令;

//使能函数: unsigned int  _iror_( unsigned int x,  unsigned char n ); 将双字节型变量x的值,

//向右循环移动n位,相当于汇编的RR A命令;

//使能函数: unsigned long _lror_( unsigned long x, unsigned char n ); 将4字节型变量x的值,

//向右循环移动n位,相当于汇编的RR A命令;

//使能函数: unsigned char _crol_( unsigned char x, unsigned char n ); 将字节型变量x的值,向

//左循环移动n位,相当于汇编的RL A命令;

//使能函数: unsigned int  _irol_( unsigned int x,  unsigned char n ); 将双字节型变量x的值,向左循环移动n位,相当于汇编的RL A命令;

//使能函数: unsigned long _lrol_( unsigned long x, unsigned char n ); 将4字节型变量x的值,

//向左循环移动n位,相当于汇编的RL A命令;

//以上的循环左移和循环右移,同C语言的左移和右移是不同的，使用时要小心;

#include <string.h>

//void *memchr(void *s,char val,int n);

//在字符串数组s[]中,搜索前n个字符,查找是否具有val的值,若有,则返回指向val的指针,否则返回

//NULL;

//char memcmp (void *s1, void *s2, int n);

//比较字符串数组s1[]和字符串数组s2[]的前n个字符是否相等,若相等,则返回0;

//若s1>s2,则返回一个正数,若s1<s2,则返回一个负数;

//char strncmp (char *s1, char *s2, int n);

//比较字符串数组s1[]和字符串数组s2[]的前n个字符是否相等,若相等,则返回0;

//若s1>s2,则返回一个正数,若s1<s2,则返回一个负数;

//char strcmp (char *s1, char *s2);

//比较字符串数组s1[]和字符串数组s2[],若s1=s2则返回0,表示这两个字符串是相同的;

//若s1>s2,则返回一个正数,若s1<s2,则返回一个负数;

//char *strcpy (char *s1, char *s2);

//将字符串数组s2[]的字符(包括结束符)拷贝到数组s1[]中,并将数组s1[]的首地址返回;

//char *strncpy (char *s1, char *s2, int n);

//将字符串数组s2[]的前n个字符拷贝到数组s1[]中,若s2的长度小于n,则用0补齐到长度

//n,拷贝到s1中,并将数组s1[]的首地址返回;

//void *memcpy (void *s1, void *s2, int n);

//将字符串数组s2[]的前n个字符拷贝到数组s1[]中,并将数组s1[]的首地址返回;

//注意:s1[]和s2[]是互相独立，没有重叠;

//void *memccpy (void *s1, void *s2, char val, int n);

//将字符串数组s2[]的前n个字符拷贝到数组s1[]中,若拷贝了n个字符，没有遇到val的值,

//则返回NULL;

//在拷贝过程中,若遇到val的值,则在拷贝完该字符后,将指向s1[]的下一个元素的指针返回;

//void *memmove (void *s1, void *s2, int n);

//将字符串数组s2[]的前n个字符拷贝到数组s1[]中,并将数组s1[]的首地址返回;

//注意:s2[]可以是s1[]的一部分，即有重叠部分;

//void *memset  (void *s, char val, int n);

//将s[]的前n个元素设置为val的值;

//char *strcat (char *s1, char *s2);

//将字符串数组s2[]拷贝到字符串数组s1[]的尾部,并将s1[]的首字符指针返回;

//注意:s1[]要可以接受s2的字符串;

//char *strncat (char *s1, char *s2, int n);

//将字符串数组s2[]的前n个字符拷贝到字符串数组s1[]的尾部,并将s1[]的首字符指针返回;

//若字串数组s2[]的元素个数小于n,则只拷贝到s2的结束符,就停止拷贝;

//int strlen (char *s1); //返回字符串s1[]中的字符个数,包括结束符'\0';

//char *strchr (const char *s, char c);

//在s[]中搜索c的值并将第1次出现c值的指针返回,若没有搜索到,则返回NULL;

//int strpos (const char *s, char c);

//在s[]中搜索c的值并将第1次出现c值的位置值返回,若没有搜索到,则返回-1;

//char *strrchr (const char *s, char c);

//在s[]中搜索c的值并将最后1个出现c值的指针返回,若没有搜索到,则返回NULL;

//int strrpos (const char *s, char c);

//在s[]中搜索c的值并将最后1个出现c值的位置值返回,若没有搜索到,则返回-1;

//char *strstr  (char *s, char *sub);

//在s[]中搜索字符串数组sub[]的字符串,并将第1次出现"sub[]的字符串"的指针返回,若没有

//搜索到,则返回NULL;

#include <stdio.h>  //包含头文件stdio.h

       //_getkey();从串口读入一个字符;

   //putchar();向串口发送一个字节;

   //printf();向串口发送一串字节;

//函数功能:测试memchr()函数;

void test_memchr(void)

{ char s[15]="It is test!";

  void *ptr;

  ptr=memchr( s,'!',sizeof(s) ); //在字符串s[]中,搜索所有字符,查找是否具有!的值,若有,

//则返回指向!的指针,否则返回NULL;

  if( ptr==NULL) printf( "! was not found in s[10].\n");

  else printf( "Found ! in s[10].\n" );

}

//函数功能:测试memcmp()函数;

void test_memcmp()

{ char s1[16]="0123456789ABCDEF";

  char s2[16]="0123456789abcdef";

  char i;

  i=memcmp(s1,s2,16);

       //比较字符串数组s1[]和字符串数组s2[]的前n个字符是否相等,若相等,则返回0,

       //若s1>s2,则返回一个正数,若s1<s2,则返回一个负数;

  if(i==0) printf("s1[16]==s2[16],return value = 0.\n");

  else if(i>0) printf("s1[16>]=s2[16],return value is > 0.\n");

  else printf("s1[16]<s2[16],return value < 0.\n");

}

//函数功能:测试memcpy()函数;

void test_memcpy()

{ char s2[]="12345678";

  char s1[11]="aaaaaaaaaa";

  char *ptr;

  ptr=memcpy( s1,s2,sizeof(s1) );

    //将字符串数组s2[]的前9个字符拷贝到数组s1[]中,并将数组s1[]的首地址返回;

  printf( "s1[%bu]=%s\n",sizeof(s2),ptr ); //s1[9]=12345678

}

//函数功能:测试memccpy()函数;

void test_memccpy()

{ unsigned char i=0;

  char s2[10]="123456789";

  char s1[11]="aaaaabcde";

  void *ptr;

  unsigned char * p;

  ptr=memccpy( s1,s2,'5',sizeof(s1) );

       //将字符串数组s2[]的前n个字符拷贝到数组s1[]中,若拷贝了n个字符，

//没有遇到val的值,则返回NULL;

       //在拷贝过程中,若遇到val的值,则在拷贝完该字符后,将指向s1[]的下一个元素的

//指针返回;

  if(ptr==NULL) printf( "5 was not in s2[10];\n" );

  else{ printf( "5 is in s2[10];\n" ); //串口发送,"5 is in s2[10];\n";

        while(s1[i]!='5') i++;

i++;

printf( "s1[%bu]=",i ); //串口发送,"S[5]=";

p=*(&ptr); //将ptr所指向的指针送给p;

i=*p;      //将p所指的内容保存到i中;

printf("%c;\n",i); //串口发送,"b\n";

printf("s[11]=%s;\n",s1); //串口发送:"s[11]=12345bcde;"

      }

}

//函数功能:测试memmove()函数;

void test_memmove()

{ unsigned char s2[]="123"

                    "456"

                    "789";

  unsigned char s1[10]="123";

  printf( "s2[]=%s\n",s2 ); //串口发送:"s2[]=123456789"

  memmove( s2,&s2[2],5 );   //将s2[2]~s2[7]的5个元素拷贝到s2[]数组中;

  printf( "s2[]=%s\n",s2 ); //串口发送:"s2[]=345676789"

  memmove( s1,s2,5 );        //将s2[]的前5个元素拷贝到s1[]中;

  printf( "s1[]=%s\n",s1 );  //串口发送:"s1[]=34567"

  printf( "s2[]=%s\n",s2 );  //串口发送:"s2[]=345676789"

}

//函数功能:测试memset()函数;

void test_memset()

{ char s[10]="123456789";

  memset( s,'*',9 );

  s[9]='\0';               //添加字符串结束符,为printf()打印做准备;

  printf( "s[]=%s\n",s );  //串口发送:"s[]=*********"

}

//函数功能:测试strcat()函数;

void test_strcat()

{ char s2[]="456";

  char s1[10]="123";

  void *ptr;

  ptr=strcat( s1,s2 ); //将字符串数组s2[]拷贝到字符串数组s1[]的尾部,并将s1[]的

//首字符指针返回;

  printf( "s1[]=%s\n",s1 );  //串口发送:"s[]=123456"

  printf( "s1[]=%s\n",ptr );  //串口发送:"s[]=123456"

}

//函数功能:测试strncat()函数;

void test_strncat()

{ char s2[]="DEF";

  char s1[10]="ABC";

  void *ptr;

  ptr=strncat( s1,s2,2 ); //将s2[]的前2个字符拷贝到字符串数组s1[]的尾部,并将s1[]的首字符

//指针返回;

  printf( "s1[]=%s\n",s1 );  //串口发送:"s[]=ABCDE"

  printf( "s1[]=%s\n",ptr );  //串口发送:"s[]=ABCDE"

}

//函数功能:测试strcmp()函数;

void test_strcmp()

{ char s1[]="123";

  char s2[]="321";

  char i;

  i=strcmp(s1,s2);

       //比较字符串数组s1[]和字符串数组s2[]的字符串是否相等,若相等,则返回0,

       //若s1>s2,则返回一个正数,若s1<s2,则返回一个负数;

  if(i==0) printf("s1[]==s2[],return value = 0.\n");

  else if(i>0) printf("s1[>]=s2[],return value is > 0.\n");

  else printf("s1[]<s2[],return value < 0.\n");

}

//函数功能:测试strncmp()函数;

void test_strncmp()

{ char s1[16]="0123456789ABCDEF";

  char s2[16]="0123456789abcdef";

  char i;

  i=strncmp(s1,s2,16);

       //比较字符串数组s1[]和字符串数组s2[]的前16个字符是否相等,若相等,则返回0,

       //若s1>s2,则返回一个正数,若s1<s2,则返回一个负数;

  if(i==0) printf("s1[16]==s2[16],return value = 0.\n");

  else if(i>0) printf("s1[16>]=s2[16],return value is > 0.\n");

  else printf("s1[16]<s2[16],return value < 0.\n");

}

//函数功能:测试strcpy()函数;

void test_strcpy()

{ char s2[]="12345678";

  char s1[11];

  char *ptr;

  ptr=strcpy( s1,s2 );

    //将字符串数组s2[]的字符(包括结束符)拷贝到数组s1[]中,并将数组s1[]的首地址返回;

  printf( "s1[11]=%s\n",ptr ); //s1[11]=12345678

  printf( "s1[11]=%s\n",s1 );  //s1[11]=12345678

}

//函数功能:测试strncpy()函数;

void test_strncpy()

{ char s2[]="abcd";

  char s1[11]="1234567890";

  char *ptr,*p;

  unsigned char i,temp;

  ptr=strncpy( s1,s2,8 );

//将字符串数组s2[]的前8个字符拷贝到数组s1[]中,若s2的长度小于8,则用0补齐到长

//度8,拷贝到s1中,

    //并将数组s1[]的首地址返回;

  printf( "s1[11]=%s\n",ptr ); //s1[11]=abcd

  printf( "s1[11]=%s\n",s1 );  //s1[11]=abcd

  printf( "s1[11]=" );          //s1[11]=

  p=*(&ptr); //将ptr所指向的指针送给p;

  for( i=0;i<4;i++ )

     { temp=*p++; //将p所指的内容保存到temp中;

    printf("%c",temp); //打印字符串:abcd

 }

  for( i=4;i<8;i++ )

     { temp=*p++; //将p所指的内容保存到temp中;

    printf("%bd",temp);  //打印补齐的数据:0000

 }

  for( i=8;i<sizeof(s1)-1;i++ )

     { temp=*p++; //将p所指的内容保存到temp中;

    printf("%c",temp);  //打印字符串:90

 }

  temp=*p; //将p所指的内容保存到temp中;

  printf("%bd",temp);  //打印字符串结束符:\0

  printf( "\n" );

}

//函数功能:测试strlen()函数;

void test_strlen()

{ char s1[11]="1234567890";

  int return_value;

  return_value=strlen(s1);  //返回字符串s1[]中的字符个数,包括结束符'\0';

  printf("s1 length is %d\n",return_value);  //打印:s1 length is 10

  printf( "s1 length is %bd\n",sizeof(s1) );  //打印:s1 length is 11

}

//函数功能:测试strchr()函数;

void test_strchr()

{ char * ptr,*p;

  char s[]="cbcd";

  unsigned char temp;

  int return_value;

  ptr=strchr( s,'c' ); //在s[]中搜索'c'的值并将第1次出现'c'值的指针返回,若没有搜索到,

//则返回NULL;

  return_value= strpos(s,'c'); //在s[]中搜索c的值并将第1次出现c值的位置值返回,若没

//有搜索到,则返回-1;

  p=*(&ptr);   //将ptr所指向的指针送给p;

  temp=*p;  //将p所指的内容保存到temp中;

  if(ptr!=NULL) printf("%c is in s[%d];\n",temp,return_value); //"c is in s[0];"

}

//函数功能:测试strpos()函数;

void test_strpos()

{ char s[]="01234";

  int return_value;

  return_value= strpos(s,'3');

  //在s[]中搜索c的值并将第1次出现c值的位置值返回,若没有搜索到,则返回-1;

  if(return_value!=-1) printf("s[%d]=3\n",return_value); //"s[3]=3"

}

//函数功能:测试strrchr()函数;

void test_strrchr()

{ char * ptr,*p;

  char s[]="cbcd";

  unsigned char temp;

  int return_value;

  ptr=strrchr( s,'c' ); //在s[]中搜索c的值并将最后1个出现c值的指针返回,若没有搜索到,

//则返回NULL;

  return_value= strrpos(s,'c'); //在s[]中搜索c的值并将最后1个出现c值的位置值返回,

//若没有搜索到,则返回-1;

  p=*(&ptr);  //将ptr所指向的指针送给p;

  temp=*p;  //将p所指的内容保存到temp中;

  if(ptr!=NULL) printf("%c is in s[%d];\n",temp,return_value);   //"c is in s[2]"

}

//函数功能:测试strrpos()函数;

void test_strrpos()

{ char s[]="33234";

  int return_value;

  return_value=strrpos(s,'3');

//在s[]中搜索c的值并将最后1个出现c值的位置值返回,若没有搜索到,则返回-1;

  if(return_value!=-1) printf("s[%d]=3\n",return_value);  //"s[3]=3"

}

//函数功能:测试strstr()函数;

void test_strstr()

{ char * ptr,*p;

  char s[]="1234aabcd5678abcd";

  char sub[]="abcd";

  unsigned char temp,i;

  ptr=strstr( s,sub );

  //在s[]中搜索字符串数组sub[]的字符串,并将第1次出现"sub[]的字符串"的指针返回,

//若没有搜索到,则返回NULL;

  p=*(&ptr);    //将ptr所指向的指针送给p;

  if(ptr!=NULL)

    { printf("s[]=1234a");

  for(i=0;i<12;i++)

    { temp=*p++;        //将p所指的内容保存到temp中;

  printf("%c",temp);  //"abcd5678abcd"

}

  printf("\n");

}

}

//函数功能:初始化串口,设置波特率为1200bps@16MHz,使能接收,使用8位UART;

void Serial_Port_Initialization()

{ SCON  = 0x50; //串行控制寄存器: SM0,SM1,SM2,REN,TB8,RB8,TI,RI

                //SM1:SM0=01,选择方式1,SM2=0,表示非多机通讯,8-bit UART;

//REN=1,使能接收;

  TMOD |= 0x20; //定时器方式控制寄存器:GATE1,C/T1,M11,M10,GATE0,C/T0,M01,M00

                //GATE=0,TR置1便可以启动Timer;GATE=1,TR置1,且INT脚输入

//高电平,才可以启动Timer;

//M11:M10=10,选择方式2,8位自动重装载;

  TH1   = 221;  //TH1:  reload value for 1200 baud @ 16MHz

  TR1   = 1;    //启动Timer1;

  TI    = 1;    //发送UART的第一个字节,为下次发送做准备;

}

void main(void)

{

  Serial_Port_Initialization(); //初始化串口,设置波特率为1200bps@16MHz,使能接收,使用8位UART;

  for(;;)

     { test_memchr();   //测试memchr()函数;

    test_memcmp();  //测试memcmp()函数;

test_memcpy();   //测试memcpy()函数;

test_memccpy(); //测试memccpy()函数;

test_memmove();  //测试memmove()函数;

test_memset();    //测试memset()函数;

test_strcat();     //测试strcat()函数;

test_strncat();    //测试strncat()函数;

test_strcmp();    //测试strcmp()函数;

test_strncmp(); //测试strncmp()函数;

test_strcpy();     //测试strcpy()函数;

test_strncpy();    //测试strncpy()函数;

test_strlen();     //测试strlen()函数;

test_strchr();    //测试strchr()函数;

test_strpos();     //测试strpos()函数;

test_strrchr();    //测试strrchr()函数;

test_strrpos();    //测试strrpos()函数;

test_strstr();    //测试strstr()函数;

 }