【C语言】字符串函数+函数内存的介绍

作者简介：大家好我是狂暴于涛侠本侠，本人写博客主要是方便自己学习复习，所以内容的量可能比较夸张，如果能静下心来阅读一定会受益匪浅
🦸个人主页：狂暴于涛侠
支持我：点关注不迷路提高彼此亲密度💌💌💌

本次我们将会介绍学习处理字符和字符串的库函数的使用和注意事项

函数介绍

字符串长度获取函数
       ·strlen

长度不受限制的字符串函数
       ·strcpy
       ·strcat
       ·strcat
       ·strcmp

长度受限制的字符串函数介绍
       ·strncpy
       ·strncat
       ·strncmp

字符串查找
       ·strstr
       ·strtok

错误信息报告
          ·strerror

字符操作

内存操作函数
       ·memcpy
       ·memmove
       ·memset
       ·memcmp

🐇1.求字符串长度

🏳‍🌈1 strlen字符串长度函数

注意函数的返回值为size_t，是无符号的（ 易错 ）

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "abc"; //这种写法后面自动补齐\0
	int len  = strlen(arr);
	printf("%d\n", len);//3 \0不算长度

    char arr1[] = { 'a', 'b', 'c' };//这种写法后面不自动补齐\0
    int len1  = strlen(arr1);
	printf("%d\n", len1);//未知值 直到遇到\0才结束
	return 0;
}

小练习

int main()
{
	if (strlen("abc") - strlen("abcdef") > 0)
	{
		printf(">\n");
	}
	else
	{
		printf("<=\n");
	}
	return 0;
}

结果为 >
为什么呢？因为strlen库函数中返回值是无符号整形 3-6 的得数是个很大的正数而不是一个负数

自己重新写一个my_strlen函数就可以避免错误 返回值不设置 size_t
int my_strlen(const char* str)
{
	int count = 0;//计数器
	assert(str != NULL);

	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	if (my_strlen("abc") - my_strlen("abcdef") > 0)
	{
		printf(">\n");
	}
	else
	{
		printf("<=\n");//结果为这个
	}
	return 0;
}

---

🐇2.长度不受限制的字符串函数

🏳‍🌈2.1 strcpy字符串拷贝函数

关于strcpy函数有以下几点要注意
1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
4.目标空间必须可变。

假如我们修改一个已经创建的数组里面的元素，改为xixi

所以就需要引入strcpy这个库函数

  //1.源字符串必须以 '\0' 结束。
	char arr[20] = "########";
	char arr2[] = { 'a', 'b', 'c' };
	strcpy(arr, arr2);
	printf("%s\n", arr)//没有\0会一直向后找\0 所以会出现问题

    //2.会将源字符串中的 '\0' 拷贝到目标空间
	char arr[20] = "########";
	strcpy(arr, "hello");//其中\0也被拷过去当遇到 \0停止拷贝
	printf("%s\n", arr)

    //3.目标空间必须足够大，以确保能存放源字符串。
	char arr[5] = "####";
	char* p = "lovejjy";//程序奔溃 arr中只有5个元素 lovejjy中元素过多将数组撑爆了
	strcpy(arr, p);
	printf("%s\n", arr);

    //4.目标空间必须可变
	char* str = "xxxxxxxxxxxxxxxxxxx";
	char* p = "lovejjy";
	strcpy(str, p);//? 肯定不行啊 目标空间是常量字符串最起码也要可以修改啊
    printf("%s\n", arr);

🏳‍🌈2.2strcat字符串追加函数

标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

	//一般写法
	char arr1[20] = "hello ";
	char arr2[] = "world";
	printf("%s\n", strcat(arr1, "jjy"));//hello jjy
	printf("%s\n", strcat(arr1, arr2));//hello word

    char arr1[20] = "hello \0#########";//在前面加入\0
	char arr2[] = "world";
	char arr3[] = {'j','j','y'}; 
	printf("%s\n", strcat(arr1, "jjy"));//hello jjy
	printf("%s\n", strcat(arr1, arr2));//hello jjyword
	printf("%s\n", strcat(arr1, arr3));//hello jjywordjjy烫烫烫烫烫烫烫烫烫烫烫烫 ? 耇 ?
	由此可以看出是新的字符串覆盖掉源字符串的\0，
	并且将自己的\0同样复制过去，
	所以这就要求要追加的字符串自己必须有\0

写一个自己的strcat函数
原理：

