AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C语言-字符串+内存函数介绍与模拟实现（10）

2023-07-16 57
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C语言-字符串+内存函数介绍与模拟实现（10）

思维导图：


字符串与内存函数

求字符串长度

strlen

size_t strlen ( const char * str )


其实我们对于strlen函数并不陌生，


他能通过字符串首地址求出字符串长度。


既然如此，我们来挑战一下，用三种不同的方法实现strlen函数：


第一种：循环


#include 
#include 
#include 
//size_t strlen(const char * str)
size_t my_strlen(const char* str)
{
  assert(str);
  int count = 0;//计数
  while (*str)//遍历数组
  {
  str++;
  count++;
  }
  return count;
}
int main()
{
  char arr[] = "abcdef";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}

输出：


输出：6

第二种：递归


#include 
#include 
#include 
//size_t strlen(const char * str)
size_t my_strlen(const char* str)
{
  assert(str);
  if (*str != '\0')
  return 1 + my_strlen(str + 1);
  else
  return 0;
}
int main()
{
  char arr[] = "abcdef";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}


输出：


输出：6

第三种：指针减指针


#include 
#include 
#include 
//size_t strlen(const char * str)
size_t my_strlen(const char* str)
{
  assert(str);
  const char* start = str;
  while (*str)
  {
  str++;
  }
  return str - start;//指针之间隔着一整个数组
  //数组在内存中是连续存储的，start与str之间相差6个字节
}
int main()
{
  char arr[] = "abcdef";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}

输出：


输出：6

怎么样，学会了吗？


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

strcpy

char* strcpy(char * destination, const char * source )


strcpy是字符串拷贝函数，可以拷贝字符串


例：


#include 
#include 
int main()
{
  char arr1[] = "welcome to my blog";
  char arr2[30] = { 0 };
  strcpy(arr2, arr1);
  printf("%s\n", arr2);
  return 0;
}

输出：


输出：welcome to my blog

注：


1.源字符串必须以 '\0' 结束，


2.该函数会将源字符串中的 '\0' 拷贝到目标空间，


3.目标空间必须足够大，以确保能存放源字符串。


接下来我们可以模拟实现一下strcpy函数：


#include 
#include 
#include 
//char* strcpy(char* destination, const char* source)
char* my_strcpy(char* dest, const char* src)
{
  assert(dest && src);
  char* ret = dest;
  while (*dest++ = *src++)
  {
  ;
  }
  return ret;//返回的是目标字符串的首字符地址
}
int main()
{
  char arr1[] = "welcome to my blog";
  char arr2[30] = { 0 };
  my_strcpy(arr2, arr1);
  printf("%s\n", arr2);
  return 0;
}


输出：


输出：welcome to my blog

strcat

char * strcat ( char * destination, const char * source )


strcat是个字符串追加函数，可以追加字符串。


例：


#include 
#include 
int main()
{
  char arr1[30] = "welcome to";
  char arr2[] = " my ";
  strcat(arr1, arr2);
  strcat(arr1, "blog");
  printf("%s\n", arr1);
  return 0;
}

输出：


输出：welcome to my blog

注：


1.源字符串必须以 '\0' 结束，


2.目标空间必须有足够的大，能容纳下源字符串的内容，


3.目标空间必须可修改。


接下来我们可以模拟实现一下strcat函数：


#include 
#include 
#include 
//char* strcat(char* destination, const char* source)
char* my_strcat(char* dest, const char* src)
{
  assert(dest && src);
  const char* ret = dest;
  while (*dest)//指针到'\0'停下
  {
  dest++;
  }
  while (*dest++ = *src++)
  {
  ;
  }
  return ret;
}
int main()
{
  char arr1[30] = "welcome to";
  char arr2[] = " my ";
  my_strcat(arr1, arr2);
  my_strcat(arr1, "blog");
  printf("%s\n", arr1);
  return 0;
}


输出：


输出：welcome to my blog

strcmp

int strcmp ( const char * str1, const char * str2 )


