C语言:字符函数和内存函数

最新推荐文章于 2024-06-27 19:12:25 发布
最新推荐文章于 2024-06-27 19:12:25 发布
阅读量161 收藏 1
点赞数
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljs__123/article/details/113519791
版权

个人博客网址：https://ljsblog.com

字符函数和内存函数（八）

  • 求字符串长度
    • strlen
  • 长度不受限制的字符串函数
    • strcpy
    • strcat
    • strcmp
  • 字符串查找
    • strstr
    • strtok
  • 字符操作
  • 内存操作函数
    • memcpy
    • memmove
    • memset
    • memcmp

字符函数

求字符串长度的字符串函数

strlen

格式：
size_t strlen(const char*str)
其中size_t是无符号整型
从字符串的开头位置依次向后计数，遇见\0结束，最终计算的字符串长度不包括\0。
例：

#include <stdio.h>
#include <string.h>
int main()
{
    int len=strlen("myblog");
    printf("%d\n",len);//6
    return 0;
}

注：strlen函数的返回类型是无符号整型（unsigned int）
例：

#include <stdio.h>
#include <string.h>
int main()
{
    if(strlen("my")-strlen("myblog")>0)
    //两个无符号数相减依然是无符号数
    {
        printf("大于零\n");
    }
    else
    {
        printf("小于等于零\n");
    }
    return 0;
}
//大于零
模拟实现
#include <stdio.h>
unsigned int my_strlen(const char* str)
{
	int c=0;
	while(*str!='\0')
	{
		str++;
		c++;
	}
	return c;
}
int main()
{
	int len=0;
	len=my_strlen("ljsblog");//7
	printf("%d\n",len);
}

长度不受限的字符串函数

strcpy

对字符串进行复制
格式
char* strcpy(char* strDestination, const char* strSource);
注：

  • 源字符串必须以’\0’结束
  • 目标空间必须足够大
  • 目标空间可以修改

例：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[]="abcdef";
    //a1: 'a' 'b' 'c' 'd' 'e' 'f' '\0
    char a2[]="my";
    //a2: 'm' 'y' '\0'
    strcpy(a1,a2);
    //a1变为'm' 'y' '\0' 'd' 'e' 'f' '\0'
    printf("%s\n",a1);//my
    return 0;
}
模拟实现
#include <stdio.h>
char* my_strcpy(char *dest,const char *src)
{
	char* cp=dest;
	while( *dest++ = *src++ )
	{
		;
	}
	return cp;

}
int main()
{
	char arr1[]="ljsblog";
	char arr2[]="mybl";
	my_strcpy(arr1,arr2);
	printf("%s\n",arr1);
	return 0;
}
strcat

将两个字符串连接起来，目的字符串末尾的\0会被覆盖，源字符串末尾的\0会一起被复制过去，最终的字符串只有一个\0。
格式:
char* strcat(char* strDestination, const char* strSource);
注：

  • 目的空间必须足够大
  • 源字符串必须以’\0’结束
  • 目标空间可以修改

例：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[10]="my";
    //a1: 'm' 'y' '\0' '\0' '\0' '\0' '\0' '\0' '\0' '\0'
    char a2[]="blog";
    //a2: 'b' 'l' 'o' 'g' '\0'
    strcat(a1,a2);
    //a1: 'm' 'y' 'b' 'l' 'o' 'g' '\0' '\0' '\0' '\0'
    printf("%s\n",a1);//myblog
    return 0;
}
模拟实现
#include <stdio.h>
char* my_strcat(char *dest,const char *src)
{
	char* cp=dest;
	while(*dest !=0 )
	{
		dest++;
	}
	while( *dest++ = *src++ )
	{
		;
	}
	return cp;
}
int main()
{
	char arr1[256]="ljs";
	char arr2[]="blog";
	my_strcat(arr1,arr2);
	printf("%s\n",arr1);//ljsblog
	return 0;
}
strcmp

对两个字符串进行比较，据ASCII编码依次比较str1和str2的每一个字符，直到出现不等的字符，或者遇到\0。
格式:
int strcmp(const char* stri1，const char* str2);
返回值：

  • 返回值<0，表示str1小于str2。
  • 返回值>0，表示str2小于str1。
  • 返回值=0，表示str1等于str2。

例：

