C 标准库 string常用函数笔记

2023-05-16

文章目录

@[TOC](文章目录)

前言
字符串长度
strlen()
sizeof

字符串拼接
strcat()
strncat()

字符串拷贝
strcpy()
strncpy()
memcpy()

内存填充
memset()

字符串比较
strcmp()
strncmp()

字符串查找
strchr()
strrchr()
strstr()

字符串与数字互转
atoi()、 atol()
strtol()
strtoul

字符串转浮点型数据
atof()
strtod() strtof()

前言

C 标准库 string.h 常用函数梳理

字符串长度

strlen()

计算字符串长度的函数 strlen()

#include <string.h>
size_t strlen(const char *s);

s： 需要计算的字符串，字符串必须包含结束字符’ \0 '。
return：返回字符串长度（以字节为单位）

例如：

char str[] = "1234567890abcde";
printf("Length: %ld\n", strlen(str));

结果为 Length: 15

sizeof

统计数据类型所占用的内存大小

sizeof 和 strlen 的区别

sizeof 用来计算数据类型或变量大小，strlen 只能以结尾为’ \0 '的字符串作为参数

char str[20] = "1234567890abcde";
printf("sizeof: %ld\n", sizeof(str));
printf("strlen: %ld\n", strlen(str))

结果为sizeof: 20 strlen:15

字符串拼接

strcat()或 strncat()用于将两个字符串连接起来，strncat 可以指定源字符串追加到目标字符串的字符数量

strcat()

#include <string.h>
char *strcat(char *dest, const char *src);

dest： 目标字符串。
src： 源字符串。
return： 返回指向目标字符串 dest 的指针。

strcat()函数会把 src 字符串追加到 dest 字符串的末尾，所以必须要保证 dest 有足够的存储空间来容纳两个字符串，否则会导致溢出错误

strncat()

strncat 可以指定源字符串追加到目标字符串的字符数量

#include <string.h>
char *strncat(char *dest, const char *src, size_t n);

dest：目标字符串。
src： 源字符串。
n： 要追加的最大字符数。
return： 返回指向目标字符串 dest 的指针。

注意实际追到到dest字符串的数量为n+1（结束字符’ \0 '）

char str1[100] = "Linux app strcat test, ";
char str2[] = "Hello World!";
strncat(str1, str2, 5);
puts(str1);

结果为： Linux app strcat test,Hello

字符串拷贝

拷贝函数会将目标字符串覆盖

strcpy()函数和 strncpy()函数用于实现字符串拷贝,strncpy()可以指定复制到目标的字符数量

strcpy()

#include <string.h>
char *strcpy(char *dest, const char *src);

dest： 目标字符串。
src： 源字符串。
return： 返回指向目标字符串 dest 的指针。

strcpy()会把 src 指向的字符串复制到 dest中，必须保证 dest 指向的内存空间足够大，否则会导致溢出错误

char str1[100] = "123456789";
char str2[] = "Hello World!";
strcpy(str1, str2);
puts(str1); //Hello World!

结果 Hello World!

strncpy()

strncpy()可以指定从源字符串 src 复制到目标字符串 dest 的字符数量

#include <string.h>
char *strncpy(char *dest, const char *src, size_t n);

dest： 目标字符串。
src： 源字符串。
n： 从 src 中复制的最大字符数。
return： 返回指向目标字符串 dest 的指针。

char str1[100] = "12345678910";
char str2[] = "Hello World!";
strncpy(str1, str2, 5);
puts(str1);	//Hello678910

memcpy()

可以从 str2 复制 n 个字节到str1

#include <string.h>
void *memcpy(void *str1, const void *str2, size_t n)

str1： 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
str2：指向要复制的数据源，类型强制转换为 void* 指针。
n：要被复制的字节数。

注意：n为字节数并非个数
例如：

	int data[50] = { 1,2,3,4,5 };
	int str[20] = {10,11,12,13,14,15 };
	memcpy(data + 6, str, 4);
	for (int i = 0; i < 15; i++)
		printf("%d ", data[i]);

实际输出为：1 2 3 4 5 0 10 0 0 0
int变量为4个字节，所以只复制了一个数据到data数组中，如需要全部复制使用sizeof()

char str1[100];
char str2[]="ABCD";
memcpy(str1,str2,sizeof(str2));
printf("%s",str1);  //ABCD

内存填充

memset()

memset()函数用于将某一块内存的数据全部设置为指定的值，但它是以字节为单位进行初始化的。

#include <string.h>
void *memset(void *s, int c, size_t n);

s：需要进行数据填充的内存空间起始地址。
c：要被设置的值，该值以 int 类型传递。
n：填充的字节数。
return：返回指向内存空间 s 的指针。

char str[100];
memset(str, 0x0, sizeof(str));

对数组 str 进行初始化操作，将全部设置为 0

字符串比较