char* my_strcat(char* dest, const char*src)
{
	char* ret = dest;//保存原数组起始位置，结束返回起始位置
	assert(dest && src);
	//1. 找目标字符串中的\0
	while (*dest)
	{
		dest++;
	}
	//2. 追加源字符串,包含\0
	while(*dest++ = *src++)
	{
		;
	}

	return ret;//返回的目标空间的起始地址
}

int main()
{
	char arr1[20] = "hello ";//world
	char arr2[] = "world";
	//my_strcat(arr1, arr2);//字符串追加（连接）
	printf("%s\n", my_strcat(arr1, arr2));

	return 0;
}

想一下下面代码可能实现么？
 
int main()
{
	char arr[20] = "abcd";
	strcat(arr, arr);//?
	printf("%s\n", arr);//err
	return 0;
}

解释

🏳‍🌈2.3 strcmp字符串比较函数

如果说比较字符串长度你觉得下面方法可以么？

int main()
{
	char* p = "obc";
	char* q = "abcdef";
	//方法一
	if (p > q)
	{
		printf(">\n");
	}
	else
	{
		printf("<=\n");
	}

    //方法二
	if ("obc" > "abcdef")
	{

	}

其实上面放方法无论那个都是错的
方法一：p和q比较实际是字符串的首元素地址比较的就是o和a
方法二：同理比较的其实都是首元素地址

 
下面这个函数就是解决这个问题的

//strcmp - 字符串比较大小的  ASCLL码值

	int ret1 = strcmp("abbb", "abq");//ab相等比较的是b和q
	int ret2 = strcmp("abzb", "abq");//ab相等比较的是z和q
	int ret3 = strcmp("aaa", "aaa"); //aaa\0和aaa\0完全相等
	printf("%d\n", ret1);// -1
	printf("%d\n", ret2);// 1
	printf("%d\n", ret3);// 0

实现strcmp函数

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	return *s1 - *s2;//只需要返回正数负数就可不需要考虑是不是-1或1
}


int main()
{
	char arr[] = {"abcdef"};
	char* p = arr;
	char arr2[] = { "abcdea" };
	char* q = arr2;

	int ret = my_strcmp(p, q);

	if (ret > 0)
	{
		printf("p > q\n");//结果
	}
	else if (ret < 0)
	{
		printf("p < q\n");
	}
	else
	{
		printf("p == q\n");
	}

	return 0;
}

---

注意上面的 strcmp strcpy strcat 是长度不受限制的字符串函数
就是你想复制改变比较多少都可以的对于长度没有限制

---

🐇3.长度受限制的字符串函数介绍

🏳‍🌈3.1strncpy字符串拷贝函数

优点：更加安全，避免安排不合理引发的数组越界 因为目标空间可能放不下需要拷贝的字符串

int main()
{
   	char arr1[20] = "abcdefghi";
   	char arr2[] = "qwer";
   	strncpy(arr1, arr2, 2);
    printf("%s\n", arr1);//qwcdefghi
    
    char arr3[20] = "abcdefghi";
    char arr4[] = "qwer";
    strncpy(arr3, arr4, 6);
    printf("%s\n", arr3);//qwer
   	return 0;
}

🏳‍🌈3.2strncpy字符串追加函数

以下是代码案例👓

int  main()
{
  char arr1[20] = "hello ";        
  char arr2[] = "world";
  strncat(arr1, arr2, 3);
  printf("%s\n", arr1);//hello wor\0


  char arr3[20] = "hello ";
  char arr4[] = "world";
  strncat(arr3, arr4, 10);
  printf("%s\n", arr3);//hello word\0

  return 0;
}

🏳‍🌈3.3 strncmp字符串比较函数

以下为代码区别：
int  main()
{
   char arr1[20] = "abcqwert ";	         
   char arr2[] = "abcdef";
   int ret = strncmp(arr1, arr2, 3);
   printf("%d\n", ret);//输出 0

   char arr3[20] = "abcqwert ";
   char arr4[] = "abcdef";
   int ret1 = strcmp(arr3, arr4);
   printf("%d\n", ret1);//输出 1
   return 0;
}

---

🐇4.字符串查找

🏳‍🌈4.1 strstr查找子字符串，就是在一个字符串中找另一个字符串

int main()
{
   char arr1[] = "abbbcdef";
   char arr2[] = "bbc";

   //在arr1中查找是否包含arr2数组
   char* ret = strstr(arr1, arr2);
   if (ret == NULL)
   {
   	printf("没找到\n");
   }
   else
   {
   	printf("找到了：%s\n", ret);//输出： 找到了：bbcdef
   }
   return 0;
}

那么我们可以模拟一下改函数的实现。

