本章介绍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()函数;
}