strcmp是字符串比较函数，可以用来进行字符串之间的比较。


例：


#include 
#include 
int main()
{
  char arr1[] = "abcd";
  char arr2[] = "abcz";
  int ret = strcmp(arr1, arr2);//按照字典序来排
  if (ret > 0)
  printf("arr1>arr2\n");
  else if (ret == 0)
  printf("arr1=arr2\n");
  else
  printf("arr1
  return 0;
}

输出：

输出：arr1

注：


1.第一个字符串大于第二个字符串，则返回大于0的数字，


2.第一个字符串等于第二个字符串，则返回0，


3.第一个字符串小于第二个字符串，则返回小于0的数字。


接下来我们可以模拟实现一下strcmp函数：



输出：

#include 
#include 
#include 
int my_strcmp(const char* src, const char* dest)
{
    int ret = 0;
    assert(src &&dest);
  while (!(ret = *(unsigned char*)src++ - *(unsigned char*)dest++) && *dest && *src)
  {     //!ret如果ret!=0则跳出循环，ret=0则继续,*dest=0和*src=0也跳出循环
  ;
  }
  if (ret < 0)
  ret = -1;
  else if (ret > 0)
        ret = 1;
    return ret;
}
int main()
{
  char arr1[] = "abcd";
  char arr2[] = "abcz";
  int ret = my_strcmp(arr1, arr2);//按照字典序来排
  if (ret > 0)
  printf("arr1>arr2\n");
  else if (ret == 0)
  printf("arr1=arr2\n");
  else
  printf("arr1
  return 0;
}
输出：arr1

以上就是长度不受限制的字符串函数。


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

strncpy

char * strncpy ( char * destination, const char * source, size_t num )


strncpy可以控制拷贝过去的字符串的字符个数。


#include 
#include 
int main()
{
  char arr1[20] = "xxxxxxxxxxxxx";
  char arr2[] = "hello";
  strncpy(arr1, arr2, 3);
  printf("%s\n", arr1);
  strncpy(arr1, arr2, 6);//\0也会被拷贝过去
  printf("%s\n", arr1);
  return 0;
}

输出：


输出：
helxxxxxxxxxx
hello

他的实现方式与strcpy自然也是大同小异。


例：


#include 
#include 
#include 
//char* strncpy(char* destination, const char* source, size_t num)
char* my_strncpy(char* dest, const char* src, size_t num)
{
  assert(dest && src);
  char* ret = dest;
  for (int i = 0; i < num; i++)
  {
  *dest++ = *src++;
  }
  return ret;//返回的是目标字符串的首字符地址
}
int main()
{
  char arr1[20] = "xxxxxxxxxxxxx";
  char arr2[] = "hello";
  my_strncpy(arr1, arr2, 3);
  printf("%s\n", arr1);
  my_strncpy(arr1, arr2, 6);//\0也会被拷贝过去
  printf("%s\n", arr1);
  return 0;
}

输出：


输出：
helxxxxxxxxxx
hello

strncat

char * strncat ( char * destination, const char * source, size_t num )


strncat可以控制追加字符的数量。


例：

#include 
#include 
int main()
{
  char arr1[30] = "welcome to";
  char arr2[] = " my ";
  strncat(arr1, arr2, 2);
  strncat(arr1, "blog", 2);
  printf("%s\n", arr1);
  return 0;
}


输出:


输出：welcome to mbl

我们也能将它模拟实现一下：


#include 
#include 
#include 
//char* strncat(char* destination, const char* source, size_t num)
char* my_strncat(char* dest, const char* src, size_t num)
{
  assert(dest && src);
  const char* ret = dest;
  while (*dest)//指针到'\0'停下
  {
  dest++;
  }
  for (int i = 0; i < num; i++)
  {
  *dest++ = *src++;
  }
  return ret;
}
int main()
{
  char arr1[30] = "welcome to";
  char arr2[] = " my ";
  my_strncat(arr1, arr2, 2);
  my_strncat(arr1, "blog", 2);
  printf("%s\n", arr1);
  return 0;
}

输出：


输出：welcome to mbl

strncmp

int strncmp ( const char * str1, const char * str2, size_t num )

strncmp可以控制比较的字符串的字符数。


例：

#include 
#include 
void print(int ret)
{
  if (ret > 0)
  printf("arr1>arr2\n");
  else if (ret == 0)
  printf("arr1=arr2\n");
  else
  printf("arr1
}
int main()
{
  char arr1[] = "abcd";
  char arr2[] = "abcz";
  int ret = strncmp(arr1, arr2, 3);
  print(ret);
  ret = strncmp(arr1, arr2, 4);
  print(ret);
  return 0;
}


输出：


输出：
arr1=arr2
arr1

字符串查找

strstr

strstr函数可以查找字符串中的字符，并返回他们的地址。


如果找不到对应字符或字符串，就返回空指针。


例：


#include 
#include 
int main()
{
  char arr[] = "welcome to my blog";
  char* p = strstr(arr, "my");
  printf("%s\n", p);
  return 0;
}

输出：


输出：my blog

例2：


#include 
#include 
int main()
{
  char arr1[] = "abbbcdbbcef";
  char arr2[] = "bbcb";
  char* ret = strstr(arr1, arr2);
  if (ret == NULL)
  {
  printf("找不到\n");
  }
  else
  {
  printf("%s\n", ret);
  }
  return 0;
}

输出：


输出：找不到

接下来我们可以模拟实现一下strstr函数：


#include 
#include 
#include 
//char* strstr(const char* str1, const char* str2)
char* my_strstr(const char* str1, const char* str2)
{
  assert(str1 && str2);
  if (*str2 == '\0')
  {
  return (char*)str1;
  }
  const char* s1 = NULL;
  const char* s2 = NULL;//初始化指针
  const char* cp = str1;//cp指针的作用是作为遍历字符串str1的起始地址
  while (*cp)//如果*cp已经等于'\0'了就证明查找失败了，不再进入循环
  {
  s1 = cp;//如果没找到，s1指针返回cp地址，也就是遍历开始的地址
  s2 = str2;//而s2指针返回str2的地址，重新对应查找
  while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)//匹配
  {
    s1++;
    s2++;
  }
  if (*s2 == '\0')
  {
    return (char*)cp;
  }
  cp++;//没找到，遍历的地址向前一个字节
  }
  return NULL;
}
int main()
{
  char arr1[] = "abbbcdbbcef";
  char arr2[] = "bbc";
  char* ret = my_strstr(arr1, arr2);
  if (ret == NULL)
  {
  printf("找不到\n");
  }
  else
  {
  printf("%s\n", ret);
  }
  return 0;
}

输出：


输出：bbcdbbcef

strtok

char * strtok ( char * str, const char * sep )


strtok函数可以通过分隔符sep分割字符串，并标记


如果之后传空指针，也能通过标记继续分割字符串。


例：

#include 
#include 
int main()
{
  char arr[] = "asdf@hjkl.qwer";
  char* p = "@.";
  char buf[20] = { 0 };
  strcpy(buf, arr);
  char* pa = strtok(buf, p);
  printf("%s\n", pa);
  pa = strtok(NULL, p);//传空指针
  printf("%s\n", pa);
  pa = strtok(NULL, p);
  printf("%s\n", pa);
  return 0;
}

输出：


输出：
asdf
hjkl
qwer

但是，我们发现，想上面那样写的话，


代码有一点冗余了，该怎么解决呢？


#include 
#include 
int main()
{
  char arr[] = "asdf@hjkl.qwer";
  char* p = "@.";
  char buf[20] = { 0 };
  strcpy(buf, arr);
  char* ret = NULL;
  for (ret = strtok(buf, p); ret != NULL; ret = strtok(NULL, p))
  {
  printf("%s\n", ret);
  }
  return 0;
}

输出：


输出：

asdf

hjkl

qwer

写成循环的形式就好多啦。


错误信息报告

strerror

C语言的库函数在运行的时候，如果发生错误，


就会将错误码存在一个变量中，这个变量是：errno。


而strerror 函数能将错误码翻译成错误信息。


例：


#include 
#include 
int main()
{
  //错误码是一些数字：1 2 3 4 5 ，他们都有不同的含义
  printf("%s\n", strerror(0));
  printf("%s\n", strerror(1));
  printf("%s\n", strerror(2));
  printf("%s\n", strerror(3));
  printf("%s\n", strerror(4));
  printf("%s\n", strerror(5));
  return 0;
}

输出：


输出：
No error
Operation not permitted
No such file or directory
No such process
Interrupted function call
Input/output error


perror

但在平时，perror用的也很多，


举个例子：

#include 
#include 
#include //这个是errno的头文件
int main()
{
  //打开文件
  FILE* pf = fopen("test.txt", "r");
  if (pf == NULL)
  {
  printf("%s\n", strerror(errno));//实际上我们并没有这个文件，就能通过strerror报错
  return 1;
  }
  //读文件
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

输出：


输出：No such file or directory

但是使用perror 函数会更方便和灵活。


#include 
#include 
#include 
int main()
{
  //打开文件
  FILE* pf = fopen("test.txt", "r");
  if (pf == NULL)
  {
  perror("fopen");
  return 1;
  }
  //读文件
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

输出：


输出：fopen: No such file or directory

字符操作

字符分类函数：

函数 如果他的参数符合下列条件就返回真

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 任何可打印字符，包括图形字符和空白字符

例：


#include 
#include 
int main()
{
  int ret = isdigit('Q');//参数是十进制数字 0~9返回真，否则返回假
  printf("%d\n", ret);
  return 0;
}

输出：


输出：0

还有一些字符操作函数：


例:


#include 
#include 
int main()
{
  printf("%c\n", toupper('a'));//转成大写
  printf("%c\n", tolower('A'));//转成小写
  return 0;
}

输出：


输出：
A
a

内存操作函数

memcpy

void * memcpy ( void * destination, const void * source, size_t num )


memcpy是内存拷贝函数：


1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。


2.这个函数在遇到 '\0' 的时候并不会停下来。


3.如果source和destination有任何的重叠，复制的结果都是未定义的（会出问题）。


例：


#include 
#include 
void print(int* arr, int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
}
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[10] = { 0 };
  memcpy(arr2, arr1 + 2, 17);//17个字节
  int sz = sizeof(arr2) / sizeof(arr2[0]);
  print(arr2, sz);
}


输出：


输出；3 4 5 6 7 0 0 0 0 0

接下来我们可以模拟实现一下memcpy函数：


#include 
#include 
#include 
void print(int* arr, int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
}
//void* memcpy(void* destination, const void* source, size_t num)
void* my_memcpy(void* dest, const void* src, size_t num)
{
  assert(dest && src);
  void* ret = dest;//记住起始地址
  while (num--)
  {
  *(char*)dest = *(char*)src;//一个字节一个字节的拷贝
  ++(char*)dest;
  ++(char*)src;
  }
  return ret;
}
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[10] = { 0 };
  my_memcpy(arr2, arr1 + 2, 17);//17个字节
  int sz = sizeof(arr2) / sizeof(arr2[0]);
  print(arr2, sz);
}

输出：


输出：3 4 5 6 7 0 0 0 0 0

memmove

void * memmove ( void * destination, const void * source, size_t num )


memmove函数的功能与memcpy的功能类似，但也有差别：


1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。


2.如果源空间和目标空间出现重叠，就得使用memmove函数处理


例：


如果使用memcpy,拷贝的结果就会出问题：


#include 
#include 
#include 
void print(int* arr, int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
}
//void* memcpy(void* destination, const void* source, size_t num)
void* my_memcpy(void* dest, const void* src, size_t num)
{
  assert(dest && src);
  void* ret = dest;//记住起始地址
  while (num--)
  {
  *(char*)dest = *(char*)src;//一个字节一个字节的拷贝
  ++(char*)dest;
  ++(char*)src;
  }
  return ret;
}
int main()
{
  int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
  my_memcpy(arr1 + 2, arr1, 17);//17个字节
  int sz = sizeof(arr1) / sizeof(arr1[0]);
  print(arr1, sz);
}

输出：


输出：1 2 1 2 1 2 1 8 9 10

我们想要的结果是：1 2 1 2 3 4 5 8 9 10


（注：在VS2019的环境下，memcpy的库函数实现已经和memmove一样了）


那就得使用memmove函数：


#include 
#include 
void print(int* arr, int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
}
int main()
{
  int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
  memmove(arr1 + 2, arr1, 17);//17个字节
  int sz = sizeof(arr1) / sizeof(arr1[0]);
  print(arr1, sz);
}


输出：


输出：1 2 1 2 3 4 5 8 9 10

这样就成功得到我们想要的值了。


接下来我们可以模拟实现一下memmove函数：


#include 
#include 
#include 
void print(int* arr, int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
}
//void* memmove(void* destination, const void* source, size_t num)
void* my_memmove(void* dest, const void* src, size_t num)
{
  assert(dest && src);
  void* ret = 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);
  }
  }
}
int main()
{
  int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
  my_memmove(arr1 + 2, arr1, 17);//17个字节
  int sz = sizeof(arr1) / sizeof(arr1[0]);
  print(arr1, sz);
}


