目录
一.字符串操作函数
1.求字符串长度
strlen函数：字符串长度
size_t strlen ( const char * str );字符串的结束标志是'\0'，所以strlen也是根据一个字符串'\0'的位置来求得字符串的长度。
头文件：string.h 返回值：字符串长度的无符号整型
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "abcdef";
int len = strlen(str);
printf("%d\n",len);
return 0;
}//模拟实现：
#include <stdio.h>
#include <assert.h>
int my_strlen(const char* ps)
{
assert(ps);
int count = 0;
while (*ps++)
{
count++;
}
return count;
}
int main()
{
char str[] = "abcdef";
int len = my_strlen(str);
printf("%d\n", len);
return 0;
}2.长度不受限制的字符串操作函数
strcpy函数：字符串拷贝
char* strcpy(char * destination, const char * source );几个注意事项：
1.源字符串必须以'\0'为结束标志
2.源字符串中的'\0'也会被拷贝到目标空间
3.目标空间足够大，确保能存放源字符串
4.目标空间必须可变（这里的意思主要是目标空间不能是常量字符串）
头文件：string.h 返回值：目标空间的起始地址
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "abcdef";
char des[20] = "0";
char* ps = strcpy(des, str);
puts(ps);
return 0;
}//模拟实现：
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest,const char* src)
{
assert(dest && src);
char* start = dest;
while (*dest++ = *src++)
{
;
}
return start;
}
int main()
{
char str1[20] = "0";
char str2[] = "abcdef";
char* ps = my_strcpy(str1, str2);
printf("%s\n", ps);
return 0;
}strcat函数：字符串拼接
char * strcat ( char * destination, const char * source );几个注意事项：
1.源字符串必须以'\0'为结束标志
2.目标空间足够大，能容纳下追加源字符串的所有内容
3.目标空间可修改
4.是可以实现源字符串自己给自己追加的，例如：
//能实现的原因也还是使用了未完全初始化的字符串，保证有足够的空间来追加
#include <stdio.h>
#include <string.h>
int main()
{
char str[20] = "abcdef";
char* ps = strcat(str, str);
printf("%s\n", ps);
return 0;
}
头文件：string.h 返回值：目标空间的起始地址
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "abcdef";
char str2[] = "ghijkl";
char* ps = strcat(str1, str2);
printf("%s\n", ps);
return 0;
}//模拟实现：
#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest,const char* src)
{
assert(dest && src);
char* start = dest;
while (*dest)
{
dest++;
}
while (*dest++ = *src++)
{
;
}
return start;
}
int main()
{
char str1[20] = "abcd";
char str2[] = "efgh";
char* p = my_strcat(str1, str2);
printf("%s\n", p);
return 0;
}strcmp函数：字符串比较
int strcmp ( const char * str1, const char * str2 );strcmp是从两个字符串的第一个字符开始比较每一个字符的ASCII码值，相等就继续比较下一个字符，不等则返回正数/负数。
头文件：string.h
返回值：
第一个字符串大于第二个字符串则返回大于0的数字；
第一个字符串等于第二个字符串则返回0；
第一个字符串小于第二个字符串则返回小于0的数字；
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[] = "abcdef";
char str2[] = "abcdeg";
int ret = strcmp(str1, str2);
printf("%d\n", ret);
return 0;
}//模拟实现：
#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* src, const char* dst)
{
assert(src && dst);
int ret = 0;
while (!(ret = *(unsigned char*)src - *(unsigned char*)dst) && *dst)
++src, ++dst;
if (ret < 0)
ret = -1;
else if (ret > 0)
ret = 1;
return ret;
}
int main()
{
char str1[] = "abc";
char str2[] = "abca";
char str3[] = "abce";
char str4[] = "abcdef";
char str5[] = "abcdef";
int ret1 = my_strcmp(str1, str2);
int ret2 = my_strcmp(str1, str3);
int ret3 = my_strcmp(str1, str4);
int ret4 = my_strcmp(str1, str5);
printf("%d\n", ret1);
printf("%d\n", ret2);
printf("%d\n", ret3);
printf("%d\n", ret4);
return 0;
}3.长度受限制的字符串操作函数
strncpy函数：拷贝指定数目的字符串
char * strncpy ( char * destination, const char * source, size_t num );strncpy函数是从源字符串拷贝num个字符至目标空间，如果源字符串长度小于num，则拷贝完源字符串后，在后面追加0，直至num个。
头文件：string.h 返回值：目标空间的起始地址
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[] = "abcdefgh";
char str2[] = "dcab";
char* ps = strncpy(str1, str2, 2);
puts(ps);
return 0;
}
//结果：dccdefghstrncat函数：追加指定数目的字符串
char * strncat ( char * destination, const char * source, size_t num );strncat函数是从源字符串追加num个字符至目标空间，如果源字符串长度小于num，仅追加到源字符串'\0'的结尾处。
头文件：string.h 返回值：目标空间的起始地址
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "abcdefgh";
char str2[] = "ijkl";
char* ps = strncat(str1, str2, 2);
puts(ps);
return 0;
}
//结果：abcdefghijstrncmp函数：比较指定数目的字符串
int strncmp ( const char * str1, const char * str2, size_t num );strncmp函数比较到出现字符不一样、一个字符串结束、或者num个字符全部比较完成。
头文件：string.h
返回值：
第一个字符串大于第二个字符串则返回大于0的数字；
第一个字符串等于第二个字符串则返回0；
第一个字符串小于第二个字符串则返回小于0的数字；
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[] = "abcdef";
char str2[] = "abcdfg";
char str3[] = "abcefg";
int ret1 = strncmp(str1, str2, 4);
int ret2 = strncmp(str1, str2, 5);
int ret3 = strncmp(str3, str2, 4);
printf("%d\n%d\n%d\n", ret1,ret2,ret3);
return 0;
}
//结果：0、-1、14.字符串查找函数
strstr函数：字符串匹配函数（子串查找）
char * strstr ( const char *str1, const char * str2);strstr函数是判断字符串str2是不是字符串str1的子串，找到了则返回str2在str1中第一次出现的位置的地址，没找到则返回空指针。
头文件：string.h 返回值：子串在主串中第一次出现的地址
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[] = "ababcabcd";
char str2[] = "abcd";
char* ps = strstr(str1, str2);
if (NULL != ps)
{
puts(ps);
}
return 0;
}
//结果： abcdstrstr函数功能的实现分为暴力搜索和KMP搜索两种，这里主要说明前者的实现思想：
//模拟实现：
#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* s1,const char* s2)
{
assert(s1&&s2);
char* cur = s1;
char* start = s2;
while (*cur)
{
s1 = cur;
s2 = start;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return cur;
}
cur++;
}
return NULL;
}
int main()
{
char str1[] = "ababcabcd";
char str2[] = "abcd";
char* p = my_strstr(str1, str2);
printf("%s\n", p);
return 0;
}
strtok函数：分隔符分隔字符串函数
char * strtok ( char * str, const char * sep );几个注意事项：
1. sep参数是个字符串，定义了用作分隔符的字符集合
2. 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
3. strtok函数找到str中的下一个标记，并将其用\0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。）
4. strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
5.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。
6. 如果字符串中不存在更多的标记，则返回 NULL 指针。
头文件：string.h
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "XXXXXXXXX@XXX.com";
const char* sep = "@.";
//拷贝一份str，因为strtok的操作会改变str
char buff[20] = "0";
strcpy(buff, str);
//第一个参数不为NULL
char* ps = strtok(buff, sep);
puts(ps);
//第一个参数为NULL
ps = strtok(NULL, sep);
puts(ps);
ps = strtok(NULL, sep);
puts(ps);
return 0;
}
结果：XXXXXXXX、XXX、com上面的代码主要是为了演示strtok函数的作用，但是实际上写代码不会写成上面的方式，毕竟当str字符串中不止两个分隔符"@."时，肯定无法通过上面的代码完整分割str。
//strtok利用循环的用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "XXXXXXXXX@XXX.com";
const char* sep = "@.";
char buff[20] = "0";
strcpy(buff, str);
for (char* ps = strtok(buff, sep); ps!=NULL; ps = strtok(NULL, sep))
{
printf("%s\n", ps);
}
return 0;
}5.错误信息报告函数
strerror函数：打印错误信息
char * strerror ( int errnum );当代码出现错误时，错误信息会存到errno这个全局变量中，通过调用<errno.h>使用，而strerror函数就是将errno错误码所对应的错误信息以字符串的形式打印出来。
头文件：string.h 返回值：错误码对应的错误信息
#include <stdio.h>
#include <string.h>
#include <errno.h>//必须包含的头文件
int main()
{
FILE* pFile;
pFile = fopen("unexist.ent", "r");
if (pFile == NULL)
printf("Error opening file unexist.ent: %s\n", strerror(errno));
//errno: 错误码
return 0;
}二.字符操作函数
字符判断函数：
| 函数： | 如果函数参数符合下列条件就返回真 |
|---|---|
| iscntrl | 任何控制字符 |
| isspace |
空白字符：空格
‘ ’
，换页
‘\f’
，换行
'\n'
，回车
‘\r’
，制表符
'\t'
或者垂直制表符
'\v'
|
|
isdigit
|
十进制数字
0~9
|
|
isxdigit
|
十六进制数字，包括所有十进制数字，小写字母
a~f
，大写字母
A~F
|
|
islower
|
小写字母
a~z
|
|
isupper
|
大写字母
A~Z
|
|
isalpha
|
字母
a~z
或
A~Z
|
|
isalnum
|
字母或者数字，
a~z,A~Z,0~9
|
|
ispunct
|
标点符号，任何不属于数字或者字母的图形字符（可打印）
|
|
isgraph
|
任何图形字符
|
|
isprint
|
任何可打印字符，包括图形字符和空白字符
|
字符转换函数：
| 函数： | 功能： |
|---|---|
| tolower | 将大写字母转换成小写字母 |
| toupper | 将小写字母转换成大写字母 |
三.内存操作函数
memset函数：
void *memset( void *dest, int c, size_t count );memset函数可以将目标空间dest中指定数量的字节count的目标设置成目标值c。
头文件：string.h 返回值：指向目标空间的起始地址的空类型的指针（使用时建议强制类型转换）
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
int arr[100];
//因为memset操作的单位是字节，一个整形占用4个字节
memset(arr,0,400);
return 0;
}memcpy函数：
void * memcpy ( void * destination, const void * source, size_t num );几个注意事项：
1. 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
2. 这个函数在遇到 '\0' 的时候并不会停下来。
3. 如果source和destination有任何的重叠，复制的结果都是未定义的（取决于编译器）。
//用法：
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "abcdef";
char temp[10] = "0";
char* ps=(char*)memcpy(temp, str, strlen(str));
puts(ps);
return 0;
}
//结果：abcdef//模拟实现：
void* my_memcpy(void* dest, void* src, int count)
{
void* start = dest;
while (count--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return start;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[40] = { 0 };
my_memcpy(arr2, arr1, sizeof(arr1));
return 0;
}memmove函数：
void * memmove ( void * destination, const void * source, size_t num )；当在同一个数组或字符串中操作时，并且目标空间和源空间有重叠时，使用memcpy函数可能不会达到预期的结果。
//例子：
#include <stdio.h>
#include <string.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
memcpy(arr + 2, arr, 5 * sizeof(arr[0]));
for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
return 0;
}
//在VS编译器下的结果：1 2 1 2 3 4 5 8 9 10
//有可能出现的结果：1 2 1 2 1 2 1 8 9 10之所以会出现第二种结果，是因为当拷贝arr[3]至arr[5]时，arr[3]的值已经是1了，而不是最初的3。这种情况下，用memmove函数就不会出现这样的问题。
#include <stdio.h>
#include <string.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr + 2, arr, 5 * sizeof(arr[0]));
for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
return 0;
}
//结果：1 2 1 2 3 4 5 8 9 10
memmove函数模拟实现思想：
//模拟实现：
#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dest, void* src, int count)
{
assert(dest && src);
void* start = dest;
if (dest < src)
{
//前->后
while (count--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
//后->前
while (count--)
{
*((char*)dest + count) = *((char*)src + count);
}
}
return start;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//my_memmove(arr + 2, arr, 20);
my_memmove(arr, arr + 2, 20);
return 0;
}memcmp函数：
int memcmp ( const void * ptr1, const void * ptr2, size_t num );memcmp函数是一个以字节为单位的比较函数。类似于strncmp，不多赘述。
3566
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
