字符函数和字符串函数

最新推荐文章于 2022-10-27 21:26:37 发布
最新推荐文章于 2022-10-27 21:26:37 发布
阅读量211 收藏
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45407664/article/details/102594733
版权

strlen

  1. 测量长度： size_t strlen ( const char * str );
    字符串已以’\0’ 作为结束标志；strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数(不包含 ‘\0’ )；参数指向的字符串必须要以 ‘\0’ 结束。注意函数的返回值为size_t，为无符号型
#include<stdio.h>
int main()
{
	const char *str = "abc\0def";
	printf("%d\n", strlen(str));  //3
	return 0;
}
  1. 模拟实现
int Mystrlen(const char * str)  //计数
{
	int count = 0;
	while (*str)
	{	count++;
		str++;
	}
	return count;
}
int Mystrlen(char *s)  //指针-指针的方式
{
	char *p = s;
	while (*p != ‘\0’)
		p++;
	return p - s;
}
int Mystrlen(const char * str)  //递归实现
{
    assert(str);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

strcpy

  1. 拷贝： char * strcpy (char * destination, const char * source);
    源字符串必须以 ‘\0’ 结束；将源字符串中的 ‘\0’ 拷贝到目标空间；目标空间必须足够大，以确保能存放源字符串；目标空间必须可变。
#include<stdio.h>
#include<string.h>
int main()
{
	char str1[] = "abc\0def";
	const char str2[] = "def\0abc";
	strcpy(str1, str2);
	printf("%s\n", str1);  //输出def
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
char *Mystrcpy(char *dest, const char*src)  //函数源字符串必须加const
{
	char *ret = dest;
	assert(dest);
	assert(src);
	while ((*dest++ = *src++));
	return ret;
}
int main()
{
	char str1[]="def";
	char str2[]="abc";
	printf("%s\n", Mystrcpy(str1, str2));  //输出abc
	return 0;
}

strcat

  1. 连接： char * strcat(char * destination, const char * source);
    目标空间必须足够大，能容纳下源字符串；目标空间必须可修改。
#include<stdio.h>
#include<string.h>
int main()
{
	char str1[] = "abc\0def";
	const char str2[] = "def\0abc";
	strcat(str1, str2);  //以'\0'截止
	printf("%s\n", str1);  //输出abcdef
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
char *Mystrcat(char *dest, const char*src)
{
	char *ret = dest;
	assert(dest);
	assert(src);
	while (*dest)
		dest++;
	while ((*dest++ = *src++));
	return ret;
}
int main()
{
	char str1[] = "abcd\0def";
	const char str2[] = "def\0abc";
	Mystrcat(str1, str2);  //以'\0'截止
	printf("%s\n", str1);  //输出abcddef
	return 0;
}

strcmp

  1. 比较大小： int strcmp(const char* str1,const char* str2);
    第一个字符串大于第二个字符串，返回大于0的数字；第一个字符串小于第二个字符串，返回小于0的数字；相等则返回0。
#include<stdio.h>
#include<string.h>
int main()
{
	char str1[] = "abcd";
	char str2[] = "def";
	int ret = strcmp(str1, str2); 
	if (ret > 0)
		printf("第一个大\n");
	else if (ret < 0)
		printf("第二个大\n");
	else
		printf("相等\n");
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
int MyStrcmp(const char*str1, const char*str2)
{
	assert(str1);
	assert(str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0');  //不能放在最后，两个字符串均为'\0'时不再需要比较
		{
			return 0;
		}
		str1++;
		str2++;
	}
	return *str1 - *str2;
}
int main()
{
	char str1[] = "abcd";
	char str2[] = "def";
	int ret = MyStrcmp(str1, str2); 
	if (ret > 0)
		printf("第一个大\n");
	else if (ret < 0)
		printf("第二个大\n");
	else
		printf("相等\n");
	return 0;
}

strncpy

  1. 拷贝(字符)：char* strncpy(char* destination,constchar* source,size_t num);
    拷贝指定个字符从源字符串到目标空间；如果源字符串的长度小于num，则拷贝完源字符之后，在目标的后边追加0，直到指定个；拷贝最后一个字符不追加’\0’
#include<stdio.h>
#include<string.h>
int main()
{
	char str[20] = "asdfasdfsadfasd";
	strncpy(str,"Hello!",5);
	printf("%s\n", str);  //Hellosdfsadfasd
	getchar();
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
char *MyStrncpy(char * str3, const char * str4, int count)
{
    assert(str3);
	assert(str4);
	while (count && (*str3++ = *str4++))
		count--;
	if (count)
		while (--count)
			*str3++ = '\0';
	return (str3);
}
int main()
{
	char str1[20] = "asdfasdfsadfasd";
	MyStrncpy(str1, "Hello!", 5);  //Hellosdfsadfasd
	printf("%s\n", str1);
	return 0;
}

strncat

  1. 连接(字符)：char* strncat(char* destination,const char* source,size_t num);
    将指定个字符从源字符串连接到目标空间；如果源字符串的长度小于num，不追加0；连接最后一个字符追加’\0’
#include<stdio.h>
#include<string.h>
int main()
{
	char str[20] = "asnlgk";
	strncat(str, "Hello!", 5);  //asnlgkHello
	printf("%s\n", str); 
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
char* MyStrncat(char* dest, const char* src, int n)
{
	assert(dest);
	assert(src);
	while (*dest)
		++dest;
	while (n)
	{
		if (*src == '\0') 
			break;
		*dest++ = *src++;
		--n;
	}
	*dest = '\0';  //在结果后面添加'\0'，而不是用'\0'填充目标剩余空间
	return dest;
}
int main()
{
	char str[20] = "asnlgk";
	MyStrncat(str, "Hello!", 5);  //asnlgkHello
	printf("%s\n", str);  
	return 0;
}

strncmp

  1. 比较大小：int strncmp(const char* str1,const char* str2,size_t num);
    第一个字符串大于第二个字符串，返回大于0的数字；第一个字符串小于第二个字符串，返回小于0的数字；相等则返回0；比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
#include<stdio.h>
#include<string.h>
int main()
{
	int ret1 = strncmp("acc", "abcd", 4);
	int ret2 = strncmp("abc", "abcd", 3);
	int ret3 = strncmp("abc", "abcd", 4);
	printf("%d\n", ret1);  //1
	printf("%d\n", ret2);  //0
	printf("%d\n", ret3);  //-1
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
int  MyStrncmp(char* str1, char* str2, int a)
{
    int i = 0;
	assert(str1);
	assert(str2);	
	for (i = 0; i < a; i++)
	{
		if (*(str1 + i) > *(str2 + i))
			return 1;
		else if (*(str1 + i) == *(str2 + i))
			continue;
		else if (*(str1 + i) < *(str2 + i))
			return -1;
	}
	if (i == a)
		return 0;
}
int main()
{
	int ret1 = MyStrncmp("acc", "abcd", 4);
	int ret2 = MyStrncmp("abc", "abcd", 3);
	int ret3 = MyStrncmp("abc", "abcd", 4);
	printf("%d\n", ret1);  //1
	printf("%d\n", ret2);  //0
	printf("%d\n", ret3);  //-1
	return 0;
}

strstr

  1. 在字符串中查找子字符串：char* strstr(const char* ,const char* );
    在第一个字符串中查询含有第二个子字符串的内容
#include<stdio.h>
#include<string.h>
int main()
{
	char*p1 = "abc";
	char*p2 = "thaabcaedef";
	char*ret = strstr(p2, p1);
	printf("%s\n", ret);  //abcaedef
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
char* MyStrstr(const char*str1, const char*str2)
{
	const char *s1 = str1; 
	const char *s2 = str2;
	const char *cp = str1;
	assert(str1);
	assert(str2);
	if (!*str2)  //若查找空字符串，直接返回子字符串
		return str1;
	while (*cp)
	{
		s1 = cp;  //将跳过字符的指针重新赋值，重新查找
		s2 = str2;  //将指针重新指向子字符串
		while (*s1 && *s2 && !(*s1 - *s2))  //当两个字符串均未结束且找到相同字符，继续查找
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')  //当子字符串结束时停止循环
			return cp;
		cp++;  //子字符串与源字符串有部分不完全相同时，跳过此时指向的第一个字符
	}
	return NULL;
}
int main()
{
	char*p1 = "abc";
	char*p2 = "thaabcaedef";
	char*ret = MyStrstr(p2, p1);
	printf("%s\n", ret);  //abcaedef
	return 0;
}

strtok

   char* strtok(char* str,const char* sep);  
          第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。strtok函
   数找到str中的下一个标记，并将其用\0结尾，返回一个指向这个标记的指针。(注：strtok函数会改变被操作的字符
   串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。)strtok函数的第一个参数不为NULL，
   函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。strtok函数的第一个参数为NULL，函数将在同
   一个字符串中被保存的位置开始，查找下一个标记。

#include<stdio.h>
#include<string.h>
int main()
{
	char *str = "Seincfe@yeah.net";
	char arr[20] = { 0 };
	char *ret = NULL;
	char *p = "@.";
	strcpy(arr, str); 
	for (ret = strtok(arr, p); ret != NULL; ret = strtok(NULL, p))
	    //仅在第一次传参的时候传入arr的地址吗，如果使用while将会使每次传入的参数都是arr的地址
	    //strotk函数中有延长局部变量生存时间，自动记录节点
		printf("%s\n", ret);
	/*char arr[] = "Seincfe@yeah. net";
	printf("%s\n", strtok(arr, "@."));
	printf("%s\n", strtok(NULL, "@."));
	printf("%s\n", strtok(NULL, "@."));*/  //过于麻烦所以不考虑这种方法
	return 0;
}

strerro

   char* strerror(int errnum);  返回错误码，所对应的错误信息；检测错误。

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
	FILE* pF = fopen("unexist.ent", "r");
	if (pF == NULL)
		printf("Erroropeningfileunexist.ent:%s\n", strerror(errno));  //errno:Lasterrornumber 
	fclose(pF);
	return 0;
}

memcpy

  1. 内存拷贝：void* memcpy(void* destination,constvoid* source,size_t num);
    遇到’\0’的时候并不会停下来；函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。(库函数中的memcpy可以实现memmove的功能，我们这里不实现memmove)
#include<stdio.h>
#include<string.h>
int main()
{
	int str1[] = { 1,2,3,4,5,6 };
	int str2[20] = { 0 };
	memcpy(str2, str1, 24);
	printf("%d\n", str2[0]);
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
void* MyMemcpy(void* dest, const void* src, int count)
{
	void *ret = dest;
	assert(dest);
	assert(src);
	while (count--)
	{
		*(char*)dest = *(char*)src;  //按字节拷贝
		((char*)dest)++;
		((char*)src)++;
	}
	return ret;
}
int main()
{
	int str1[] = { 1,2,3,4,5,6 };
	int str2[20] = { 0 };
	MyMemcpy(str2, str1, 24);
	printf("%d\n", str2[0]);
	return 0;
}

memmove

  1. 内存拷贝：void* memmove(void* destination,const void* source,size_t num);
    和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的；如果源空间和目标空间出现重叠，就得使用memmove函数处理。
#include<stdio.h>
#include<string.h>
int main()
{
	int i = 0;
	int str1[] = { 1,2,3,4,5,6 };
	int str2[20] = { 20,19,18,17,16,15,14,13,12,11,10 };
	memmove(str2 + 5, str1, 24);
	for (i = 0; i < 20; i++)
		printf("%-3d", str2[i]);
	return 0;
}
  1. 模拟实现
#include<stdio.h>
#include<assert.h>
#include<string.h>
void* MyMemmove(void* dest, const void*src, int count)
{
	void *ret = dest;
	assert(src && dest);
	if (dest < src)  //从后往前拷贝
	{
		while (count--)
		{
			*(char*)dest = *(char*)src;  //按字节拷贝
			((char*)dest)++;
			((char*)src)++;
		}
	}
	else  //从前往后拷贝
		while (count--)
			*((char *)dest + count) = *((char*)src + count);
	return ret;
}
int main()
{
	int i = 0;
	int str1[] = { 1,2,3,4,5,6 };
	int str2[20] = { 20,19,18,17,16,15,14,13,12,11,10 };
	MyMemmove(str2 + 5, str1, 24);
	for (i = 0; i < 20; i++)
		printf("%-3d", str2[i]);
	return 0;
}

memcmp

  内存比较：int memcmp(const void* ptr1,const void* ptr2,size_t num);
  第一个字符串大于第二个字符串，返回大于0的数字；第一个字符串小于第二个字符串，返回小于0的数字，相等则返回0

#include<stdio.h>
#include<string.h>
int main()
{
	char str1[] = "DWgAOtP12df0";
	char str2[] = "DWGAOTP12DF0";
	int n = memcmp(str1, str2, sizeof(str1));  //按字节比大小，可选取字节长度
	printf("%d\n", n);
	return 0;
}

memset

  初始化函数：void *memset(void *s, int ch, size_t n);
  将已开辟内存空间s的首n个字节的值设为值ch。

#include <stdio.h>
#include <string.h>
int main() {
	char s[] = "Golden Global View";
	memset(s, 'G', 6);
	printf("%s", s);
	return 0;
}
  1. memset()函数常用于内存空间初始化，将某一块内存中的内容全部设置为指定的值，通常为新申请的内存做初始化工作；
  2. memset()的深刻内涵：用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化
    例如:memset(a,’\0’,sizeof(a))；
  3. memset可以方便的清空一个结构类型的变量或数组；它是对较大的结构体或数组进行清零操作的一种最快方法。

附：
在这里插入图片描述

Seincfe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
memcpy, memcpy()函数，字符串拷贝
08-13
memcpy: 头文件，函数原型，函数功能，函数返回值，说明
C语言进阶-字符串函数与内存函数
~
09-21 1822
前言 本章主要讲解： 字符和字符串的库函数的使用和注意事项 求字符串长度 strlen 长度不受限制的字符串函数 strcpy strcat strcmp 长度受限制的字符串函数 strncpy strncat strncmp 字符串查找 strstr strtok 错误信息报告 strerror 字符操作 内存操作函数 memcpy memmove memset memcmp 写在前面的话： C语言本身是没有字符串类型的 字符串通常放在常量字符串（不做修改）中或者字符数
字符串函数的模拟实现
qq_41181857的博客
01-09 187
字符串函数的模拟实现 strcpy的模拟实现 我们知道strcpy的功能是将源指向的C字符串复制到目标指向的数组中，包括终止数组 空字符(并在该点停止）。 需要注意的是： 源字符串必须以 ‘\0’ 结束 会将源字符串中的 ‘\0’ 拷贝到目标空间。 目标空间必须足够大，以确保能存放源字符串。 目标空间必须可变 仿照库函数strcpy的标准来实现同样功能的一个函数my_strcpy，源字符串中...
C语言：字符串申请内存
xikangsoon的博客
01-13 1156
下面程序段的输出结果是 1 2 3 char *p1 = ”123”, *p2 = ”ABC”, str[50] = “xyz”; strcpy(str +2, strcat(p1, p2)); printf(“%s\n”, str); 正确答案: D 你的答案: C(错误) xyz123ABC z123A...
LabVIEW的字符串操作函数
01-19
LabVIEW提供了用于对字符串进行操作的内置Ⅵ和函数，可对字符串进行格式化、解析字符串等编辑操作。字符串操作函数位于程序框图函数选板的“编程→字符串”子选板中，如图1所示。 　字符串操作函数包括计算字符串...
javascript字符串函数汇总
10-23
本文给大家汇总介绍了常用的javascript字符串函数，分为自带函数和扩展函数2部分，希望大家能够喜欢。
C语言字符串操作函数.doc
12-02
C语言字符串操作函数是一组强大且实用的函数，用于处理和操作字符串。这些函数在C语言编程中非常常用，掌握这些函数可以提高编程效率和质量。本章将详细介绍C语言字符串操作函数的使用方法和应用场景。 1. 字符串...
vbs字符串分割函数
09-05
vbs字符串分割函数，将字符中如入指定分割字符，需要的朋友可以参考下。
sql字符串函数大全和使用方法示例
09-10
本文主要讲解SQL SERVER的字符串函数使用方法，包括LEN、LOWER、UPPER (string)、LTRIM、RTRIM等函数
字符串必须申请内存空间
weixin_30856725的博客
08-29 703
#include "stdafx.h" #include "stdlib.h" int _tmain(int argc, _TCHAR* argv[]) { //输入字符串 char *str; scanf("%s",str); printf("输出输入的字符串*str=%s\n",&str); system...
二维字符串数组动态申请内存及排序
rgdggf的博客
06-06 394
输入描述: 输入有两行，第一行n 第二行是n个字符串，字符串之间用空格隔开 输出描述: 输出一行排序后的字符串，空格隔开，无结尾空格 输入例子1: 5 c d a bb e 输出例子1: a bb c d e
字符串（memcpy）
weixin_33755649的博客
12-31 124
【1】内存拷贝函数应该如何实现？ 函数原型：void * memcpy(void *memTo,memFrom,size_t size) 返回值类型：void * 参数1：void *memTo; 需要拷入的目的指针 参数2：void *memFrom; 需要拷贝的起始指针 参数3：size_t size; size_t代表unsigned int 表示拷贝的字节数 （1）具体实现版本...
字符串函数-memcpy
qq_41759269的博客
06-09 631
void *memcpy(void *string1, const void *string2, size_t n)参数string1 -- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。string2 -- 指向要复制的数据源，类型强制转换为 void* 指针。n -- 要被复制的字节数。返回值该函数返回一个指向目标存储区 str1 的指针。实例下面的实例演示了 memcpy...
杂杂的基础知识【Sizeof与Strlen&strcpy和memcpy&字符串常量和字符常量】
nanaMasuda的博客
07-16 1144
呃呃呃好多基础知识忘的都差不多了，再瞅瞅，顺便记录一下今天都学了什么 对对，今天上午还看了下接口测试那面，哎哟~要继续努力呢 Sizeof与Strlen的区别与联系 一、sizeof     sizeof(...)是运算符，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。     它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。     由于
C语言字符串库函数 #include ＜string.h＞
热门推荐
leonoe121的博客
04-17 1万+
c语言字符串库函数#include<string.h> 在头文件<string.h>中定义了两组字符串函数。第一组函数的名字以str开头；第二组函数的名字以mem开头。只有函数memmove对重叠对象间的拷贝进行了定义，而其他函数都未定义。比较类函数将其变量视为unsigned char类型的数组。 1 strcpy #include <string.h> char* strcpy(char *str1, const char *str2); 把字符串str2(包括
C语言-申请内存
qq_70851535的博客
10-27 2939
C语言内存申请过程
C++中内存申请
hu_hao的博客
05-15 4468
C++中内存申请 内存分配三个区域 目前看到资料说，C++内存分配分为三种方式，在静态存储区分配，在栈上分配，在堆上分配，这三者的不同首先在存储变量的生命周期不同，静态存储区存放静态变量和全局变量，在程序运行过程中一直存在，而栈上的属于编译器自动申请的，分为静态分配和动态分配，属于系统自动分配和回收的，生命周期不受控制。而堆上的是动态分配，属于程序员可控制生命周期的变量，需要手动释放，不然会造成内存泄漏。 那么如果声明了一个vector，怎么知道它是如何分配的内存呢？按上述说法，它分配的地点其实不确定，如果
delphi 字符串函数
最新发布
05-02
下面是一些常用的Delphi字符串函数的介绍： 1. Length函数：用于获取字符串的长度，返回字符串中字符的个数。 2. Pos函数：用于查找子字符串在字符串中的位置，返回子字符串在字符串中的起始位置。 3. Copy函数：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值