#include <stdio.h>
#include <string.h>
int main()
{
    char* a1="abcd";
    char* a2="bbcd";
    int ret=strcmp(a1,a2);
    printf("%d\n",ret);
    //在vs编译器下返回值为-1，其他编译器结果可能有所不同
    return 0;
}
模拟实现
#include <stdio.h>
int my_strcmp(const char *str1,const char *str2)
{
	while(*str1 == *str2)
	{
		if(*str1 == 0)
		{
			return 0;
		}
		str1++;
		str2++;
	}
	return (*str1 - *str2);
}
int main()
{
	char arr1[]="ljsblog";
	char arr2[]="ljmblog";
	int ret=0;
	ret=my_strcmp(arr1,arr2);
	printf("%d\n",ret);//6
	return 0;
}

长度受限的字符串函数

strncpy

把源字符串复制到目的字符串，最多复制n个字符。
当源字符串的长度小于n时，复制完字符串后，在目标的后边追加0，直到n个。
格式:
char *strncpy(char *dest, const char *src, size_t n)
例：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[]="abblog";
    char a2[]="my";
    strncpy(a1,a2,2);
    printf("%s\n",a1);//myblog
    return 0;
}
strncat

把源字符串所指向的字符串的前n个字符追加到目标字符串的结尾并自动补0。
注：若次数n大于源字符串长度，将源字符串追加到目标字符串并且补0后，剩下的次数忽略不计。
例如:
char *strncat(char *dest, const char *src, size_t n)
例：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[10]="my";
    char a2[]="blog";
    strncat(a1,a2,4);
    printf("%s\n",a1);//myblog
    return 0;
}
strncmp

把str1和str2进行比较，比较到出现不一样的字符或者一个字符串结束或者n个字符全部比较完。
格式：
int strncmp(const char *str1, const char *str2, size_t n)

#include <stdio.h>
#include <string.h>
int main()
{
    char* a1="abcdsd";
    char* a2="abcdef";
    int ret=strncmp(a1,a2,4);
    printf("%d\n",ret);//0
    return 0;
}

字符串查找

strstr

返回在字符串str1中查找第一次出现字符串str2的位置。
如果str1中不存在str2，则返回NULL。
格式：
char *strstr(const char *str1, const char *str2)
例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[]="ljsblogblog";
	char arr2[]="bl";
	char *ret=strstr(arr1,arr2);
	if(ret == NULL)
	{
		printf("不存在\n");
	}
	else
	{
		printf("%s\n",ret);//blogblog
	}
    return 0;
}
模拟实现
#include <stdio.h>
char* my_strstr(char* str1,char* str2)
{
    char *s1=str1;
    char *s2=str2;
    char *s=str1;
    if(*str2==0)
    {
        return s1;
    }
    while(*s)
    {
        s1=s;
        s2=str2;
        while((*s1 != 0) && (*s2 != 0) && (*s1==*s2))
        {
            s1++;
            s2++;
        }
        if(*s2==0)
        {
            return s;            
        }
        s++;
    }
    return NULL;

}
int main()
{
    char arr1[]="ljsblogblog";
	char arr2[]="bl";
	char *ret=my_strstr(arr1,arr2);
	if(ret == NULL)
	{
		printf("不存在\n");
	}
	else
	{
		printf("%s\n",ret);//blogblog
	}
    return 0;    
}
strtok

分解字符串为一组字符串,str为要分解的字符串，delim为分隔符字符（如果传入字符串，则传入的字符串中每个字符均为分割符）。
首次调用时，str指向要分解的字符串，之后的调用要把str设成NULL。
如果字符串中不存在标记或者不存在更多的标记，则返回NULL指针。
格式：
char *strtok(char *str, const char *delim)
例：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[]="ab.cd#ef.gh";
    char* a2=".#";
	char* ret=NULL;
    for(ret=strtok(a1,a2);ret!=NULL;ret=strtok(NULL,a2))
    {
        printf("%s\n",ret);
    }
    return 0;
}
/*
ab
cd
ef
gh
*/

错误信息报告

strerror

返回错误码所对应的错误信息
格式：
char *strerror(int errnum)
例：

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
    FILE* pf=fopen("test.txt","r");
    if(pf==NULL)
    {
        printf("%s\n",strerror(errno));
        //errno用来存储错误代码，当库函数在执行过程中发生错误时，就会将错误码写入到errno中
    }
    else
    {
        printf("打开成功\n");
    }
    return 0;
}
/*
No such file or directory
*/

