C语言字符串操作和输入输入
1.字符串的输入
(1)int scanf( const char *format [,argument]... )
不做越界检查，遇见空格符就结束，此函数不安全
#include <stdio.h>
//测试1
int main(int argc, char *argv[])
{
//scanf() 不做越界检查
char str[5];
printf("请输入字符串str：");//输入abcdefg
scanf("%s", str);
printf("str = %s\n", str);//输出abcdefg，超过了str数组的大小
return 0;
}
//测试2
int main(int argc, char *argv[])
{
//scanf() 遇见空格符就结束
char str[5];
printf("请输入字符串str：");//输入a b c
scanf("%s", str);
printf("str = %s\n", str);//输出a
return 0;
}
(2)char *gets(char *str)
允许有空格，不做越界检查，此函数不安全
#include <stdio.h>
//测试
int main(int argc, char *argv[])
{
char buf[5];
printf("请输入字符串buf：");//a b c d e f g
gets(buf);
printf("buf = %s\n", buf);//输出a b c d e f g
return 0;
}
(3)char *fgets(char *str, int n, FILE *stream)
假如定义一个char buf[5]。 如果输入内容如果大于sizeof(buf) - 1， 只取sizeof(buf) - 1，放在buf所在的数组,数组最后一位存放'\0'
注意：如果输入的字符串长度没有超过 n–1，那么系统会将最后输入的换行符 '\n' 保存进来
#include <stdio.h>
//测试1
int main(int argc, char *argv[])
{
//如果输入内容如果大于sizeof(buf) - 1， 只取sizeof(buf) - 1，放在buf所在的数组,最后一个是'\0'
char buf[5];
printf("请输入字符串："); //abcdefg
fgets(buf, sizeof(buf), stdin); //从stdin(代表标准输入)，读取内容
printf("buf = [%s]", buf);//输出[abcd]
return 0;
}
//测试2
int main(int argc, char *argv[])
{
//如果输入的字符串长度没有超过 n–1，那么系统会将最后输入的换行符 '\n' 保存进来
char buf[5];
printf("请输入字符串："); //abc
fgets(buf, sizeof(buf), stdin); //从stdin(代表标准输入)，读取内容
printf("buf = [%s]", buf);//输出[abc
//]
//可以看到把换行符也读取进来了，自动换行
return 0;
}
(4)int sscanf(const char *str, const char *format, ...)
从字符串中以指定的格式提取内容
#include <stdio.h>
int main(int argc, char *argv[])
{
int a, b, c;
//提取数字
char str[] = "a = 1, b = 2, c = 3";
a = 0;
b = 0;
c = 0;
sscanf(str, "a = %d, b = %d, c = %d", &a, &b, &c);
printf("a1 = %d, b1 = %d, c1 = %d\n", a, b, c);//a1 = 1, b1 = 2, c1 = 3
char str2[] = "1,2,3";
a = 0;
b = 0;
c = 0;
sscanf(str2, "%d,%d,%d", &a, &b, &c);
printf("a2 = %d, b2 = %d, c2 = %d\n", a, b, c);//a2 = 1, b2 = 2, c2 = 3
//提取字符串
char str3[] = "hello world";
char x[10], y[10];
sscanf(str3, "%s %s", x, y);
printf("x = %s, y = %s\n", x, y);//x = hello, y = world
return 0;
}
2.字符串的输入
(1)int printf ( const char * format, ... )
按格式打印输出，不会自动换行
(2)int puts(const char *string);
把字符串输出到屏幕，会自动换行
(3)int fputs(const char *str, FILE *stream)
往stdout(标准输出，一般指屏幕)输出内容
(4)int sprintf(char *str, const char *format, ...)
格式化一个字符串，把这个字符串输出到指定的数组 不会自动换行
#include <stdio.h>
int main01(int argc, char *argv[])
{
char buf[] = "hello world";
printf("%s", buf); //按格式打印输出，不会自动换行
puts(buf); //把字符串输出到屏幕，会自动换行
fputs(buf, stdout);//往屏幕输出内容，不会自动换行
//格式化一个字符串，把这个字符串输出到（保存在）指定的数组 不会自动换行
int a = 1;
char ch = 'd';
sprintf(dst, "a = %d, ch = %c, buf = %s\n", a, ch, buf);
printf("dst的内容:%s",dst);//dst的内容:a = 1, ch = d, buf = hello world
return 0;
}
3.字符串的长度
(1)size_t strlen(char const* str)
返回字符串的长度。从首元素开始，到结束符为止的长度，结束符不算入计算长度内，字符串中遇到\0会直接结束。
注意：和strlen()不同的是，sizeof()测数据类型的长度，不会因为结束符而提前结束,会把结束符也计算在内
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char buf[] = "hello world";
//从首元素开始，到结束符为止的长度，结束符不算入计算长度内
int len = strlen(buf);
printf("len = %d\n", len);//len = 11
//sizeof()测数据类型的长度，不会因为结束符提前结束
printf("sizeof(buf) = %lu\n", sizeof(buf)); //sizeof(buf) = 12，多了一个结束符\0
//遇到\0会直接结束。
char buf2[] = "\0hello world";
len = strlen(buf2);
printf("len2 = %d\n", len);//len2 = 0
//sizeof()测数据类型的长度，不会因为结束符提前结束
printf("sizeof(buf2) = %lu\n", sizeof(buf2)); // sizeof(buf2) = 13
char str[3] = "zwr";
printf("strlen(str) = %lu\n", strlen(str)); //strlen(str) = 3
printf("sizeof(str) = %lu\n", sizeof(str)); //sizeof(str) = 20
return 0;
}
4.字符串的拷贝
(1)char strcpy(char dest, const char *src)
把src字符数组的内容拷贝给dest所代表的数组 ，从首元素开始，遇到结束符'\0'结束
注意：dest数组的大小容不下源字符串长度，则会造成缓冲溢出。
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char src[50] = "hello world"; //源字符串
char dst[50]; //目标数组
//把src字符数组的内容拷贝给dst所代表的数组
strcpy(dst, src);
printf("dst = %s\n", dst);//dst = hello world
char src2[50] = "hello\0world";
char dst2[50];
//遇到结束符'\0'结束, 把'\0'拷贝也过去了，用来当结束符，但'\0'后面的内容无法拷贝
strcpy(dst2, src2);
printf("dst2 = %s\n", dst2);//dst2 = hello
return 0;
}
(2)char *strncpy(char *dest, const char *src, size_t n)
把src字符数组前n个字符的内容拷贝给dst所代表的数组
#include <stdio.h>
#include <string.h>
int main()
{
char src[50] = "hello"; //源字符串
char dst[50] = "123456789"; //目标数组
//把src字符数组前n个字符的内容拷贝给dst所代表的数组
strncpy(dst, src, strlen(src));
printf("dst = %s\n", dst);//dst = hello6789
char src2[50] = "hello";
char dst2[50] = "123456789";
//strlen(src)+1把'\0'也拷贝了
strncpy(dst2, src2, strlen(src)+1);
printf("dst2 = %s\n", dst2);//dst2 = hello
return 0;
}
5.字符串的比较
(1)strcmp(const char *s1,const char * s2)
如果返回值 < 0，则表示 s1 小于 s2。
如果返回值 > 0，则表示 s2 小于 s1。
如果返回值 = 0，则表示 s1 等于 s2。
两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止
(2)int strncmp ( const char * str1, const char * str2, size_t n );
str1, str2 为需要比较的两个字符串，n为要比较的前n个字符的数目。
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char s1[] = "abc";
char s2[] = "abcd";
int flag = strcmp(s1, s2);
if(flag > 0)
{
printf("[%s] > [%s]\n", s1, s2);
}
else if(flag < 0)
{
printf("[%s] < [%s]\n", s1, s2);
}
else
{
printf("[%s] == [%s]\n", s1, s2);
}
//输出[abc] < [abcd]
return 0;
}
6.字符串的追加
(1)extern char *strcat(char *dest, const char *src);
把src的内容(包括'\0')追加到dst的后面(删除dest原来末尾的“\0”)*
(2)char * strncat(char *dest, const char *src, size_t n);
把src所指字符串的前n个字符添加到dest所指字符串的结尾处
注意：要保证dest必须有足够的空间来容纳src的字符串
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char src[] = "hello world";
char dst[100] = "abc";
//把src的内容追加到dst的后面
strcpy(dst, src);
printf("dst = %s\n", dst);//dst = hello world
char src2[] = "hello world";
char dst2[100] = "abc";
//指定长度追加
strncat(dst2, src2, 1);
printf("dst2 = %s\n", dst2);//dst2 = abch
return 0;
}
7.字符串的查询
(1)char *strchr(const char *str, int c)
查找字符串str中首次出现字符c的位置，未找到就返回NULL
(2)char *strstr(const char *str1, const char *str2)
返回在 str1 中首次次出现 str2 字符串的位置，如果str2不是str1的子串，则返回NULL.
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char buf[] = "abcdefg";
//在buf中查询字符e, 如果找到，返回e所在位置的地址
//如果查询失败，返回NULL
char *p = strchr(buf, 'e');
if(p == NULL)
{
printf("未查询到结果\n");
}
else
{
printf("p = %s\n", p);//p = efg
}
return 0;
}
int main(int argc, char *argv[])
{
char buf[] = "abcdefg";
//在buf中查询字符串"cde", 如果找到，返回匹配字符串所在位置的地址
//如果查询失败，返回NULL
char *p = strstr(buf, "cde");
if(p == NULL)
{
printf("查询失败\n");
}
else
{
printf("p = %s\n", p);//p = cdefg
}
return 0;
}
8.字符串切割
(1)char *strtok(char *str, const char *delim)
str为 要被分解的字符串。
delim为包含分隔符
该函数返回被分解的第一个子字符串，如果没有可检索的字符串，则返回一个空指针。
注意：使用strtok()会破坏原来字符串的结构，所以可以使用strcpy() ,再来操作复制后的字符串
//测试一
#include <stdio.h>
#include <string.h>
int main () {
char str[100] = "this-is-demo";
const char delim[2] = "-";
char * result;
//第一次切割，使用strtok()会破坏原来字符串的结构
printf("str切割前：%s\n",str);//str切割前：this-is-demo
result = strtok(str, delim);
printf("str切割一次后：%s\n",str);//str切割一次后this
while( result != NULL ) {//说明切割成功
printf( "%s\n", result );//依次输出 this is demo
//第二次起，第一个参数需要写NULL
result = strtok(NULL, delim);
}
return 0;
}
//测试二
int main () {
char str[100] = "this-is-demo";
char temp[100];
const char delim[2] = "-";
char * result;
//把buf内容拷贝到tmp的数组，后面使用tmp
strcpy(temp, str);
//第一次切割
printf("切割前的str：%s\n",str);//切割前的str：this-is-demo
result = strtok(temp, delim);
printf("切割一次后的str：%s\n",str);//切割一次后的str：this-is-demo
while( result != NULL ) {
printf( "%s\n", result );//依次输出 this is demo
result = strtok(NULL, delim);
}
return 0;
}
