前言
C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串 中或者 字符数组 中。
字符串常量 适用于那些对它不做修改的字符串函数.
1.求字符串长度
1.1 strlen
- 字符串以’ \0 ‘作为结束标志，strlen 函数返回的是在字符串’ \0 ‘前面出现的字符个数（不包含’ \0 '）。
- 参数指向的字符串必须要以 ’ \0 '结束。
- 注意函数的返回值为size_t，是无符号的
- 模拟实现strlen的实现。
- strlen的头文件是#include <string.h>
1.1.1 统计’ \0 '之前的字符串长度
我们来看一段代码来验证（统计第一个’ \0 '出现的位置）
int main()
{
char arr1[] = "abcdef";
size_t ret1 = strlen(arr1);
char arr2[] = "abc\0def";
size_t ret2 = strlen(arr2);
printf("arr1=%d,arr1=%d", ret1, rer2);
return 0;
}
1.1.2 返回类型是size_t（无符号整型）
int main()
{
if (strlen("abc") - strlen("abcdef") > 0)
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}
//答案: >
//数据在内存中是以补码形式存在的
//3 原码：00000000 00000000 00000000 00000011
// 补码：11111111 11111111 11111111 11111101
//6 原码：00000000 00000000 00000000 00000110
// 补码：11111111 11111111 11111111 11111001
// 显然他们的结果是 > 0的。
1.2 三种方法模拟实现（指针、计数器、递归）
1.2.1 计数器方式
int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}
1.2.2 指针的方式
int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}
1.2.3 递归的方式
int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}
2. 字符串的复制
2.1 strcpy
char *strcpy( char *strDestination, const char *strSource );
- strcpy 函数是库函数，是用来拷贝字符串的，会将源字符串中的’ \0 '拷贝到目标空间。
- strcpy 头文件 #include<string.h>。
- 源字符串必须要以 ’ \0 '结束。
- 目标空间必须要足够的大，能容纳下源字符串的内容。
- 目标空间必须可以修改，不能用const修饰。
- strcpy 函数返回的是 目标空间的起始位置。
2.1.1 strcpy 将源字符串的’ \0 '拷贝到目标空间
int main()
{
char arr1[20] = "xxxxxxxxxxxxx";
printf("%s\n", arr1);
char arr2[] = "abcdef";
strcpy(arr1, arr2);
printf("%s", arr1);
return 0;
}
2.2.2只拷贝源字符串第一个’\0’就结束了
int main()
{
char arr1[20] = "xxxxxxxxxxxxx";
printf("%s\n", arr1);
char arr2[] = "abc\0def";
strcpy(arr1, arr2);
printf("%s", arr1);
return 0;
}
2.2 strcpy 模拟实现
char* my_strcpy(char* dest, const char* src)
{
char* ret = dest;//用来返回目标函数的起始地址
assert(dest != NULL && src != NULL);//断言
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char a[20] = "xxxxxxxxxxx";
char b[] = "abfd";
my_strcpy(a, b);
printf("%s", a);
return 0;
}
思想：
1、先把*str1=*str2
2、str1++；str2++;直到 *str2==’\0’终止循环。
3、返回目标空间的起始地址，需要一个指针变量存起来。
3. 字符串的拼接
3.1strcat
- strcat函数是用来追加字符串的。
- strcat是将目标空间的’\0’的位置修改为源字符串的起始元素，然后直到源字符串的’\0’ 结束。
- 字符串必须以 ‘\0’ 结束。
- 目标空间必须有足够的大，能容纳下源字符串的内容。
- 目标空间必须可修改。
- 返回值是目标空间的起始地址。
3.1.1 代码实现strcat函数
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "abc";
char arr2[20] = "defg";
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
3.2 strcat模拟实现
#include<stdio.h>
char* my_strcat(char* str1, const char* str2)
{
char* ret = str1;
assert(str1 &&str2);//断言
while (*str1)
{
str1++;
}//结束时，*str1指向的是目标空间'\0 '的地址。
while (*str2 != '\0')//
{
*str1++ = *str2++;//将str2赋值给str1；然后分别++。
//第二个循环也可以用strcpy实现
}
return ret;//返回，目标空间的起始地址。
}
int main()
{
char arr1[20] = "abc";
char arr2[20] = "defg";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
4. 字符串的比较
4.1strcmp函数
返回值
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
那么，我们要怎么去比较两个字符串的大小？我们其实是比较两个字符串之间对应位置的ASCLL值的大小，如果相同，就比较后面一位大小，直到比较出相对应位置的大小结束。
如图：
4.2 模拟实现
#include<stdio.h>
#include<string.h>
#include <cassert>
int my_strcmp(char* p1, char* p2)
{
assert(p1 && p2);
while (*p1 == *p2)
{
if (*p1 == '\0')
return 0;
p1++;
p2++;
}
if (*p1 > *p2)
return 1;
else
return -1;
}
int main()
{
char arr1[] = "abz";
char arr2[] = "abq";
if (my_strcmp(arr1, arr2) > 0)
{
printf(">\n");
}
else if (my_strcmp(arr1, arr2) < 0)
{
printf("<\n");
}
else
{
printf("=\n");
}
printf("%d", my_strcmp(arr1, arr2));
return 0;
}
5.受限制的字符串函数（strncpy、strncat、strncmp)
接下来，我们在前面的基础上介绍受限制的字符串函数（长度受到限制）。
对比前面他们多了一个N，这个N就是操作的长度。就像strcpy和strncpy函数。他们形参的定义就有所不同：
多了一个参数 size_t。
- 拷贝n个字符从源字符到目标空间。
- 如果源字符串的长度小于n，则拷贝完源字符串之后，在目标空间后面追加0，直到n个。
- 不会将’ \0’ 考过去。
5.1 strncpy实现
假设有两个数组目标空间：str1、源字符串：str2。
n为操作数。
5.1.1 假设n<=str2长度
int main()
{
char arr1[20] = "xxxxxxxxxxxxxx";
char arr2[] = "abcdef";
strncpy(arr1, arr2,6);
printf("%s\n", arr1);
return 0;
}
这里没有拷贝’ \0 '。因为n的长度 无法接触到。
5.1.2 假设n>str2长度
int main()
{
char arr1[20] = "xxxxxxxxxxxxxx";
char arr2[] = "abcdef";
strncpy(arr1, arr2,8);
printf("%s\n", arr1);
return 0;
}
请问这里打印’ \0 ‘了吗？答案是肯定的。
请问这里有几个’ \0 '？答案是两个，这就是上面所提到的第二点。需要补0，直到和n相等。
5.2 strncat 函数。
- 从源字符串追加n个字符到目标空间
- 如果追加的长度大于源字符串的长度，则追加完源字符串以后就不会在追加了。
5.2.1 当num<=源字符串
#include<stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "abcdefg";
char arr2[] = "hijklmq";
strncat(arr1, arr2,7);
printf("%s\n", arr1);
return 0;
}
这里num<=源字符串的长度，没有打印’ \0 '。
当num>源字符串的时，只会追加到’ \0 '就停止追加了。（源字符串有多少字符元素就追加多少）。
5.3 strncmp 函数
int strncmp( const char *string1, const char *string2, size_t count );
返回值类型：
可以看到，和上面的strcmp函数是一样的。这个函数的作用是：比较指定大小 num的字符长都的大小。如：
int main()
{
char arr1[20] = "abcdefg";
char arr2[] = "abcdezg";
int len =strncmp(arr1, arr2,6);
if (len > 0)
{
printf("arr1>arr2");
}
else if (len < 0)
{
printf("arr1<arr2");
}
else
{
printf("arr1=arr2");
}
return 0;
}
我们这里比较的就是前面6个字符的大小,运行结果如下;
6.字符串查找
6.1 strstr函数
char *strstr( const char *string, const char *strCharSet );
- 在字符串中查找字符串，在前面的一个字符串中查找第二个字符串出先的位置，如果找到就返回str1中str2第一次出现的位置。如果没有找到，就返回NULL。
- 打印是由找到的地方开始向后面打印
返回值：
Each of these functions returns a pointer to the first occurrence of strCharSet in string, or NULL if strCharSet does not appear in string. If strCharSet points to a string of zero length, the function returns string.
6.1.1 strstr的使用
int main()
{
char arr1[20] = "abbcdefj";
char arr2[] = "bcd";
char* p = strstr(arr1,arr2);
if (*p == NULL)
printf("没有找到\n");
else
printf("%s\n", p);
return 0;
}
结果如图显示：
6.1.2 strstr模拟实现
根据 char *strstr( const char *str1, const char *str2 );这里的str1和str2 的指针不要乱动。我们重新创建几个指针变量：
令cp指向str1.然后开始循环 while（*cp）cp不为零进入。然后让s1指向cp，s2指向str2位置
const char* my_strstr(const char* str1, const char* str2)
{
const char * cp;//记录开始的匹配的位置
const char* s1;//遍历str1指向的字符串
const char* s2;//遍历str2指向的字符串
assert(str1 && str2);
if (*str2 == '\0')//如果str2它为空的时候，返回str1的地址。
return str1;
cp = str1;
while (*cp)//*cp不为零进入
{
s1 = cp;
s2 = str2 ;
while (s1 && s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
return cp;
cp++;
}
}
int main()
{
char arr1[20] = "abbbcdef";
char arr2[] = "bbc";
const char* p = my_strstr(arr1, arr2);
if (*p == NULL)
printf("没有找到\n");
else
printf("%s\n", p);
return 0;
}
6.2 strtok函数
char *strtok( char *str, const char *sep );
- sep参数是个字符串，定义了用作分隔符的字符集合。
- 第一个参数是一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
- strtok函数找到str中的下一个标记，将其用’ \0 '结尾，返回指向这个标记的指针（注意：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可以修改。）
- strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保留它在字符串中的位置。
- strtok函数的第一个参数为NULL，函数将在同一个字符串被保存的位置开始查找下一个标记
- 如果字符串中不存在更多的标记，则返回NULL指针。
- 若两个分隔符相邻，会跳过。
6.2.1strtok函数的使用
#include<stdio.h>
#include <string.h>
int main()
{
char arr[] = "xiaopacai@yeah.net";
char arr1[100] = { 0 };
strcpy(arr1, arr);
char* seq = { "@." };
char* ret = strtok(arr1, seq);
printf("%s\n", ret);
ret = strtok(NULL, seq);
printf("%s\n", ret);
ret = strtok(NULL, seq);
printf("%s\n", ret);
return 0;
}
上面的代码感觉冗余，可以使用循环进改进
#include<stdio.h>
#include <string.h>
int main()
{
char arr[] = "xiaopacai@yeah.net";
char arr1[100] = { 0 };
strcpy(arr1, arr);
char* seq = { "@." };
char* ret = NULL;
for (ret = strtok(arr1, seq); ret != NULL; ret = strtok(NULL, seq))
{
printf("%s\n", ret);
}
return 0;
}
运行的结果和上面的是一样的。
6.3 strerror函数
char * strerror ( int errnum );
- 函数的作用是返回错误码所对应的错误信息，返回错误信息的字符串的起始地址！
- C语言中使用库函数的时候，如果发生错误，就会将错误码放在errno的变量中，errno是一个全局变量是可以直接使用的。
6.3.1strerron函数的使用
我们以打开文件的例子来举例。
fopen 以读的形式打开文件，如果文件存在，打开成功，返回文件的起始地址。如果文件不存在，打开失败，返回NULL。
int main()
{
FILE* pf = fopen("add.txt", "r");
if (pf== NULL)
{
printf("打开文件失败，失败的原因是%s\n", strerror(errno));
}
else
{
printf("打开成功！！！\n");
}
return 0;
}
介绍完strerror函数，我们接着来看看和它很像的函数，peeeor函数，打印的形式是：自定义类型+错误码。如：
int main()
{
FILE* pf = fopen("add.txt", "r");
if (pf== NULL)
{
perror("打开文件失败");
}
else
{
printf("打开成功！！！\n");
}
return 0;
}
这两个函数非常相似。只能说他们没有好坏，只有应用的场景不同。
7.内存操作函数
7.1 memcpy函数
void * memcpy ( void * destination, const void * source, size_t num );
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数遇到’ \0 '不会停止。
- 如果source和destination由任何的重叠，复制的接结果都是未定义的。
- 其中的num是字节，比如复制一个int类型，num就是4.
这个memcpy函数和strcpy函数很相似，都是复制内容。后者可以复制的是字符串，而前者是可以复制其他的类型（int ）。
学习memcpy我们可以从strcpy函数那样入手
7.1.1 memcpy函数的使用
int main()
{
int arr1[10] = { 0 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
//把arr2中的前五个整型数据类型复制到arr1中；
memcpy(arr1, arr2, 20);
for (int i = 0; i < 5; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
7.1.2 memcpy函数的模拟实现
void my_memcpy(void *dest,void *src,size_t sz)
{
char* ret = (char*)dest;
while (sz--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
int main()
{
int arr1[10] = { 0 };
int arr2[] = { 1,2,3,4,5,6,7,8,9 };
//把arr2中的前五个整型数据类型复制到arr1中；
my_memcpy(arr1, arr2,20);
for (int i = 0; i < 5; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
请各位想一想，上面是将一个数组的数据拷贝到另外一个数组中。现在能不能将一个数组的内部进行拷贝。例如：
int arr[10]={1,2,3,4,5,6,7,8,9,10};
现在要将12345拷贝到34567的位置上，得到：1，2，1，2，3，4，5，8，9，10能否实现？？？
事实上是不行的，因为：当拷贝到元素据3时，已经被替换成1，然后进行整个数组的复制：变成了
1，2，1，2，1，2，1，8，9，10这样的结果。这时memcpy已经没有办法满足我们的需求了，接下来我们引出下面一个函数memmove函数。
7.2 memmove函数
void *memmove( void *dest, const void *src, size_t count );
可以看到memmove函数头和memcpy函数是一样的。
- 和memcpy的差别就是memmove函数处理的源内存块和目标内尺块是可以重叠的。
- 如果源空间和目标空间出现重叠，就的使用moommove函数处理。
7.2.1 memmove函数的使用
将数组第三个位置上的元素向后20个字节（5）个元素，复制到数组第一个元素。
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 ,10};
memmove(arr, arr + 2, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
一般情况下数组名代表的是数组首元素的地址，因此我们向数组传递时，分别传递我们要进行操作的两个数据的地址就可以。
7.2.2模拟实现mommove函数
在开始模拟实现memmove函数之前，我们先来探讨下mommove函数的两种情况：
1.从后往前开始拷贝
例如：1，2，3，4，5拷贝到3，4，5，6，7，先把5拷贝到7的位置，再把4拷贝到6的位置，依次进行拷贝。代码如下：
void* my_memmove(void* dest, const void* src, size_t num)
{
char *ret = (char*)dest;
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
return ret;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 ,10};
my_memmove(arr+2, arr , 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
这里需要注意的是：我们是从后面开始向前一个一个字节的拷贝，这里的两个指针dest和src都要指向末尾，也就是加上num，然后在解引用。
如果是将3，4，5，6，7拷贝到1，2，3，4，5上能不能实现啊？
代码出现了错误，说明代码还有缺陷。
2.从前往后开始拷贝
接着上边的讨论，这里思考下，我们从前往后拷贝，dest和str函数是一来就指向开始的地址，不需要加上num。然后一个一个字节的拷贝。
void* my_memmove(void* dest, const void* src, size_t num)
{
char *ret = (char*)dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
就能实现从前往后的打印。但是要怎样区分他们的区别呢？这里我们可以判断dest和str这两个指针的大小，然后将他们两个给合并在一起就可以完美实现了。代码如下：
void* my_memmove(void* dest, const void* src, size_t num)
{
char *ret = (char*)dest;
if (dest < src)//从前往后
{
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else//从后往前
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
这样就完美的实现memmove函数了。
7.3memset函数
这个函数是内存设置函数，作用是修改内存中的若干个数据，这里只要求会使用，不要求模拟。
void *memset( void *dest, int c, size_t count );
其中：dest是要修改的数据的起始地址。c是 修改后的数据。count是修改的数量。
看看如何使用它：
将hello world中的worl修改为 *。
int main()
{
char arr[] = "hello world";
memset(arr + 6, '*' ,4);
printf("%s", arr);
return 0;
}
注意，memset函数只能一个字节一个字节的操作。
7.4 memcmp
是一个内存比较函数。但是这个函数比较特殊，它可以让你指定比较的位置和数量。会使用就可。
int memcmp( const void *buf1, const void *buf2, size_t count );
其中的count是字节哦
它的返回值和strcmp是一样的。都是1，0 ，-1 。
来看具体的使用：
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[] = { 1,2,3,4,5 };
int ret = memcmp(arr1 + 1, arr2, 20);
printf("%d", ret);
return 0;
}
这里2>1,所以 结果返回的是1.
分享到此结束！！！
扫一扫
1033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