char* my_strstr(const char* str1, const char* str2)
{
   assert(str1 && str2); //防止str1 str2是空指针
   const char* s1 = NULL;//储存str1 的起始位置
   const char* s2 = NULL;//储存str2 的起始位置
   const char* cp = str1; // 储存在str1上移动的位置

   if (*str2 == '\0')//如果str2字符中第一个就是\0 返回str1的地址
   {
   	return (char*)str1;
   }

   while (*cp)//只要*cp不取到\0就一直循环
   {
   	s1 = cp;//储存str1 的起始位置
   	s2 = str2;//储存str2 的起始位置
   	
   	//abcdef
   	//  cdef
   	while (*s1 && *s2 && (*s1 == *s2))  //s1，s2指针不为\0,且s1的值等于s2的值
   	{
   		s1++;
   		s2++;
   	}
   	if (*s2 == '\0')//当s2等于/0说明比较完毕 返回cp的指针
   	{
   		return (char*)cp;
   	}
   	cp++;//当出现前几个字符相同，但是有不同的后，让cp向前加一位从新比较
   }

   return NULL;//没有相同字符串的返回空指针
}

4.2 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 指针。

int main()
{
	char arr[] = "tx@baidu.wyu zjtd";
	char arr1[] = "@. ";
	char* p = arr1;
	char tmp[30] = { 0 };
	strcpy(tmp, arr);//注：strtok函数会将tmp中的全部@. 全部替换为\0	


	char* ret = NULL;
	
	ret = strtok(tmp, p);
	printf("%s\n", ret);//tx

	ret = strtok(NULL, p);
	printf("%s\n", ret);//baidu

	ret = strtok(NULL, p);
	printf("%s\n", ret);//wyu
	
	ret = strtok(NULL, p);
	printf("%s\n", ret);//zjtd
	return 0;
}

int main()
{
	char arr[] = "tx@baidu.wyu zjtd";
	char arr1[] = "@. ";
	char* p = arr1;
	char tmp[30] = { 0 };
	strcpy(tmp, arr);//注:视同strtok函数会将tmp中的全部@. 全部替换为\0		

	char* ret = NULL;

	//我们一般这样写情况多，上面那一种太费劲了
 	// ret=strtok(NULL, p)当
	for (ret = strtok(tmp, p); ret != NULL; ret=strtok(NULL, p))
	{
		printf("%s\n", ret);
	}
	//输出：tx
	//      baidu
	//      wyu
	//      zitd
	return 0;
}

---

🐇5.错误信息报告

🏳‍🌈5.1 strerror获取指向错误消息字符串的指针

实际上错误可能有含多种而strerror函数就是翻译这些错误并存为字符串的函数。

#include<stdio.h>
#include <errno.h>

int main()
{
  FILE* pf = fopen("test.txt", "r");//打开文件test.txt,用“r”只读的方法打开
  if (pf == NULL)
  {
  	printf("%s\n", strerror(errno));//errno是全局错误码，需要引头文件#include <errno.h>
  											     //假设当前文件夹下没有这个文件
  											    //输出：No such file or directory  翻译：文件或目录不存在

  	return 1;
  }
  //下面如果不会可以不管
  //读文件后关闭文件
  fclose(pf);
  pf = NULL;

  return 0;
}

---

🏳‍🌈5.2 perror打印错误信息的函数

