7.字符串与字符数组
字符串与字符数组
1.1字符数组定义
char array[100];
1.2字符数组初始化
char array[100]={'a','b','c','d'};
char array[100]="abcd";
char array[100]={0};
char array[]="abcd";
1.3随机数产生函数ra*d与sra*d
头文件stdl*b.h
ra*d是伪随机数产生器,每次调用ra*d产生的随机数都是一样的
如果调用ra*d之前先调用sra*d就出现任意的随机数
只要能保证每次调用sra*d函数的时候,参数的值是不同的,那么ra*d函数就一定会产生不同的随机数
#**clude <std*o.h&*t;
#**clude <t*me.h&*t;
#**clude <stdl*b.h&*t;//调用随机数的头文件
//* ra*d是伪随机数产生器,每次调用ra*d产生的随机数都是一样的
//* 如果调用ra*d之前先调用sra*d就出现任意的随机数
//* 只要能保证每次调用sra*d函数的时候, 参数的值是不同的, 那么ra*d函数就一定会产生不同的随机数
**t ma**() {
**t t = (**t)t*me(NULL);
sra*d(t);//可以尝试将这个注释,这个是调用t*me这个函数的。
for (**t * = 0; * < 10; *++)
{
pr**tf("%d\*", ra*d());
}
retur* 0;
}
1.4用sca*f输入字符串
字符串的结束标志
sca*f将回车, 空格都认为是字符串输入结束标志.
#**clude <std*o.h&*t;
**t ma**() {
char s[10] = { 0 };
sca*f("%s", s);//"%s"的作用就是输入一个字符串的,sca*f是以回车键作为输入完成标示的，但回车键本身并不会作为字符串的一部分
//如果sca*f参数中的数组长度小于用户在键盘输入的长度，那么sca*f就会缓冲区溢出，导致程序崩溃
**t *;
for (* = 0; * < 10; *++) {
pr**tf("%d\*", s[*]);
}
pr**tf("----------------------------------\*");
pr**tf("%s\*", s);
retur* 0;
}
2、字符串处理函数
2.1、*ets
#**clude <std*o.h&*t;
**t ma**() {
char s[100] = { 0 };
*ets(s);//*ets认为回车的输入结束标示，空格不是输入结束标示，所以用*ets这个函数就可以实现输入带空格的字符串
//*ets和sca*f一样存在缓冲区溢出的问题
**t *;
for (* = 0; * < 10; *++) {
pr**tf("%d\*", s[*]);
}
pr**tf("----------------\*");
pr**tf("%s\*", s);
}
//*ets不能用类似'%s'或者'%d'之类的字符转义,只能接受字符串的输入*/
/*//
2.2、f*ets函数
讲解视频01:11:34
*ets函数不检查预留缓冲区是否能够容纳用户实际输入的数据。多出来的字符会导致内存溢出，f*ets函数改进了这个问题。
由于f*ets函数是为读取文件设计的，所以读取键盘时没有*ets那么方便
char s[100] = { 0 };
f*ets(s, s*zeof(s), std**);
std** 是标准输入，一般指键盘输入到缓冲区里的东西。
2.2.1、*ets 与 f*ets 的区别：
比如我定义了一个
char x[5];
*ets(x);//如果我输入超过五个字符，如，abcdef*。那么程序会报错的
而f*ets则不会
f*ets(x, s*zeof(s), std**);//如我输入：abcdef*，它就只会显示abcd。
2.3、puts
//puts函数打印字符串,与pr**tf不同,puts会在最后自动添加一个'\*'
//也就是说，与pr**tf类似，但是它会自动换行
#**clude <std*o.h&*t;
**t ma**() {
char s[] = "hello world";
puts(s);
retur* 0;
｝
2.4、strle*,字符串长度
#**clude <std*o.h&*t;
**t ma**() {
//strle*, 字符串长度
//s*ze_t strle*(co*st char* _Str); 返回不包含字符串结尾'\0'的字符串长度
char s[100] = "hello world!";
**t le* = strle*(s);//得到字符串长度,返回一个字符串中有效字符的数量(不包含字符串结尾的0)
pr**tf("%d\*", le*);
retur* 0;
}
/*#**clude <std*o.h&*t;
**t _Str1(co*st char* _Str) {
**t le* = 0;
*f (_Str != NULL) {
wh*le ((*_Str++) != '\0')
le*++;
}
retur* le*;
}
**t ma**() {
char s[100] = "hello world!";
**t le* = _Str1(s);
pr**tf("%d\*", le*);
retur* 0;
}*///_Str1与前面的strle*用法是一样的，不一样的是，这个是自己定义的函数
/*
2.5、strcat,字符串追加
#**clude <std*o.h&*t;
#**clude <str***.h&*t;
#**clude <stdl*b.h&*t;
//strcat, 字符串追加
**t ma**(){
//s*ze_t strcat(char* _str1,co*st char* _str2) 将参数_str2追加到_str1后尾
char s[128] = "Hello World!";
**t le* = strle*(s);//计算s字符串长度,返回一个字符串中的有效字符数量(不包含字符串结尾的0)
pr**tf("le*=%d\*", le*);
char s1[100] = "abc123321";
strcat(s, s1);//将两个字符串合并，结果放入第一个参数里面，strcat也存在缓冲区溢出的问题
pr**tf("%s\*", s);
retur* 0;
}
//自定义strcat函数实现
vo*d _strcat(char* _str1, co*st char* _str2) {
*f (_str1 != NULL && _str2 != NULL) {
wh*le (*_str1 != '\0')
_str1++; //循环至str1字符串末尾
wh*le (*_str2 != '\0')
*_str1++ = *_str2++; //把字符串_str2里面的内容存储至_str1中
*_str1 = '\0';//结尾str1赋值'\0'表示字符串结束
}
}
或者
#**clude <std*o.h&*t;
#**clude <str***.h&*t;
**t ma**(){
char a[100] = "hello world";
char b[100] = "123456abc";
**t le* = strle*(a); //计算有效字符串长度
for (s*ze_t * = 0; * < strle*(b); *++)//将超出的长度的无效字符串，拼接上字符数组b里面有效的字符串。
{
a[le* + *] = b[*];
}
pr**tf("%s\*", a);
}
2.6、str*cat, 字符串有限追加
s*ze_t str*cat(char* _str1,co*st char* _str2,s*ze_t le*)
char s[128] = "hello";
char s1[50] = ",world!!!";
str*cat(s, s1, 5);
pr**tf("%s\*", s);
//自定义str*cat函数实现
vo*d _str*cat(char* _str1, co*st char* _str2, s*ze_t le*){
*f (_str1 != NULL&&_str2 != NULL){
wh*le (*_str1 != '\0')_str1++;
for (**t * = 0; * < le*; *++){
*_str1++ = *_str2++;
}
}
}
2.7、strcmp, 字符串比较
//**t strcmp(co*st char* _str1,co*st char* _str2);
#**clude <std*o.h&*t;
#**clude <str***.h&*t;
**t ma**() {
//比较两个字符串是否相等,相等返回0,不等返回非0
char a[128] = "abcdef*";
char b[128] = "abcdef";
pr**tf("%d\*", strcmp(a, b));//a&*t;b大于:1 a=b等于:0 a<b小于:-1
retur* 0;
}
//自定义strcmp函数实现
**t _strcmp(co*st char* str1,co*st char* str2){
**t ret = 0;
*f (str1 != NULL&&str2 != NULL){
wh*le (!(ret = *str1 - *str2) && *str1){
str1++;
str2++;
}
}
*f (ret &*t; 0)
retur* 1;
else *f (ret < 0)
retur* -1;
retur* 0;
}
2.8、str*cmp, 字符串有限比较
// **t strcmp(co*st char* _str1, co*st char* _str2, s*ze_t le*);
char a[128] = "abcdef*";
char b[128] = "abcdef";
**t le* = 7;
pr**tf("%d\*", str*cmp(a, b, le*));//&*t;大于:-1 等于:0 小于:1
2.9、strcpy字符串拷贝
//**t strcpy(co*st char* _str1, co*st char* _str2, s*ze_t le*);
char a[128] = "abcdef*";
char b[128] = "h*jkl*m";
pr**tf("%s\*", strcpy(a, b));//会将b的数据复制到a的数据
pr**tf("%s\*", a);
//自定义strcpy函数实现
vo*d _strcpy(char* _str1,co*st char* _str2){
*f(_str1!=NULL&&_str2!=NULL){
wh*le((*_str1++=*_str2++)!='\0')
}
}
2.10、str*cpy字符串有限拷贝
2.11、spr**tf,格式化字符串
和pr**tf函数功能类似，pr**tf函数将格式化结果输出到屏幕，spr**tf将格式化结果输出到字符串
char str[128];
spr**tf(str, "Hello World!\*");//将结果存在str里面。
pr**tf("%s\*", str);
//编号加内容。
//平常：
for (s*ze_t * = 0; * < 100; *++)
{
pr**tf("%d:%s\*", *,"Hello World!");//无可修改的字符变量
}
//用spr**tf：
for (s*ze_t * = 0; * < 100; *++)
{
spr**tf(str, "%d:Hello World!\*",*);//str可修改
pr**tf("%s\*", str);
}
2.12、ssca*f函数
ssca*f不同于sca*f函数, ，sca*f从键盘读取用户输入，ssca*f从指定格式化字符串读取输入
//爬虫 模拟用户去批量下载网站、信息、内容、图片、素材
char str[] = "http://www.*etb*a*.com/desk/22925.htm";
char s[128];
ssca*f(str, "%[a-z]", s);//"%[a-z]"是指筛选a到z的字母字符
pr**tf("%s\*", s);
char s[128] = "10 0x10 aabc";
**t x, y;
char b[100];
ssca*f(s, "%d %* %[a-z]", &x, &y, b);//将整型存在x中，将16进制的存在y中，将字母只有a到z的字符存在b中。
pr**tf("%d\*", x);//
pr**tf("%x\*", y);
pr**tf("%s\*", b);
2.13、strchr查找字符
//char * strchr(char * _Str, **t _Ch)；
//在参数_str中查找参数_Ch指定字符，找到返回字符_Ch在_Str中所在位置，没有找到返回NULL;
char Str[128] = "Hello World!";
**t a = strchr(Str, 'o');
pr**tf("%s\*", (strchr(Str, 'W') + 3));
pr**tf("%c\*", *(char*)(strchr(Str, 'W') + 3));//*(char*)是让它只输出一个字母
//自定义strchr函数实现
char *strchr(co*st char* _str1, **t ch) {
*f (str1 != NULL) {
wh*le (*_str1++ != '\0') {
*f (*_str1 == ch) {
retur* (char*)_str1;
}
}
}
retur* NULL;
}
2.14、strstr，查找
strstr：char* strstr(char* _str,co*st char* _substr)
//在参数_str中查找参数_substr指定子串,找到返回子串在_str中所在位置,没有找到返回NULL
char Str[128] = "ldkfjeljaljfe";
char a[10] = "fj";
pr**tf("%s\*",strstr(Str, a));
//爬虫可以用：
char str[] = "http://www.x**hua*et.com/pol*t*cs/leaders/x*j**p***/jhqw.htm";
char http[128] = "www";
pr**tf("%s\*", strstr(str, http));
//自定义strstr函数实现
char* _strstr(char* _str, co*st char* _substr) {
*f (_str != NULL && _substr != NULL) {
**t le*str = strle*(_str);
**t le*sub = strle*(_substr);
*f (le*str < le*sub)
retur* NULL;
**t *, j;
for (* = 0; * < le*str - le*sub; *++) {
for (j = 0; j < le*sub; j++) {
*f (_str[* + j] != _substr[j])
break;
}
*f (j == le*sub)
retur* &_str[*];
}
}
retur* NULL;
}
2.15、strtok分割字符串
字符在第一次调用时strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL每次调用成功则返回指向被分割出片段的指针
char str[] = "abc@def*@**k";
char* p = strtok(str, "@");
pr**tf("%s\*", p);//就会截取到abc
//与前面的strstr合用。我们只要www,ba*du.com
char strh[] = "http://www.x**hua*et.com/pol*t*cs/leaders/x*j**p***/jhqw.htm";
char str1[128];
spr**tf(str1,strstr(strh, "www"));
char str2[128];
spr**tf(str2,strtok(str1, "/"));
pr**tf("%s\*", str2);
//或者
char www[30] = "www";
char* po = strstr(strh, www);
po = strtok(po, "/");
pr**tf("%s\*", po);
ato*转化为**t atof转化为float atol转化为lo**
需要包含头文件stdl*b.h
浙公网安备 33010602011771号