内存函数

memcpy

从str2复制n个字节到str1。
格式：
void *memcpy(void *str1, const void *str2, size_t n)
例：

#include <stdio.h>
#include <string.h>
int main()
{
    int a1[]={1,2,3,4,5};
    int a2[5]={0};
    int i=0;
    memcpy(a2,a1,sizeof(a1));
    for(i=0;i<5;i++)
    {
        printf("a2[%d]=%d\n",i,a2[i]);
    }
    return 0;
}
/*
a2[0]=1
a2[1]=2
a2[2]=3
a2[3]=4
a2[4]=5
*/

memmove

从str2复制n个字符到str1，但与memcpy不同的是，memmove可以处理重叠内存的复制。
格式：
void *memmove(void *str1, const void *str2, size_t n)
例：

#include <stdio.h>
#include <string.h>
int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int i=0;
    memmove(arr+2,arr,16);
    for(i=0;i<10;i++)
    {
        printf("arr[%d]=%d\n",i,arr[i]);
    }
    return 0;
}
/*
arr[0]=1
arr[1]=2
arr[2]=1
arr[3]=2
arr[4]=3
arr[5]=4
arr[6]=7
arr[7]=8
arr[8]=9
arr[9]=10
*/

memcmp

把str1和str2的前n个字节进行比较。
格式：
int memcmp(const void *str1, const void *str2, size_t n)
返回值：

  • 返回值<0，表示str1小于str2。
  • 返回值>0，表示str1大于str2。
  • 返回值=0，表示str1等于str2。
#include <stdio.h>
#include <string.h>
int main()
{
    int a1[]={1,2,3,4,5};
    int a2[]={1,2,4,4,5};
    int ret=memcmp(a1,a2,sizeof(a1));
    printf("%d\n",ret);//-1
    return 0;
}

memset

将字符c复制到参数str所指向的空间的前n个字节。
格式：
void *memset(void *str, int c, size_t n)
例：

