标准C库提供的对字符串的处理函数，分为字符串的输入、输出、合并、修改、比较、转换、复制、搜索等几类（ps 越学越像java了）
字符串输入/输出字符串输出（字符串专用）
常用的字符串输出函数有 putchar()、puts()、fputc()、fputs()，前面我们经常使用 printf()函数来输出字符串信息，而并没有使用到 putchar()、puts()、fputc()、fputs()这些函数，原因在于 printf()可以按照自己规定的格式输出字符串信息，一般称为格式化输出；而 putchar()、puts()、fputc()、fputs()这些函数只能输出字符串，不能进行格式转换。与 printf()一样，putchar()、puts()、fputc()、fputs()这些函数也是标准 I/O 函数，属于标准 C 库函数，所以需要包含头文件
puts 函数（man 3 puts）
puts()函数用来向标准输出设备（屏幕、显示器）输出字符串并自行换行。把字符串输出到标准输出设备，将' 转换为换行符 '' \n '。int puts(const char *s);
#include
s
： 需要进行输出的字符串。 返回值： 成功返回一个非负数；失败将返回 EOF ， EOF 其实就是 -1 。char str[50] = "Linux app puts test"; puts("Hello World!"); puts(str);
putchar 函数（man 3 putchar）
putchar()
函数可以把参数 c 指定的字符（一个无符号字符）输出到标准输出设备，其输出可以是一个字符，可以是介于 0~127 之间的一个十进制整型数（包含 0 和 127 ，输出其对应的 ASCII 码字符），也可以是用 char 类型定义好的一个字符型变量。 int putchar(int c);#includec ： 需要进行输出的字符。 返回值： 出错将返回 EOF 。 putchar('A'); putchar('B'); putchar('C'); putchar('D'); putchar('\n');
fputc
函数fputc()与
putchar()类似，也用于输出参数 c 指定的字符（一个无符号字符），与 putchar()区别在于， putchar()只能输出到标准输出设备，而 fputc()可把字符输出到指定的文件中，既可以是标准输出，也可以是一个普通文件。 int fputc(int c, FILE *stream);
#includec ： 需要进行输出的字符。 stream ： 文件指针。 返回值： 成功时返回输出的字符；出错将返回 EOF 。 //输出到标准输出设备 fputc('A', stdout); fputc('B', stdout); fputc('C', stdout); fputc('D', stdout); fputc('\n', stdout); //输出到普通文件 fputc('A', fp); fputc('B', fp); fputc('C', fp); fputc('D', fp); fputc('\n', fp);
fputs
函数
fputs()
与
puts()
类似，也用于输出一条字符串，与
puts()
区别在于，
puts()
只能输出到标准输出设 备，而
fputs()可把字符串输出到指定的文件中，既可以是标准输出、标准错误设备，也可以是一个普通文件
。
int fputs(const char *s, FILE *stream);
#includes ： 需要输出的字符串。 stream ： 文件指针。 返回值： 成功返回非负数；失败将返回 EOF 。 //输出到标准输出设备 fputs("Hello World! 1\n", stdout); fputs("Hello World! 2\n", stdout); //输出到普通文件 fputs("Hello World! 1\n", fp); fputs("Hello World! 2\n", fp);
字符串输入
常用的字符串输入函数有
gets() 、getchar()、fgetc()、fgets()。与 printf() 对应，在 C 库函数中同样也提供了格式化输入函数 scanf() 。 scanf() 与 gets() 、 getchar() 、 fgetc() 、 fgets() 这些函数相比，在功能上确实有它的优势，但是在使用上不如它们方便、简单、更易于使用。与 scanf() 一样， gets() 、 getchar() 、 fgetc() 、 fgets() 这些函数也是标准 I/O 函数，属于标准 C ，并且它们也使用 库函数，所以需要包含头文件#include函数（只读取一个字符） getchar() 函数用于从标准输入设备中读取一个字符（一个无符号字符） int getchar(void);s ： 指向字符数组的指针，用于存储字符串。 返回值： 如果成功，该函数返回指向 s 的指针；如果发生错误或者到达末尾时还未读取任何字符，则返回 NULL 。 getchar
#include函数 （推荐使用fgets代替gets） fgets() 与 gets() 一样用于获取输入的字符串 char *fgets(char *s, int size, FILE *stream);无需传参 。 返回值： 该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF 。 fgets
#includes ： 指向字符数组的指针，用于存储字符串。 size ： 这是要读取的最大字符数。 stream ： 文件指针。 fgetc
//从键盘输入
#include
#include
int main(void) {
char str[100] = {0};
printf("请输入字符串: ");
fgets(str, sizeof(str), stdin);
printf("%s", str);
exit(0);
} //从文件输入
#include
#include
int main(void) {
char str[100] = {0};
FILE *fp = NULL;
/* 打开文件 */
fp = fopen("./test_file", "r");
if (NULL == fp) {
perror("fopen error");
exit(-1);
}
/* 从文件中输入字符串 */
fgets(str, sizeof(str), fp);
printf("%s", str);
/* 关闭文件 */
fclose(fp);
exit(0);
} #include========================================================================= strlen() sizeof 函数（用来计算字符串长度） 和 strlen 的区别 在程序当中，我们通常也会使用 sizeof 来计算长度，那 strlen 和 sizeof 有什么区别呢？ ⚫ sizeof 是 C 语言内置的 *** 作符关键字，而 strlen 是 C 语言库函数； ⚫ sizeof 仅用于计算数据类型的大小或者变量的大小，而 strlen 只能以结尾为 ' 的字符串作为参数； ' ⚫ 编译器在编译时就计算出了 sizeof 的结果，而 strlen 必须在运行时才能计算出来； ⚫ sizeof 计算数据类型或变量会占用内存的大小， strlen 计算字符串实际长度。 size_t strlen(const char *s); sstream ： 文件指针 返回值： 该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF 。 字符串长度
#include： 需要进行长度计算的字符串，字符串必须包含结束字符 ' 。 ' 返回值： 返回字符串长度（以字节为单位），字符串结束字符 ' 不计算在内。 ' char str[] = "Linux app strlen test!"; printf("String: \"%s\"\n", str); printf("Length: %ld\n", strlen(str));字符串拼接 strcat char *strcat(char *dest, const char *src);
dest
=========================================================================
： 目标字符串。 函数（拼接字符串）#includesrc ： 源字符串。 返回值： 返回指向目标字符串 dest 的指针。 strcat()函数会把 src 所指向的字符串追加到 dest 所指向的字符串末尾，所以必须要保证 dest 有足够的存储空间来容纳两个字符串，否则会导致溢出错误；dest 末尾的 ' 结束字符会被覆盖， ' src 末尾的结束字符 ' ' 。 ' '会一起被复制过去，最终的字符串只有一个 char str1[100] = "Linux app strcat test, "; char str2[] = "Hello World!"; strcat(str1, str2); puts(str1);strncat 函数 strncat() 与 strcat() 的区别在于， strncat
可以指定源字符串追加到目标字符串的字符
数量
（拼接字符串）
char *strncat(char *dest, const char *src, size_t n);
dest
：
目标字符串。
src：源字符串。
#includen ： 要追加的最大字符数。 返回值： 返回指向目标字符串 dest 的指针。 char str1[100] = "Linux app strcat test, "; char str2[] = "Hello World!"; strncat(str1, str2, 5); puts(str1); //输出：Linux app strcat test,Hello字符串拷贝 strcpy 函数（字符串拷贝） strcpy() 会把 src
（必须包含结束字符
=========================================================================
' ）指向的字符串复制（包括字符串结束字符 ' ' ）到 'dest ， 所以必须保证 dest 指向的内存空间足够大 ，能够容纳下 src 字符串，否则会导致溢出错误。 char *strcpy(char *dest, const char *src); dest ： 目标字符串。 src ： 源字符串。 返回值： 返回指向目标字符串#includedest 的指针。 char str1[100] = {0}; char str2[] = "Hello World!"; strcpy(str1, str2); puts(str1);strncpy 函数 （字符串拷贝） 把 src 所指向的字符串复制到 dest ，最多复制 n 个字符。当
n
小于或等于
src
字符串长度（不包括结束字符的长度）时，则复制过去的字符串中没有包含结束字符' ；当 '
n
大于
src
字符串长度时，则会将
src
字
符串的结束字符' 也一并拷贝过去，必须保证 '
dest
指向的内存空间足够大，能够容纳下拷贝过来的字符串，否则会导致溢出错误。
strncpy()与
strcpy()
的区别在于，
strncpy()
可以指定从源字符串
src
复制到目标字符串
dest
的字符数量
char *strncpy(char *dest, const char *src, size_t n);
dest
：
目标字符串。
src
：
源字符串。
n
：
从
src
#include========================================================================= ： 要被设置的值，该值以 int 类型传递。 n ：中复制的最大字符数。 返回值： 返回指向目标字符串 dest 的指针。 内存填充 在定义数组、结构体这种类型变量时，通常需要对其进行初始化 *** 作，而初始化 *** 作一般都是将其占用的内存空间全部填充为 0 memset 函数 memset() 函数用于将某一块内存的数据全部设置为指定的值 void *memset(void *s, int c, size_t n); s ： 需要进行数据填充的内存空间起始地址。 c
#include填充的字节数。 返回值： 返回指向内存空间 s 的指针 bzero 函数 bzero() 函数用于将一段内存空间中的数据全部设置为 0 void bzero(void *s, size_t n); s ： 内存空间的起始地址。 n ：
#include
#include
#include
int main(void) {
char str[100];
memset(str, 0x0, sizeof(str));
exit(0);
} char str[100];
bzero(str, sizeof(str));
字符串比较
#includestrcmp() 函数（字符串比较） int strcmp(const char *s1, const char *s2); s1 ： 进行比较的字符串 1 。 s2
：
=========================================================================
进行比较的字符串2。
#include返回值： ⚫ 如果返回值小于 0 ，则表示 str1 小于 str2 ⚫ 如果返回值大于 0 ，则表示 str1 大于 str2 ⚫ 如果返回值等于 0 ，则表示字符串 str1 等于字符串 str2 printf("%d\n", strcmp("ABC", "ABC")); printf("%d\n", strcmp("ABC", "a")); printf("%d\n", strcmp("a", "ABC"));strncmp 函数 strncmp() 与 strcmp() 函数一样，也用于对字符串进行比较 *** 作，但最多比较前 n 个字符 int strncmp(const char *s1, const char *s2, size_t n); s1
：
参与比较的第一个字符串。 s2（字符串比较）
：参与比较的第二个字符串。 n：最多比较前 n
#include个字符。 返回值： 返回值含义与 strcmp() 函数相同。 printf("%d\n", strncmp("ABC", "ABC", 3)); printf("%d\n", strncmp("ABC", "ABCD", 3)); printf("%d\n", strncmp("ABC", "ABCD", 4));字符串查找 字符串查找在平时的编程当中也是一种很常见的 *** 作，譬如从一个给定的字符串当中查找某一个字符或者一个字符串，并获取它的位置 strchr 函数 使用 strchr() 函数可以查找到给定字符串当中的某一个字符 char *strchr(const char *s, int c); s ：
给定的目标字符串。
=========================================================================
c ： 需要查找的字符。 返回值： 返回字符 c 第一次在字符串#includes 中出现的位置，如果未找到字符 c ，则返回 NULL 。 char *ptr = NULL; char str[] = "Hello World!"; ptr = strchr(str, 'W'); if (NULL != ptr) { printf("Character: %c\n", *ptr); printf("Offset: %ld\n", ptr - str); } //Character：W //Offset：6strrchr 函数 strrchr()与 strchr() 函数一样，它同样表示在字符串中查找某一个字符，返回字符第一次在字符串中出现的位置，如果没找到该字符，则返回值 NULL ，但两者唯一不同的是， strrchr() 函数在字符串中是 从后到前 （或者称为从右向左）查找字符 ，找到字符第一次出现的位置就返回，返回值指向这个位置
char *strrchr(const char *s, int c);
char *ptr = NULL;
char str[] = "I love my home";
ptr = strchr(str, 'o');
if (NULL != ptr)
printf("strchr: %ld\n", ptr - str);
ptr = strrchr(str, 'o');
if (NULL != ptr)
printf("strrchr: %ld\n", ptr - str);
//strchr：3
//strrchr：11strstr
函数 （查找字符串的位置）与 strchr()函数不同的是，strstr()可在给定的字符串 haystack 中查找第一次出现子字符串 needle
#include的位置， 不包含结束字符' char *strstr(const char *haystack, const char *needle);
haystack
：目标字符串。
needle：需要查找的子字符串。 返回值：如果目标字符串 haystack 中包含了子字符串 needle
#include，则返回该字符串首次出现的位置；如果未能找到子字符串 needle ，则返回 NULL 。 char *ptr = NULL; char str[] = "I love my home"; ptr = strstr(str, "home"); if (NULL != ptr) { printf("String: %s\n", ptr); printf("Offset: %ld\n", ptr - str); } //String：home //Offset：10字符串与数字互转 在编程中，经常会需要将数字组成的字符串转换为相应的数字、或者将数字转换为字符串，在 C 函数库中同样也提供了相应的函数 字符串转整形数据 atoi 、 atol 、 atoll 函数（看最后一个字母）
atoi()-
（写到这突然发现有个水平线功能）
int 、 atol()- long int 、 atoll()- long long 三个函数可用于将字符串分别转换为 int 、 long int 以及 long long 类型的数据 目标字符串 nptr 中可以包含非数字字符，转换时跳过前面的空格字符（如果目标字符串开头存在空格字符），直到遇上数字字符或正负符号才开始做转换，而再遇到非数字或字符串结束时(' /0 ') 才结束转换，并将结果返回。 使用 atoi() 、 atol() 、 atoll() 函数只能转换十进制表示的数字字符串，即 0~9 。 printf("atoi: %d\n", atoi("500"));
printf("atol: %ld\n", atol("500"));
printf("atoll: %lld\n", atoll("500"));
strtol
、
strtoll
函数
strtol()-
long int
、strtoll()-
long long int
两个函数可分别将字符串转为 long int
类型数据和
long long int
#include
int atoi(const char *nptr);
long atol(const char *nptr);
long long atoll(const char *nptr);
类型数据
与 atol()
、 atoll()之间的区别在于，
strtol()
、
strtoll()
可以实现将多种不同进制数（譬如二进制表示的数字字符串、八进制表示的数字字符串、十六进制表示的数数字符串）表示的字符串转换为整形数据。
long int strtol(const char *nptr, char **endptr, int base);
long long int strtoll(const char *nptr, char **endptr, int base);
nptr
：
需要进行转换的目标字符串。
endptr
：
char **
类型的指针，如果
endptr
不为
NULL
#include，则 strtol() 或 strtoll() 会将字符串中第一个无效字符的地址存储在*endptr 中。如果根本没有数字， strtol() 或 strtoll() 会将 nptr 的原始值存储在 *endptr 中（并返回 0 ）。也可将参数 endptr 设置为 NULL ，表示不接收相应信息。 base ： 数字基数，参数 base 必须介于 2 和 36 （包含）之间，或者是特殊值 0 。参数 base 决定了字符串转换为整数时合法字符的取值范围，譬如，当 base=2 时，合法字符为 ' 0 ' 、 ' 1 ' （表示是一个二进制表示的数字字符串）；当 base=8 时，合法字符为 ' 0 ' 、 ' 1 ' 、 ' 2 ' 、 ' 3 '……' 7 ' （表示是一个八进制表示的数字字符串）；当 base=16 时，合法字符为 ' 0 ' 、 ' 1 ' 、 ' 2 ' 、 ' 3 '……' 9 ' 、 ' a '……' f ' （表示是一个十六进制表示的数字字符串）；当 base 大于 10 的时候， ' a ' 代表 10 、 ' b ' 代表 11 、 ' c ' 代表 12 ，依次类推， ' z ' 代表 35 （不区分大小写）。 返回值： 分别返回转换之后得到的 long int 类型数据以及 long long int 类型数据。 printf("strtol: %ld\n", strtol("0x500", NULL, 16)); printf("strtol: %ld\n", strtol("0x500", NULL, 0)); printf("strtol: %ld\n", strtol("500", NULL, 16)); printf("strtol: %ld\n", strtol("0777", NULL, 8)); printf("strtol: %ld\n", strtol("0777", NULL, 0)); printf("strtol: %ld\n", strtol("1111", NULL, 2)); printf("strtol: %ld\n", strtol("-1111", NULL, 2));strtoul 、 strtoull 函数 这两个函数使用方法与 strtol() 、 strtoll() 一样，区别在于返回值的类型不同， strtoul() 返回值类型是
unsigned long int，
strtoull()
返回值类型是
unsigned long long int
unsigned long int strtoul(const char *nptr, char **endptr, int base);
unsigned long long int strtoull(const char *nptr, char **endptr, int base);
printf("strtoul: %lu\n", strtoul("0x500", NULL, 16));
printf("strtoul: %lu\n", strtoul("0x500", NULL, 0));
printf("strtoul: %lu\n", strtoul("500", NULL, 16));
printf("strtoul: %lu\n", strtoul("0777", NULL, 8));
printf("strtoul: %lu\n", strtoul("0777", NULL, 0));
printf("strtoul: %lu\n", strtoul("1111", NULL, 2));
数字转字符串
数字转换为字符串推荐大家使用前面介绍的格式化 IO
相关库函数，譬如使用
printf()
将数字转字符串、并将其输出到标准输出设备或者使用 sprintf()
或
snprintf()
将数字转换为字符串并存储在缓冲区中
char str[20] = {0};
sprintf(str, "%d", 500);
puts(str);
memset(str, 0x0, sizeof(str));
sprintf(str, "%f", 500.111);
puts(str);
memset(str, 0x0, sizeof(str));
sprintf(str, "%u", 500);
puts(str);
#include字符串转浮点型数据 atof
函数
atof()
用于将
字符串
转换为一个
double 类型的浮点数据
double atof(const char *nptr);
nptr
：
需要进行转换的字符串。
返回值：
返回转换得到的
double
类型数据。
printf("atof: %lf\n", atof("0.123"));
printf("atof: %lf\n", atof("-1.1185"));
printf("atof: %lf\n", atof("100.0123"));
/*
atof:0.123000
atof:-1.118500
atof:100.012300
*/
strtod
、
strtof
#include、 strtold 函数 strtof() 、 strtod() 以及 strtold()
三个库函数可分别将字符串转换为
float 类型数据、double 类型数据、long double 类型数据
double strtod(const char *nptr, char **endptr);
float strtof(const char *nptr, char **endptr);
long double strtold(const char *nptr, char **endptr);
nptr
：
需要进行转换的目标字符串。
endptr
：
char **
类型的指针，如果
endptr
不为
#includeNULL ，则 strtol() 或 strtoll() 会将字符串中第一个无效字符的地址存储在*endptr 中。如果根本没有数字， strtol() 或 strtoll() 会将 nptr 的原始值存储在 *endptr 中（并返回 0 ）。也可将参数 endptr 设置为 NULL ，表示不接收相应信息。 printf("strtof: %f\n", strtof("0.123", NULL)); printf("strtod: %lf\n", strtod("-1.1185", NULL)); printf("strtold: %Lf\n", strtold("100.0123", NULL));给应用程序传参 根据参入不同的参数实现不同的功能，譬如，当执行应用程序的时候，把需要打开的文件路径作为参数传递给应用程序，就可以在不重新编译源码的情况下，通过传递不同的参数打开不同的文件。 注： 如果在执行应用程序时，需要向应用程序传递参数，则写法如下：int main(int argc, char **argv) { /* 代码 */ } //或者写成如下形式： int main(int argc, char *argv[]) { /* 代码 */ }传递进来的参数以字符串的形式存在， 字符串的起始地址存储在 argv 数组中 ，参数 argc 表示传递进来的 参数个数
，包括应用程序自身路径名，多个不同的参数之间使用空格分隔开来，如果参数本身带有空格、则可以使用双引号" "
或者单引号
之前讲的都是硬传参，东西都写好在代码里面，比如要改变打开文件的路径，就只能修改程序，很麻烦，真正应用时是' '
的形式来表示。 正则表达式(重要)（校验账户和密码是否合规）
给定一个字符串，检查该字符串是否符合某种条件或规则、或者从给定的字符串中找出符合某种条件或规则的子字符串，将匹配到的字符串提取出来。
C
语言中使用正则表达式
编译正则表达式
匹配正则表达式
释放正则表达式
匹配
URL
的正则表达式：
^((ht|f)tps?)://[-A-Za-z0-9_]+(\.[-A-Za-z0-9_]+)+([-A-Za-z0-9_.,@?^=%&:/~+#]*[-A-Za-z0-9_@?^=%&/~+#])?$
//获取执行应用程序时，向应用程序传递的参数。
#include
#include
int main(int argc, char *argv[])
{
int i = 0;
printf("Number of parameters: %d\n", argc);
for (i = 0; i < argc; i++)
printf(" %s\n", argv[i]);
exit(0);
}
/*
out
./testApp 0 1 2
Number of parameters:4
./testApp
0
1
2
*/ #include
#include
#include
#include
#include
int main(int argc, char *argv[])
{
regmatch_t pmatch = {0};
regex_t reg;
char errbuf[64];
int ret;
char *sptr;
int length;
int nmatch; //最多匹配出的结果
if (4 != argc) {
/**********************************
* 执行程序时需要传入两个参数:
* arg1: 正则表达式
* arg2: 待测试的字符串
* arg3: 最多匹配出多少个结果
**********************************/
fprintf(stderr, "usage: %s \n", argv[0]);
exit(0);
}
/* 编译正则表达式 */
if(ret = regcomp(®, argv[1], REG_EXTENDED)) {
regerror(ret, ®, errbuf, sizeof(errbuf));
fprintf(stderr, "regcomp error: %s\n", errbuf);
exit(0);
}
/* 赋值 *** 作 */
sptr = argv[2]; //待测试的字符串
length = strlen(argv[2]);//获取字符串长度
nmatch = atoi(argv[3]); //获取最大匹配数
/* 匹配正则表达式 */
for (int j = 0; j < nmatch; j++) {
char temp_str[100];
/* 调用 regexec 匹配正则表达式 */
if(ret = regexec(®, sptr, 1, &pmatch, 0)) {
regerror(ret, ®, errbuf, sizeof(errbuf));
fprintf(stderr, "regexec error: %s\n", errbuf);
goto out;
}
if(-1 != pmatch.rm_so) {
if (pmatch.rm_so == pmatch.rm_eo) {//空字符串
sptr += 1;
length -= 1;
printf("\n"); //打印出空字符串
if (0 >= length)//如果已经移动到字符串末尾、则退出
break;
continue; //从 for 循环开始执行
}
memset(temp_str, 0x00, sizeof(temp_str));//清零缓冲区
memcpy(temp_str, sptr + pmatch.rm_so,
pmatch.rm_eo - pmatch.rm_so);//将匹配出来的子字符串拷贝到缓冲区
printf("%s\n", temp_str); //打印字符串
sptr += pmatch.rm_eo;
length -= pmatch.rm_eo;
if (0 >= length)
break;
}
}
/* 释放正则表达式 */
out:
regfree(®);
exit(0);
} 欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）