比较函数有：strcmp()和 strncmp()， strcmp(）

strcmp()

#include <string.h>
int strcmp(const char *s1, const char *s2);

s1： 进行比较的字符串 1。
s2： 进行比较的字符串 2。
return：
小于 0， str1 小于 str2
大于 0， str1 大于 str2
等于 0， str1 等于 str2

printf("%d\n", strcmp("ABC", "ABC"));	//0
printf("%d\n", strcmp("ABC", "a"));		//-1
printf("%d\n", strcmp("a", "ABC"));		//1

strncmp()

和strcmp()一样，区别在于比较前 n 个字符

#include <string.h>
int strncmp(const char *s1, const char *s2, size_t n);

s1： 参与比较的第一个字符串。
s2： 参与比较的第二个字符串。
n： 最多比较前 n 个字符。
return： 返回值含义与 strcmp()函数相同。

printf("%d\n", strncmp("ABC", "ABC", 3));	//0
printf("%d\n", strncmp("ABC", "ABCD", 3));	//0
printf("%d\n", strncmp("ABC", "ABCD", 4));	//-1

字符串查找

在给定的字符串中查找某个字符或字符串，并获取它的位置： strchr()、strrchr()、 strstr()、

strchr()

使用 strchr()函数可以查找到给定字符串当中的某一个字符

#include <string.h>
char *strchr(const char *s, int c);

s： 给定的目标字符串。
c： 需要查找的字符。
return： 返回字符 c 第一次在字符串 s 中出现的位置，未找到，则返回 NULL。

char *ptr = NULL;
char str[] = "Hello World!";
ptr = strchr(str, 'W');
if (NULL != ptr) {
	printf("Character: %c\n", *ptr);
	printf("ptr is: %s\n", ptr);
	printf("Offset: %d\n",  ptr - str );
}

//输出结果为
Character: W
ptr is: World!
Offset: 6

可以看出strchr返回第一个要查找的字符的指针, 实际结果就是返回第一个要查找的字符后面的字符串(并且包含此查找字符本身).

strrchr()

strrchr()函数在字符串中是从后到前（或者称为从右向左）查找字符，找到字符第一次出现的位置就返回，返回值指向这个位置

#include <string.h>
char *strrchr(const char *s, int c);

char *ptr = NULL;
char str[] = "I love my home";
	
ptr = strchr(str, 'o');
printf("ptr is: %s\n", ptr);
printf("strchr: %ld\n", ptr - str);
	
ptr = NULL;	
	
ptr = strrchr(str, 'o');
printf("ptr is: %s\n", ptr);
printf("strrchr: %ld\n", ptr - str);

//输出结果为
ptr is: ove my home
strchr: 3
ptr is: ome
strrchr: 11

strrchr函数是从后开始查找字符的

strstr()

strstr()可在给定的字符串 haystack 中查找第一次出现子字符串 needle 的位置

#include <string.h>
char *strstr(const char *haystack, const char *needle);

haystack： 目标字符串。
needle： 需要查找的子字符串。
return： 如果目标字符串 haystack 中包含了子字符串 needle，则返回该字符串首次出现的位置；未找到返回 NULL。

char *ptr = NULL;
char str[] = "I love my home";
	
ptr = strstr(str, "home");
	
printf("Character: %c\n", *ptr);	
printf("ptr is: %s\n", ptr);
printf("strrchr: %ld\n", ptr - str);

//输出结果为
Character: h
ptr is : home
strrchr: 10

字符串与数字互转

atoi()、 atol()

atoi 将字符串转换为 int
atol将字符串转换为 long int

#include <stdlib.h>
int atoi(const char *nptr);
long atol(const char *nptr);

nptr： 需要进行转换的字符串。
返回值： 分别返回转换之后得到的 int 类型数据、 long int 类型数据

printf("atoi: %d\n", atoi("500"));	//500
printf("atol: %ld\n", atol("500"));	//500

strtol()

strtol()可以实现将多种不同进制数（譬如二进制的字符串、八进制的字符串、十六进制的字符串）表示的字符串转换为long int 数据

#include <stdlib.h>
long int strtol(const char *nptr, char **endptr, int base);

nptr： 需要进行转换的目标字符串。
endptr： char **类型的指针，如果 endptr 不为 NULL，则 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 不区分大小写
在 base=0 的情况下，如果字符串包含一个了“0x”前缀，表示该数字将以 16 为基数；如果包含的是“0”前缀，表示该数字将以 8 为基数。

printf("strtol: %ld\n", strtol("0x500", NULL, 16));	//1280
printf("strtol: %ld\n", strtol("0x500", NULL, 0));	//1280
printf("strtol: %ld\n", strtol("500", NULL, 16));	//1280
printf("strtol: %ld\n", strtol("0777", NULL, 8));	//511
printf("strtol: %ld\n", strtol("0777", NULL, 0));	//511
printf("strtol: %ld\n", strtol("1111", NULL, 2));	//15
printf("strtol: %ld\n", strtol("-1111", NULL, 2));	//-15

strtoul

使用方法与 strtol()一样，区别在于strtoul()返回值类型是 unsigned long int

#include <stdlib.h>
unsigned long int strtoul(const char *nptr, char **endptr, int base);

printf("strtoul: %lu\n", strtoul("0x500", NULL, 16));	//1280
printf("strtoul: %lu\n", strtoul("0x500", NULL, 0));	//1280
printf("strtoul: %lu\n", strtoul("500", NULL, 16));		//1280
printf("strtoul: %lu\n", strtoul("0777", NULL, 8));		//511
printf("strtoul: %lu\n", strtoul("0777", NULL, 0));		//511
printf("strtoul: %lu\n", strtoul("1111", NULL, 2));		//15

字符串转浮点型数据

atof()

#include <stdlib.h>
double atof(const char *nptr);

nptr： 需要进行转换的字符串。
return： 返回转换得到的 double 类型数据

printf("atof: %lf\n", atof("0.123"));		//0.123000
printf("atof: %lf\n", atof("-1.1185"));		//-1.118500
printf("atof: %lf\n", atof("100.0123"));	//100.012300

strtod() strtof()

strtof()、 strtod() 可分别将字符串转换为 float 类型数据、 double 类型数据

#include <stdlib.h>
double strtod(const char *nptr, char **endptr);
float strtof(const char *nptr, char **endptr);

使用与strtol()含义相同

printf("strtof: %f\n", strtof("0.123", NULL));			//0.123000
printf("strtod: %lf\n", strtod("-1.1185", NULL));		//-1.118500
printf("strtold: %Lf\n", strtold("100.0123", NULL));	//100.012300

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)