#include <stdio.h>
#include <string.h>
int main()
{
	char a[8]="myblog";
	memset(a,'c',7);
	printf("%s\n",a);
    //ccccccc
    return 0;
}
ljs__123
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言-字符函数和字符串函数
Yzffff的博客
09-09 458
重点介绍处理字符和字符串的库函数的使用和注意事项：求字符串长度：strlen长度不受限制的字符串函数：strcpy、strcat、strcmp长度受限制的字符串函数介绍：strncpy、strncat、strncmp字符串查找：strstr字符串截断：strtok错误信息报告：strerror字符操作内存操作函数：memcpy、memmove、memset、memcmp。
C语言中的字符串函数和字符函数
l_shadow_m的博客
06-12 1460
C语言中的字符串函数和字符函数
【c语言】memcpy使用防止地址越界
zou_albert的博客
05-30 2638
memcpy函数原型：void * memcpy (void * dest, const void * src, size_t n); 功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中 请看下面的一个例子： void check_data(int *buffer)//buffer 的长度是128 { int temp[200]; memcpy(temp,buffer,sizeof(temp)); } 此函数出现的问题，buffer的大小是128，但是te
memcpy与memmove
Payshent的博客
03-23 851
我们知道字符串操作函数的操作对象就是字符串，但想要将一段内存的数据复制到另一段内存中去的时候我们就得用到另外一种拷贝函数----内存拷贝函数。         内存拷贝函数的作用就是：将源内存地址的N个字节拷贝到目标内存地址中去。 一、memcpy函数的实现        memcpy的函数原型：void*  memcpy(void* dst, const void* src, size_t
memcpy的使用问题
Steven Li
12-17 755
    具体说一下使用环境吧，就是我通过网络从设备端获得一段数据buf以及其长度，然后我将这段内存拷贝到我自己的结构体中，这都没有问题，关键在于我指定的拷贝长度值是从网络获得的数据buf的长度。   有什么问题呢，由于通信双方扩展了各自的结构体，也就是buf的长度比原来增大了。由于我之前的这种拷贝方式，使用老的软件访问新的设备时，数据buf的长度就比结构体的长度要大，memcpy就会将一段结构体之后的内存指定了数值，这将带来不可测的问题。   因此在网络通信时，在使用memcpy时长度的指定最好使用结构体的
数组-memcpy-越界
why_up的专栏
10-02 2789
#include #include int main(void) { char src[] = "12345"; char dest[] = "1234"; printf("destination before memcpy: %s\n", dest
memcpy函数越界分析
Leonban的博客
01-25 8244
一、memcpy()函数原型   从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中 void *memcpy(void *dst, const void *src, size_t len) { if(NULL == dst || NULL == src){ return NULL; } voi
C语言：指针函数和函数指针
08-10
指针变量可以指向变量地址，数组，字符串，自然也可以指向函数了。已知每个函数在编译的时候，系统会分配给函数一个入口地址，函数名表示这个入口地址，定义指向函数的指针变量称之为函数的指针变量。
C语言字符串操作函数.doc
12-02
C语言字符串操作函数是一组强大且实用的函数，用于处理和操作字符串。这些函数在C语言编程中非常常用，掌握这些函数可以提高编程效率和质量。本章将详细介绍C语言字符串操作函数的使用方法和应用场景。 1. 字符串...
浅谈C语言之字符串处理函数
09-01
1. `puts` 函数： `puts` 用于输出字符串到终端。其一般形式为 `puts(字符串)`。例如，定义一个字符数组 `string` 并初始化，然后调用 `puts(string)` 可将字符串打印到屏幕。请注意，`puts` 在末尾会自动添加一个...
C语言字符串和数字转换函数
04-19
包含了很多C语言字符串和数字转换函数，有详细的代码解释和案例
基于C语言字符串函数的一些使用心得
09-05
本文将深入探讨C语言中的字符串函数，特别是`strcat()`函数的使用心得和注意事项。 `strcat()`函数用于将一个字符串连接到另一个字符串的末尾。其原型如下： ```c char *strcat(char *dest, const char *src); ```...
关于memcpy
王同学LM的专栏
09-22 1097
memcpy是C/C++内存拷贝函数，函数原型void *memcpy(void *dest, const void *src, size_t n);功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。 【memcpy与strcpy比较】 strcpy和memcpy主要有以下3方面的区别。 1、复制的内容不同。strcpy只能复制
memcpy和memmove
zhouguoqionghai的博客
07-31 2801
本文来自点击打开链接 memcpy() 和memmove() 要实现的功能都是将源地址指定字节数的内容拷贝到目的地址，不过但源地址的那块内存和目的地址的同样大小的内存有重叠时，memcpy会发生错误，而memmove仍然能正确的拷贝，当然这也导致了一点儿运行时的开销。 memmove能执行的拷贝的原理如下： （1）当源内存的首地址等于目标内存的首地址时，不进行任何拷贝 （2）当源内
memcpy引发字符串打印长度异常
qq_37277944的博客
05-19 721
#include <stdlib.h> #include <string.h> int main() { char str1[100] = {"192.168.12.123"}; char str2[20]={"192.168.12.1"}; printf("%s\n",str1); memcpy(str1,str2,strlen(str2)); //错误做法 //memcpy(str.
memcpy 内存越界分析
u014630983的博客
11-04 2360
memcpy 内存越界分析。
bug记录-memcpy 2023.03.02
dhhdane的博客
03-02 317
笔记
c语言 memset超过1m_C语言学习笔记---好用的函数memcpy与memset
weixin_39635432的博客
12-23 269
这个主要用于我个人的学习笔记，便于以后查询，顺便分享给大家。想必在用C的时候难免会与数组，指针，内存这几样东西打交道，先以数组为例，例如有一个数组int a[5] = {1, 2, 3, 4, 5}，我们要将数组a里面的数据复制到数组b中，一般刚刚接触C语言的我们会怎么做？我们一般会想到用循环来做吧1 inti;2 int a[5] = {1, 2, 3, 4, 5}, b[5];34 for(i...
C++(week10): C++基础：第一章 C++与C
最新发布
Edward2022的博客
06-27 854
C++基础：C++与C
c语言：函数返回字符串
06-21
在C语言中，函数可以返回字符串，通常使用数组或指向字符数组的指针来实现。有两种主要方法： 1. **静态字符串（char数组）**: - 你可以定义一个char类型的数组作为函数的结果，例如： ```c char* get_string() ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值