获取字符串长度函数
头文件: #include <string.h>
函数定义: size_t strlen(const char *s);
函数功能: 测字符指针s指向的字符串中字符的个数，不包括"\0"
返回值: 字符串中字符个数
#include <string.h>
size_t strlen(const char *s);
功能:计算一个字符串的长度
参数:
s:指定的字符串
返回值:
当前字符申的长度
注意:strlen获取的字符串长度遇到第一个\0结束且\0不算做字符串长度之中
#include <stdio.h>
#include <string.h>
int main (int argc, char *argv[])
{
//使用strlen函数获取字符串的长度
char s1[100]="hello";
printf("s1_len = %d\n",strlen(s1));
return 0;
}
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
//使用strlen函数获取字符串的长度
//strlen获取的字符串的长度遇到第一个\0结束
char s1[ 100] = "hel\0lo" ;
printf ("s1_len=%d\n", strlen(s1));
printf ("s1_size= %d\n",sizeof(s1));
char *s2= "hello";
printf("s2_len = %d\n", strlen(s2));
printf ("s2_size =%d\n" , sizeof(s2));
return 0;
}
字符串拷贝函数
头文件:#include <string.h>
函数的定义:
`char *strcpy(char *dest, const char *src);`
函数的说明: 拷贝src指向的字符串到dest指针指向的内存中，’\0’也会拷贝函数的
返回值: 目的内存的地址
注意: 在使用此函数的时候，必须保证 dest,指向的内存空间足够大，否则会出现内存污染。
char *strncpy(char *dest, const char *src,size_t n);
函数的说明:
将src指向的字符串前n个字节，拷贝到 dest指向的内存中
返回值: 目的内存的首地址
注意:
1、strncpy不拷贝'\0’
2、如果n大于src,指向的字符串中的字符个数，则在dest,后面填充n-strlen(src)个'\0’
#include <string.h>
char *strcpy ( char *dest, const char *src);
功能:将src复制给dest
参数:
dest:目的字符串
src:源字符串
返回值:
保存dest字符串的首地址
注意:使用strcpy函数复制字符串时必须保证dest足够大，否则会内存溢出
strcpy是将src字符串中第一个\0之前包括\0复制给dest
char *strncpy( char *dest,const char *src, size_t n);
函数的说明:
src指向的字符串前n个字节，拷贝到dest指向的内存中
返回值:目的内存的首地址
注意:
1、strncpy不拷贝"\0"
2、如果n大于src指向的字符串中的字符个数，则在dest后面填充n-strlen(src)个"\0"
#include <stdio.h>
#include <string.h>
int main( int argc, char *argv[])
{
//使用strcpy函数拷贝字符串
char s1[32] = "hello world" ;
char s2[32] = "abcdefg";
strcpy(s1, s2);
printf ( "s1 =%s\n", s1);
return 0;
}
#include <stdio.h>
#include <string.h>
int main( int argc, char *argv[])
{
//使用strcpy函数拷贝字符串
char s1[32] = "hello world";
//使用strcpy函数时，必须保证第一个参数的内存足够大
//char s2[5] = "abcd";
char s2[32]="ahhhhh";
strcpy(s1, s2);
printf ( "s1 =%s\n", s1);
int i;
for(i = 0; i < 32; i++)
{
printf("[%c]- %d\n" , s1[i],s1[i]);
}
return 0;
}
字符串追加函数
头文件:#include <string.h>
函数定义:
char *strcat(char *dest, const char *src);
函数功能:
strcat:函数追加src字符串到dest指向的字符串的后面。追加的时候会追加'\0’
注意:
保证dest指向的内存空间足够大。
char*strncat(char *dest, const char *src, size_t n);
追加src指向的字符串的前n个字符，到 dest指向的字符串的后面。
注意:
如果n大于src的字符个数，则只将src字符串追加到 dest指向的字符串的后面追加的时候会追加'\0’
#include <stdio.h>
#include <string.h>
int main(int argc,char *argv[])
{
//使用strcat函数追加字符串
char s1[32] = "hello world" ;
char s2[32] = " nihao moshengren";
//strcat是从s1的\0的位置开始追加，直到s2的第一个\0复制完毕后结束
strcat(s1,s2);
printf("s1 = %s \n", s1);
return 0;
}
#include <stdio.h>
#include <string.h>
int main()
{
char str[20]="aa\0aaaaaaaaaaaaaaaaa";
char *src ="hello";
strncat(str,src,3);
printf("%s\n",str);
return 0;
}
字符串比较函数
strcmp/strncmp //比较
头文件:#include <string.h>
函数定义: int strcmp(const char s1, const chars2);
函数说明: 比较s1和s2指向的字符串的大小，
比较的方法: 逐个字符去比较ascII码，一旦比较出大小返回。
如过所有字符都一样，则返回0
返回值:
如果s1指向的字符串大于s2指向的字符串返回1；
如果s1指向的字符串小于s2指向的字符串返回-1；
如果相等的话返回0
int strncmp(const char*s1, const char*s2, size_t n);
函数说明:比较s1和 s2指向的字符串中的前n个字符
#include <string.h>
int strcmp( const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
功能:
strcmp是比较两个字符串的内容，
strncmp是比较两个字符串的前n个字节是否一样
参数：
s1、s2:要比较的两个字符串
n: strncmp中的参数n表示要比较的字节数
返回值:
0 s1 = s2
>0 s1 > s2
<0 s1 < s2
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
//使用strcmp比较两个字符串的内容是否一致
//strcmp函数一个字符一个字符比较，只要出现不一样的，就会立即返回
char s1[] = "hello";
char s2[] = "hella";
//int ret = strcmp(s1, s2);
int ret = strncmp(s1,s2,4);
if(ret == 0)
{
printf("s1 = s2\n");
}
else if(ret > 0)
{
printf ("s1>s2\n");
}
else
{
printf ("s1<s2\n");
}
return 0;
}
字符查找函数
头文件:#include <string.h>
函数定义: char strchr(const chars, int c);
函数说明:
在字符指针s指向的字符串中，找ascII码为c的字符
注意 是首次匹配，如果过说s指向的字符串中有多个ASCII为c的字符，则找的是第1个字符
返回值:
找到了返回找到的字符的地址，找不到返回NULL，
函数定义:
char *strrchr(const char*s, int c);
**函数的说明:**末次匹配在s指向的字符串中，找最后一次出现的ASCII为c的字符，
返回值: 末次匹配的字符的地址。
#include <string.h>
char *strchr( const char *s , int c);
功能:在字符指针s指向的字符串中，找ascii码为c的字符
参数:
s:指定的字符串
c:要查找的字符
返回值:
成功:找到的字符的地址
失败:NULL
注意:s指向的字符串中有多个ASCII为c的字符，则找的是第1个字符
char *strrchr( const char *s, int c);
功能:在s指向的字符串中，找最后一次出现的ASCII为c的字符，
#include <stdio.h>
#include <string.h>
int main(int argc,char *argv[])
{
//使用strchr函数在一个字符串中查找字符
char s[] = "hel6lo wor6ld";
char *ret = strchr(s,'6');
if (ret == NULL)
{
printf ( "no found\n" );
}
else
{
printf ( "yes,pos= %d\n", ret - s);
}
return 0;
}
字符串转换数值
atoi/atol/atof字符串转换功能
头文件: #include <stdlib.h>
函数的定义: int atoi(const char *nptr);
函数的功能: 将nptr指向的字符串转换成整数，返回
int num;
num=atoi("123");
long atol(const char *nptr);
double atof(const char *nptr);
#include <stdlib.h>
int atoi( const char *nptr);
功能:将一个数字型字符串转化为整形数据
参数:
nptr:指定的字符串
返回值:
获取到的整形数据
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
//使用atoi将数字型字符串转化为整形数据
char s1[] = "7856" ;
int ret1 = atoi(s1);
printf ("ret1 = %d\n",ret1) ;
//使用atof将浮点型的字符串转化为浮点型数据
char s2[] = "3.1415926";
double ret2=atof(s2);
printf ( "ret2 = %lf\n", ret2) ;
return 0;
}
字符串切割函数
头文件:#include <string.h>
函数定义: char *strtok(char *str, const char *delim);
函数的功能:
字符串切割，按照delim指向的字符串中的字符，切割str指向的字符串。其实就是在str指向的字符串中发现了delim字符串中的字符，就将其变成
"\0",调用一次 strtok,只切割一次，切割一次之后，再去切割的时候 sttok的第一个参数传NULL，意思是接着上次切割的位置继续切
注意如果str字符串中出现了连续的几个 delim中的字符，则只将第一个字符变成"\0"
#include <string.h>
char *strtok( char *str, const char *delim) ;
功能:对字符串进行切割
参数:
str:要切割的字符串
第一次切割，就传入指定的字符串，后面所有次的切割传NULL
delim:标识符，要根据指定的delim进行切割，切割的结果不包含delim
返回值:
返回切割下来的字符串的首地址，如果都切割完毕，则返回NULL
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
//使用strtok函数切割字符串
char s[] = "111:22222:33:4444444444:5555555555555";
char *ret;
//第一次切割
ret = strtok(s, ": ");
printf ( "ret = %s\n",ret);
//后面所有切割时都要将strtok的第一个参数传NULL
while((ret = strtok(NULL,":"))!= NULL)
printf( "ret = %s \n",ret) ;
return 0;
}
格式化字符串操作函数
int sprintf(char*buf,const char *format，---);
//输出到buf指定的内存区域
char buf[20];
sprintf(buf, "%d:%d:%d",2013,10,1);
printf("buf=%s\n".buf);
int sscanf(const char*buf,const char *format，"…);
//从buf指定的内存区域中读入信息
例: int a, b, c;
sscanf("2013:10:1","%d:%d:%d", &a,&b, &c);
printf("%d %d %dn",a,b,c);
#include <stdio.h>
// sprintf和sscanf的基本用法
void test1()
{
char buf[20];
int a, b,c;
sprintf (buf,"%d:%d:%d",2020,11,28);
printf( "buf=%s\n",buf);
sscanf("2013:10:1","%d:%d:%d", &a,&b,&c);
printf("a=%d,b=%d,c=%d\n",a,b,c);
}
//sscanf高级用法
void test2()
{
//1、跳过数据: %*s或%*d
char buf1[20];
sscanf( "1234 5678","%*d %*s",buf1);
printf("%s\n",buf1);
//2、读指定宽度的数据:%[width]s
char buf2[20];
sscanf("1234 5678", "%4s", buf2);
printf("%s\n",buf2);
//3、支持集合操作:只支持获取字符串
//%[a-z]表示匹配a到z中任意字符(尽可能多的匹配)
//%[aBc]匹配a、B、c中一员，贪婪性
//%[^aFc]匹配非a、F、c的任意字符，贪婪性
//%[^a-z]表示读取除a-z以外的所有字符
char buf3[20];
sscanf ( "agcd32DajfDdFF" ,"%[a-z]" , buf3 );
printf ( "%s\n" , buf3);
}
int main(int argc,char *argv[])
{
test1();
test2();
return 0;
}
const
1:修饰普通变量，代表只读的意思
const int a=100;//定义了一个只读变量a值为100以后在程序中，不能再给a赋值了
a=200;//错误的,a只读
2: const修饰指针
(1)cconst char*str
意思是str指向的内存的内容不能通过str来修改,用来保护str指向的内存的内容,但是str的指向是可以改变的
char * strcpy(char *dest,const char *src);
#include <stdio.h>
//const修饰全局变量
//此时全局变量只能使用但是不能修改，
//如果直接拿全局变量修改值，编译直接报错
//如果使用全局变量的地址修改值，运行时程序异常结束
const int a = 100;
void test1()
{
printf("a = %d\n",a);
//报错
//a = 666;
// printf("a = %d\n" ,a);
//程序异常错误
int *p = &a ;
*p = 888;
printf("a = %d\n",a);
}
//const修饰普通局部变量
//可以读取变量的值
//不同直接通过变量进行修改值，编译报错
//可以通过变量的地址修改值
void test2()
{
int b;
printf("b=%d\n,b");
//b=666;
//printf("b=%d\n,b");
int *p=&b;
*p=888;
printf("b=%d\n",b);
}
//如果const修饰指针变量的类型，无法通过指针变量修改地址里面的值
//如果const修饰指针变量，无法修改指针变量保存的地址
//如果const既修饰指针变量的类型，又修饰指针变量，则只能通过原本变量修改值
void test3()
{
int c = 100 ;
//int *p=&c ;
// const修饰指针变量的类型
const int *p=&c ;
// const修饰指针变量
//int * const p = &c;
// const既修饰指针变量的类型，又修饰指针变量
//const int * const p =&c;
printf("*p =%d\n", *p);
c = 666;
printf("*p = %d\n", *p);
*p = 777;
printf("*p = %d\n",*p);
int d=888;
p=&d;
printf("*p=%d\n",*p);
}
int main (int argc,char *argv[])
{
test3();
return 0;
}
1939
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