输出：


输出：1 2 1 2 3 4 5 8 9 10

memset

void * memset ( void * ptr, int value, size_t num )


memset是内存定义函数，我们一般用它来进行初始化操作。


例：


#include 
#include 
void print(int* arr, int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
  printf("\n");
}
int main()
{
  int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
  memset(arr1, 0, sizeof(arr1));//设置成0
  char arr2[20] = "hello world";
  memset(arr2, 'x', 5);//把五个字节的内容设置成‘x’
  int sz = sizeof(arr1) / sizeof(arr1[0]);
  print(arr1, sz);
  printf("%s\n", arr2);
}

输出：


输出：
0 0 0 0 0 0 0 0 0 0
xxxxx world

memcmp

int memcmp ( const void * ptr1,const void * ptr2,size_t num )


memcmp函数能比较从ptr1和ptr2指针开始的num个字节，


ptr1 > ptr2 返回 >0 的数，


ptr1 < ptr2 返回 <0 的数，


ptr1 = ptr2 返回 =0 的数。


例：


#include 
#include 
int main()
{
  char arr1[] = "abcd";
  char arr2[] = "abcz";
  int ret = memcmp(arr1, arr2, 4);//比较四个字节的内容
  if (ret > 0)
  printf("arr1>arr2\n");
  else if (ret == 0)
  printf("arr1=arr2\n");
  else
  printf("arr1
  return 0;
}

输出：


输出：arr1

写在最后：

以上就是本篇文章的内容了，感谢你的阅读。


如果喜欢本文的话，欢迎点赞和评论，写下你的见解。


如果想和我一起学习编程，不妨点个关注，我们一起学习，一同成长。


之后我还会输出更多高质量内容，欢迎收看。

文章标签：
C语言
关键词：
C语言函数
内存字符串
C语言内存
内存函数
C语言内存函数
戊子仲秋
目录
相关文章
Skyund
|
7天前
|
C语言
c语言调用的函数的声明
被调用的函数的声明： 一个函数调用另一个函数需具备的条件: 首先被调用的函数必须是已经存在的函数，即头文件中存在或已经定义过； 如果使用库函数，一般应该在本文件开头用#include命令将调用有关库函数时在所需要用到的信息“包含”到本文件中。.h文件是头文件所用的后缀。 如果使用用户自己定义的函数，而且该函数与使用它的函数在同一个文件中，一般还应该在主调函数中对被调用的函数做声明。 如果被调用的函数定义出现在主调函数之前可以不必声明。 如果已在所有函数定义之前，在函数的外部已做了函数声明，则在各个主调函数中不必多所调用的函数在做声明
Skyund
23 6
众所周知
|
9天前
|
缓存 算法 Java
本文聚焦于Java内存管理与调优，介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制
在现代软件开发中，性能优化至关重要。本文聚焦于Java内存管理与调优，介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制。通过调整垃圾回收器参数、优化堆大小与布局、使用对象池和缓存技术，开发者可显著提升应用性能和稳定性。
众所周知
30 6
ephemerals__
|
21天前
|
C语言
【c语言】动态内存管理
本文介绍了C语言中的动态内存管理，包括其必要性及相关的四个函数：`malloc`、``calloc``、`realloc`和`free`。`malloc`用于申请内存，`calloc`申请并初始化内存，`realloc`调整内存大小，`free`释放内存。文章还列举了常见的动态内存管理错误，如空指针解引用、越界访问、错误释放等，并提供了示例代码帮助理解。
ephemerals__
33 3
c的前世今生
|
20天前
|
存储 算法 程序员
C语言：库函数
C语言的库函数是预定义的函数，用于执行常见的编程任务，如输入输出、字符串处理、数学运算等。使用库函数可以简化编程工作，提高开发效率。C标准库提供了丰富的函数，满足各种需求。
c的前世今生
24 1
ephemerals__
|
26天前
|
机器学习/深度学习 C语言
【c语言】一篇文章搞懂函数递归
本文详细介绍了函数递归的概念、思想及其限制条件，并通过求阶乘、打印整数每一位和求斐波那契数等实例，展示了递归的应用。递归的核心在于将大问题分解为小问题，但需注意递归可能导致效率低下和栈溢出的问题。文章最后总结了递归的优缺点，提醒读者在实际编程中合理使用递归。
ephemerals__
53 7
ephemerals__
|
23天前
|
存储 C语言
【c语言】字符串函数和内存函数
本文介绍了C语言中常用的字符串函数和内存函数，包括`strlen`、`strcpy`、`strcat`、`strcmp`、`strstr`、`strncpy`、`strncat`、`strncmp`、`strtok`、`memcpy`、`memmove`和`memset`等函数的使用方法及模拟实现。文章详细讲解了每个函数的功能、参数、返回值，并提供了具体的代码示例，帮助读者更好地理解和掌握这些函数的应用。
ephemerals__
19 0
ephemerals__
|
23天前
|
C语言
【c语言】qsort函数及泛型冒泡排序的模拟实现
本文介绍了C语言中的`qsort`函数及其背后的回调函数概念。`qsort`函数用于对任意类型的数据进行排序，其核心在于通过函数指针调用用户自定义的比较函数。文章还详细讲解了如何实现一个泛型冒泡排序，包括比较函数、交换函数和排序函数的编写，并展示了完整的代码示例。最后，通过实际运行验证了排序的正确性，展示了泛型编程的优势。
ephemerals__
19 0
不爱讲大道理
|
6月前
|
存储 编译器 C语言
在C语言中的数组和字符串
在C语言中的数组和字符串
不爱讲大道理
55 1
小徐在进步
|
2月前
|
存储 C语言
【C语言基础考研向】10 字符数组初始化及传递和scanf 读取字符串
本文介绍了C语言中字符数组的初始化方法及其在函数间传递的注意事项。字符数组初始化有两种方式：逐个字符赋值或整体初始化字符串。实际工作中常用后者，如`char c[10]=&quot;hello&quot;`。示例代码展示了如何初始化及传递字符数组，并解释了为何未正确添加结束符`\0`会导致乱码。此外，还讨论了`scanf`函数读取字符串时忽略空格和回车的特点。
小徐在进步
85 8
chem4111
|
4月前
|
安全 C语言
C语言8 数组与字符串
C语言8 数组与字符串
chem4111
32 0