#include <stdio.h>
int main()
{
  //打开文件失败的时候，会返回NULL
  FILE* pf = fopen("test.txt", "r");
  //0   "no error"
  if (pf == NULL)
  {
  	perror("fopen");//打印出 fopen: No such file or directory
  	return 1;
  }
  //读文件
  // 
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

那么strerro和perror的区别是什么呢？

首先strerro只是把错误码转化为错误信息，没有打印
perror把错误码转化为错误信息的同时，还打印错误信息（包含了自定义的信息）

---

🐇6.字符操作

字符分类函数：

函数	如果他的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’
isdigit	十进制数字 0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母af，大写字母AF
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a ~ z或A ~ Z
isalnum	字母或者数字，a~ z,A~ Z,0~ 9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

举一个小例子:

#include <stdio.h>
#include <ctype.h>
int main()
{
	char ch = 'a';
	//isdigit  如果是数字字符返回非0的值，如果不是数字字符，返回0
	// 
	int ret = isdigit(ch);//isdigit  如果是数字字符返回非0的值，如果不是，返回0
	int ret1 = islower(ch);//islower 如果是小写字母返回非0的值，如果不是，返回0
	printf("%d\n", ret);//0
	printf("%d\n", ret1);//2

	return 0;
}

 
字符转换函数：

函数	作用
int tolower ( int c );	将大写字母转换为小写字母
int toupper ( int c );	将小写字母转换为大写字母

举一个小例子:

#include <stdio.h>
#include <ctype.h>
int main()
{
	char arr[20] = { 0 };
	scanf("%s", arr);//输入：ABcDef
	int i = 0;
	while (arr[i] != '\0')
	{
		if (isupper(arr[i]))//判断是否为是大写字母
		{
			arr[i] = tolower(arr[i]);//是大写字母转化为小写
		}
		printf("%c ", arr[i]);//输出： a b c d e f
		i++;
	}

	return 0;
}

---

🐇7.内存操作函数

🏳‍🌈7.1 memcpy类型拷贝函数

存在的意义：

int main()
{
   //如果说让你把arr1中的1,2,3,4,拷贝到arr2中，你怎么办
   //你可能会想到strcpy
   //但是 char* strcpy(char* dest, const char* src)
   //传参和返回的都是字符指针啊，类型不合适啊
   int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
   int arr2[20] = { 0 };
   //第二个问题syrcpy在拷贝的时候遇到\0是要停止的
   //如果是小端储存的话 01 00 00 00 02 00 00 00 ...
   //当你拷贝01 后 后面就变成\0了，后面的2,3,4就不会拷贝了
   return 0;
}

所以我们迫切的需要一个针对与内存块拷贝的函数：只关心内存块不看里面放的是什么东西

#include<stdio.h>
#include<string.h>
 int main()
{
	
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
    memcpy(arr2,arr1,4);
	return 0;
}

下图我们可以看见arr2中的数据确实改变了

那么我们可以自己写一个memcpy函数么？

//内存操作函数
//memcpy - 内存拷贝
//
#include <assert.h>
#include<stdio.h>
#include<string.h>
void* my_memcpy(void* dest, const void* src, size_t num)//这里为什么是size_t 这样就算是负数也没有关系
{
	void* ret = dest;//存目标函数位置
	assert(dest && src);//断言

	while (num--)//4 3 2 1
	{   //为什么不能强转为（int*）
		//因为转（int*）后每次移动都移动4个字节
		//而假如我们要移动1个字节的时候就不适用了
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
		
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 16);
 	return 0;

}
运行结果同上

那你有没有想过下面这种情况呢过？

将1234移动到3456的位置可以么？
#include<stdio.h>
#include<string.h>
int main()
{
     
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memcpy(arr1+2, arr1, 16);//arr1中数据为： 1 2 1 2 1 2 7 8 9 10
	return 0;
}
//拓展：memcpy(arr1+2, arr1, 16);的时候数据能够完美被执行可以拷贝重叠的内存
//那么这是为什么呢？ 只是因为我用的vs编译器，但是不一定所有编译器都能通过所以 
//memcpy - 只要实现了不重叠拷贝就可以了,而VS中的实现既可以拷贝不重叠，也可以拷贝重叠内存

下图为原因：

由此见得
memcpy函数应该拷贝不重叠的内存
而我们接下来要介绍的和他相反memmove函数可以处理内存重叠的情况

🏳‍🌈7.2 memmove移动内存块

对于上述情况
#include<stdio.h>
#include<string.h>
int main()
{
     
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1+2, arr1, 16);//arr1中数据为: 1 2 1 2 3 4 7 8 9 10
	return 0;
}

那么我们能模拟实现memmove函数么？
思路图：

void * my_memmove(void* dest, const void*src, size_t num)
{
	void* ret = dest;
	assert(dest && src);

	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;
}

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	             
	my_memmove(arr1+2, arr1, 16);//arr1中数据为: 1 2 1 2 3 4 7 8 9 10

	return 0;
}

---

🏳‍🌈7.3 memset内存设置函数

例子：

int main()
{
  //40
  int arr[10] = { 0 };//20
  memset(arr, 1, 20);//以字节为单位设置内存的 
  //将arr中前20个字节全部变成1
  //01 01 01 01
  return 0;
}

🏳‍🌈7.4 memcmp内存比较函数

例子：

//memcmp - 内存比较
//
int main()
{
   float arr1[] = { 1.0, 2.0,3.0,4.0 };
   float arr2[] = { 1.0, 3.0 };
   int ret = memcmp(arr1, arr2, 8);//-1
   int ret = memcmp(arr1, arr2, 4);//0
   //当相同返回0 大于返回正数 小于返回负数 
   printf("%d\n", ret);

   return 0;
}

---