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

C语言之字符函数&字符串函数篇（1）

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


接下来我们进入字符函数和字符串函数的讲解。中秋和国庆即将来临，终于要放假了回家了。

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在 常量字符串 中或者 字符数组 中。 字符串常量 适用于那些对它不做修改的字符串函数.

我们重点讲解：字符串函数 字符函数 内存函数

关于下面的字符串函数我们将从：作用  头文件  参数 返回值 等方面去介绍。

前言

printf打印字符串是打印\0之前的字符串。看到\0停止打印了

#include<stdio.h>
int main()
{
  char arr[10] = "abc\0def";
  printf("%s\n", arr);
  return 0;
}

需要用到的头文件

#include<stdio.h>
#include<string.h>
#include<assert.h>
//断言和const修饰的指针在调试讲过

求字符串长度

strlen

strlen - C++ Reference

  • strlen是库函数，是用来求字符串长度的
  • strlen求字符串长度本质上统计的是字符串\0之前的字符串长度。
  • 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前的字符个数（不包含 '\0' )
  • strlen的头文件是#include<string.h>
  • strlen的参数 是 const char *str （把字符串的首元素地址传给strlen)(const 是为了确保库函数strlen里的操作将主函数main的字符串改变了）
  • 参数指向的字符串必须要以 '\0' 结束。
  • strlen的返回值是 size_t 类型的，返回的数值是无符号的整型
  • strlen的模拟实现需要掌握（计数器  函数递归  指针_指针）

strlen统计的是字符串\0之前的字符串长度

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "abcdef";
  size_t ret =strlen(arr1);
  char arr2[] = "abc\0def";//统计的是\0之前的字符串长度
  size_t r = strlen(arr2);
  printf("arr1=%d,arr1=%d", ret, r);
  return 0;
}

字符指针

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "abcdef";
  size_t ret =strlen(arr1);
  char* p = "abcdef";//这里p存储的就是字符串的首元素地址 起始地址
  size_t r = strlen(p);
  printf("ret=%d r=%d", ret, r);
  return 0;
}

strlen的返回值是无符号整型

#include<stdio.h>
#include<string.h>
int main()
{
  //          3                 6       
  if (strlen("abc") - strlen("abcdef") > 0)//正数，3为无符号数是一个很大的数
  {
    printf(">\n");
  }
  else
  {
    printf("<\n");
  }
  return 0;
}
3为无符号整数的时候
//00000000 00000000 00000000 00000011 原码
//为无符号为所以没有符号位，所以全部取反加1
//11111111 11111111 11111111 11111101 补码
6
//00000000 00000000 00000000 00000110 原码
//11111111 11111111 11111111 11111010 补码
//3>6

strlen的三种模拟实现

计数器
#include<stdio.h>
size_t my_strlen(char* p)
{
  int count = 0;
  while (*p)
  {
    count++;
    p++;
  }
  return count;
}
int main()
{
  char arr[] = "abcdef";
  size_t ret = my_strlen(arr);
  printf("%zd\n", ret);
  return 0;
}
函数递归 
#include<stdio.h>
size_t my_strlen(const char* p)
{
  if (*p == '\0')
    return 0;
  else
  {
    return 1 + my_strlen(p+1);//切记不要p++,++p这种副作用的++
  }
}
int main()
{
  char arr[] = "abcdef";
  size_t ret = my_strlen(arr);
  printf("%zd", ret);
  return 0;
}
指针_指针
#include<stdio.h>
int my_strlen(char* p)
{
  char* r = p;//起始地址
  while (*p != '\0')
  {
    p++;
  }
  return p - r;
}
int main()
{
  char arr[] = "abcdef";
  int ret=my_strlen(arr);
  printf("%d", ret);
  return 0;
}

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

下面我们介绍的是长度不受限制的字符串函数。

strcpy

strcpy - C++ Reference (cplusplus.com)

  • strcpy是库函数，是用来字符串拷贝的，会将源字符串中的 '\0' 拷贝到目标空间。
  • 本质就是 将源头字符串source（包括\0) 拷贝到 目的地空间中的字符串destination里
  • strcpy的头文件是 #include<string>
  • strcpy的参数 一个是指向 源头字符串的首元素地址 指针变量source
  • 源字符串必须以 '\0' 结束。
  • strcpy的另外一个参数是指向 目的地空间字符串的首元素地址 指针变量destination
  • 目标空间必须足够大，以确保能存放源字符串。
  • 目标空间必须可变。
  • strcpy函数的返回值是 目标空间的起始地址
  • strcpy的模拟实现
  • 链式访问和assert

strcpy会将源字符串中的 '\0' 拷贝到目标空间

#include<stdio.h>
int main()
{
  char arr1[20] = "xxxxxxxxxxxxx";
  printf("%s\n", arr1);
  char arr2[] = "abcdef";//会将\0拷贝过去，所以不会有xxxxx
  strcpy(arr1, arr2);
  printf("%s", arr1);
  return 0;
}

strcpy参数目标空间必须足够大且可变

#include<stdio.h>
int main()
{
  char arr1[1] = { 0 };//不够大
  char arr2[] = "abcdef";
  strcpy(arr1, arr2);
  printf("%s", arr1);
  return 0;
}
#include<stdio.h>
int main()
{
  char arr1[1] = "hijklem";//常量字符串
  char arr2[] = "abcdef";
  strcpy(arr1, arr2);
  printf("%s", arr1);
  return 0;
}

strcpy的模拟实现

//逻辑关系
//
{
;
}
//操作符的优先级
//画图最重要

//模拟实现strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcpy( char*dest,  const char* src)
{
  char* ret = dest;//为了返回目标空间字符串的起始地址，需要先存储起来
  assert(dest && src);//断言
  while (*dest++ = *src++)//赋值和等于
  {
    ;
  }
  return ret;
}
int main()
{
  char arr1[20] = {0};
  char arr2[] = "abcdef";
  my_strcpy(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}
//链式访问
int main()
{
  char arr1[20] = {0};
  char arr2[] = "abcdef";
  printf("%s\n", my_strcpy(arr1, arr2));//链式访问
  return 0;
}
//换种写法❌的没有将\0拷贝过去
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
  char* ret = dest;//为了返回目标空间字符串的起始地址，需要先存储起来
  assert(dest && src);//断言
  while (*src != '\0')
  {
    *dest = *src;//不是== 是赋值
    dest++;
    src++;
  }
  return ret;
}

strcat

strcat - C++ Reference (cplusplus.com)

  • strcat是库函数，是用来字符串追加的
  • strcat是将 源头字符串 （包括\0) 追加到 目的地空间字符串 (覆盖\0) 的后面。
  • strcat的头文件是#include<string.h>
  • strcat 的一个参数是 指向源头字符串的首元素地址 的指针变量 source
  • 源字符串必须以 '\0' 结束。
  • 在拷贝时，需要将源字符串中的'\0'拷贝过去
  • strcat 的另外一个参数是 指向目的地空间的字符串的首元素 的指针变量 destination
  • 目标空间必须有足够的大，能容纳下源字符串的内容。
  • 目标空间必须可修改
  • 目标空间必须得有'\0'（保证能找到目标空间的末尾）
  • strcat的返回值也是 目标空间的起始地址
  • strcat的模拟实现
  • 字符串自己给字节追加，可以吗？strncat

strcat有将源头字符串的\0追加过去

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

strcat字符串自己追加自己 

#include<stdio.h>
int main()
{
  char arr1[20] = "abc";
  strcat(arr1, arr1);
  printf("%s\n", arr1);
  return 0;
}

#include<stdio.h>
char* my_strcat(char* str1, const char* str2)
{
  char* ret = str1;
  while (*str1)
  {
    str1++;
  }
  while (*str2 != '\0')
  {
    
      *str1++ = *str2++;
  }
  return ret;
}
int main()
{
  char arr1[20] = "abc";
  char arr2[20] = "defg";
  my_strcat(arr1, arr1);
  printf("%s\n", arr1);
  return 0;
}

字符串自己追加自己这种方式。在不同编译器上，有的可以，有的不行。编译器的厂商不同，相同的库函数是由不同程序员实现的，所以库函数内部实现是不同的。最好不要这样写 。后面介绍strncat可以实现这种情况。

strcat的模拟实现

//逻辑关系
//
{
;
}
//操作符的优先级
//画图最重要

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char* str1, const char* str2)
{
  assert(str1 && str2);//断言
  //strcat函数返回的是目标空间的起始地址
  char* ret = str1;
  //1，找到目标空间的末尾
  while (*str1 != '\0')
    //  while (*str1++)❌?????????????
    //后置++ 先使用  再*
  {
    str1++;
  }
  //2。数据追加
  while (*str1++ = *str2++)
    //后置++的规则
  {
    ;
  }
  return ret;
}
int main()
{
  char arr1[20] = "abc";
  char arr2[20] = "defg";
  my_strcat(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}

strcmp

strcmp - C++ Reference (cplusplus.com)

strcmp的返回值如下：

  • strcmp是库函数，是用来字符串比较的
  • 本质上：不是比较长度，而是比较对应位置上的字符的大小，用ASCII码值来比较
  • strcmp的头文件是 #include<string.h>
  • strcmp 的两个参数 是指向 两个需要比较的字符串 的指针变量str1 和 str2
  • const修饰指针变量，为了确保strcmp库函数里的操作将主函数main里的字符串改变
  • strcmp的返回值由上图解释就是：
  1. 第一个字符串 大于 第二个字符串，则返回大于0的数字
  2. 第一个字符串 等于 第二个字符串，则返回0
  3. 第一个字符串 小于 第二个字符串，则返回小于0的数字
  • strcpy的模拟实现

strcmp的返回值

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "abz";
  char arr2[] = "abq";
  if (strcmp(arr1, arr2) > 0)
  {
    printf(">\n");
  }
  else if(strcmp(arr1, arr2) < 0)
  {
    printf("<\n");
  }
  else
  {
    printf("=\n");
  }
  printf("%d", strcmp(arr1, arr2));//不同编译器下的值不同，但是都是以><=0的范围。
  return 0;
}

strcmp的模拟实现

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp( const char* p1, const 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));//不同编译器下的值不同，但是都是以><=0的范围。
  return 0;
}
//或者
#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp( const char* p1, const char* p2)
{
  assert(p1 && p2);
  while (*p1 == *p2)
  {
    if (*p1 == '\0')
      return 0;
    p1++;
    p2++;
  }
  //!=
  return *p1 - *p2;
}
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));//不同编译器下的值不同，但是都是以><=0的范围。
  return 0;
}
int my_strcmp(char* p1, char* p2)
{
  while (*p1 == *p2)
  {
    if (*p1 == '\0')
      return 0;
    p1++;
    p2++;
  }
  //!=
    return (*p1-*p2);
}

长度受限制的字符串函数

接下来，我们介绍的是在上面函数的基础上，长度受限制的字符串函数

关于上面的解释过的点，我们将不在介绍，下面我们重点介绍受限制n的差别，和注意点

对比上面长度不受限制的字符串函数，我们发现多了一个size_t num的参数 ，相对安全一些

strncpy

strncpy - C++ Reference (cplusplus.com)

  • 拷贝num个字符从源字符串到目标空间。
  • 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个
  • 不会将'\0'拷贝过去

num<

#include<stdio.h>
int main()
{
  char arr1[20] = "xxxxxxxxxxxxxx";
  char arr2[] = "abcdef";
  strncpy(arr1, arr2,3);
  printf("%s", arr1);
  return 0;
}

无拷贝'\0'

那请问是否将'\0'拷贝过去了呢？答案是：没有哦

#include<stdio.h>
int main()
{
  char arr1[20] = "xxxxxxxxxxxxxx";
  char arr2[] = "abcdef";
  strncpy(arr1, arr2,3);
  printf("%s\n", arr1);
  strcpy(arr1, arr2);
  printf("%s", arr1);
  return 0;
}
对比一下：就只知道'\0'有没有拷贝过去
#include<stdio.h>
int main()
{
  char arr1[20] = "xxxxxxxxxxxxx";
  printf("%s\n", arr1);
  char arr2[] = "abcdef";//会将\0拷贝过去，所以不会有xxxxx
  strcpy(arr1, arr2);
  printf("%s", arr1);
  return 0;
}

调式过后，我们可以发现，当我们num是几，我们就拷贝几个字符过去，并不会将'\0'拷贝

num>

那当我们的num超过了被拷贝的字符串的字符个数，会发生什么呢？ 

#include<stdio.h>
int main()
{
  char arr1[20] = "xxxxxxxxxxxxxx";
  char arr2[] = "abc";
  strncpy(arr1, arr2, 6);
  printf("%s\n", arr1);
  return 0;
}

当我们调试发现，即便我们没有num超出了被拷贝字符串的字符个数。但是strnpy仍然会达到num的个数。那就是用'\0'去填补缺少的num的个数，必须满足num的字符个数拷贝过去方可。

strncat

strncat - C++ Reference (cplusplus.com)

  • 追加num个字符从源字符串到目标空间。
  • 如果源字符串的长度小于num，则追加完源num字符串之后，不会再追加了
  • 会将'\0'追加过去

num<

#include<stdio.h>
int main()
{
  char arr1[20] = "abc";
  char arr2[] = "defghi";
  strncat(arr1, arr2, 3);
  printf("%s\n", arr1);
  return 0;
}

是追加'\0'

那我们的strncat函数是否追加字符串的同时将'\0'追加过去呢？答案是：有。

#include<stdio.h>
int main()
{
  char arr1[20] = "abc\0xxxxxxxxxx";
  char arr2[] = "defghi";
  strncat(arr1, arr2, 3);
  printf("%s\n", arr1);
  return 0;
}
//如果追加了'\0'，那么打印abcdef
//如果没有追加'\0',那么打印abcdefxxxxxxx

经过调试，我们发现在将源字符串追加到目的地空间字符串的后面时，我们把num的字符追加过去之后，同时会将'\0'追加过去。

num>

那当我们的num超过了被追加的字符串的字符个数，会发生什么呢？ 

#include<stdio.h>
int main()
{
  char arr1[20] = "abc\0xxxxxxxxxx";
  char arr2[] = "defghi";
  strncat(arr1, arr2, 10);
  printf("%s\n", arr1);
  return 0;
}

当我们调试发现，当num超过源字符串里的元素个数，strncat的源字符串有多少字符元素就追加多少字符元素，并不会用'\0'去弥补空缺。

strncmp

strcmp - C++ Reference (cplusplus.com)

  • 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

>0

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "abczef";
  char arr2[] = "abcqw";
  int ret = strncmp(arr1, arr2, 4);
  printf("%s\n", ret);
  return 0;
}

<0

#include<stdio.h>
#include<string.h>
int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "abcqw";
  int ret = strncmp(arr1, arr2, 4);
  printf("%s\n", ret);
  return 0;
}

=0

#include<stdio.h>
int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "abcdef";
  int ret = strncmp(arr1, arr2, 3);
  printf("%s\n", ret);
  return 0;
}

这里留下几个任务就是动动小手我们写一写在原来的基础上模拟实现strnpy strncat strncmp,下篇博文讲。🙂🙂🙂🙂🙂

总结

  • 作用会包含'\0'的字符串函数：strcpy strcat strncat
  • 不会作用会包含'\0'的字符串函数：strncpy
  • 需要作用包括\0的字符串函数像追加/拷贝，会覆盖掉目的地空间字符串的\0，必须带上\0
  • 不需要是因为即便拷贝过去，目的地函数里原本就有多余的\0，不需要拷贝例如strnpy
  • 各个字符串函数的模拟实现要掌握

✔✔✔✔✔最后，感谢大家的阅读，若有错误和不足，欢迎指正！下篇博文我们继续字符函数。🆗

当然今天有很开心的事情就是，以为我不能考英语四级了，结果候补有位置了，真的很开心！当然也提醒大家抢四级报名不要慌，也不要一直刷新和操作，这样会和我一样强制下线的┭┮﹏┭┮

代码------→【gitee:唐棣棣 (TSQXG) - Gitee.com】

联系------→【邮箱：2784139418@qq.com】

文章标签：
C语言
C++
编译器
程序员
安全
关键词：
C语言函数
C语言字符字符串函数
C语言字符
C语言字符串函数
C语言函数字符串函数
唐唐思
目录
相关文章
蓝易云
|
2月前
|
安全 C语言
C语言中的字符、字符串及内存操作函数详细讲解
通过这些函数的正确使用，可以有效管理字符串和内存操作，它们是C语言编程中不可或缺的工具。
蓝易云
233 15
RossyYan
|
8月前
|
存储 算法 C语言
【C语言程序设计——函数】素数判定（头歌实践教学平台习题）【合集】
本内容介绍了编写一个判断素数的子函数的任务，涵盖循环控制与跳转语句、算术运算符（%）、以及素数的概念。任务要求在主函数中输入整数并输出是否为素数的信息。相关知识包括 `for` 和 `while` 循环、`break` 和 `continue` 语句、取余运算符 `%` 的使用及素数定义、分布规律和应用场景。编程要求根据提示补充代码，测试说明提供了输入输出示例，最后给出通关代码和测试结果。 任务核心：编写判断素数的子函数并在主函数中调用，涉及循环结构和条件判断。
RossyYan
367 23
程序员Feri
|
7月前
|
人工智能 Java 程序员
一文彻底搞清楚C语言的函数
本文介绍C语言函数：函数是程序模块化的工具，由函数头和函数体组成，涵盖定义、调用、参数传递及声明等内容。值传递确保实参不受影响，函数声明增强代码可读性。君志所向，一往无前！
程序员Feri
171 1
一文彻底搞清楚C语言的函数
RossyYan
|
8月前
|
算法 C语言
【C语言程序设计——函数】利用函数求解最大公约数和最小公倍数（头歌实践教学平台习题）【合集】
本文档介绍了如何编写两个子函数，分别求任意两个整数的最大公约数和最小公倍数。内容涵盖循环控制与跳转语句的使用、最大公约数的求法（包括辗转相除法和更相减损术），以及基于最大公约数求最小公倍数的方法。通过示例代码和测试说明，帮助读者理解和实现相关算法。最终提供了完整的通关代码及测试结果，确保编程任务的成功完成。
RossyYan
302 15
【C语言程序设计——函数】利用函数求解最大公约数和最小公倍数（头歌实践教学平台习题）【合集】
RossyYan
|
8月前
|
C语言
【C语言程序设计——函数】亲密数判定（头歌实践教学平台习题）【合集】
本文介绍了通过编程实现打印3000以内的全部亲密数的任务。主要内容包括： 1. **任务描述**：实现函数打印3000以内的全部亲密数。 2. **相关知识**： - 循环控制和跳转语句（for、while循环，break、continue语句）的使用。 - 亲密数的概念及历史背景。 - 判断亲密数的方法：计算数A的因子和存于B，再计算B的因子和存于sum，最后比较sum与A是否相等。 3. **编程要求**：根据提示在指定区域内补充代码。 4. **测试说明**：平台对代码进行测试，预期输出如220和284是一组亲密数。 5. **通关代码**：提供了完整的C语言代码实现
RossyYan
142 24
RossyYan
|
8月前
|
存储 C语言
【C语言程序设计——函数】递归求斐波那契数列的前n项（头歌实践教学平台习题）【合集】
本关任务是编写递归函数求斐波那契数列的前n项。主要内容包括： 1. **递归的概念**：递归是一种函数直接或间接调用自身的编程技巧，通过“俄罗斯套娃”的方式解决问题。 2. **边界条件的确定**：边界条件是递归停止的条件，确保递归不会无限进行。例如，计算阶乘时，当n为0或1时返回1。 3. **循环控制与跳转语句**：介绍`for`、`while`循环及`break`、`continue`语句的使用方法。 编程要求是在右侧编辑器Begin--End之间补充代码，测试输入分别为3和5，预期输出为斐波那契数列的前几项。通关代码已给出，需确保正确实现递归逻辑并处理好边界条件，以避免栈溢出或结果
RossyYan
358 16
RossyYan
|
8月前
|
存储 编译器 C语言
【C语言程序设计——函数】分数数列求和2（头歌实践教学平台习题）【合集】
函数首部：按照 C 语言语法，函数的定义首部表明这是一个自定义函数，函数名为fun，它接收一个整型参数n，用于指定要求阶乘的那个数，并且函数的返回值类型为float（在实际中如果阶乘结果数值较大，用float可能会有精度损失，也可以考虑使用double等更合适的数据类型，这里以float为例）。例如：// 函数体代码将放在这里函数体内部变量定义：在函数体中，首先需要定义一些变量来辅助完成阶乘的计算。比如需要定义一个变量（通常为float或double类型，这里假设用float。
RossyYan
196 3
RossyYan
|
8月前
|
存储 算法 安全
【C语言程序设计——函数】分数数列求和1（头歌实践教学平台习题）【合集】
if 语句是最基础的形式，当条件为真时执行其内部的语句块；switch 语句则适用于针对一个表达式的多个固定值进行判断，根据表达式的值与各个 case 后的常量值匹配情况，执行相应 case 分支下的语句，直到遇到 break 语句跳出 switch 结构，若没有匹配值则执行 default 分支（可选）。例如，在判断一个数是否大于 10 的场景中，条件表达式为 “num> 10”，这里的 “num” 是程序中的变量，通过比较其值与 10 的大小关系来确定条件的真假。常量的值必须是唯一的，且在同一个。
RossyYan
167 2
RossyYan
|
8月前
|
存储 编译器 C语言
【C语言程序设计——函数】回文数判定（头歌实践教学平台习题）【合集】
算术运算于 C 语言仿若精密 “齿轮组”，驱动着数值处理流程。编写函数求区间[100,500]中所有的回文数，要求每行打印10个数。根据提示在右侧编辑器Begin--End之间的区域内补充必要的代码。如果操作数是浮点数，在 C 语言中是不允许直接进行。的结果是 -1，因为 -7 除以 3 商为 -2，余数为 -1；注意：每一个数据输出格式为 printf("%4d", i);的结果是 1，因为 7 除以 -3 商为 -2，余数为 1。取余运算要求两个操作数必须是整数类型，包括。开始你的任务吧，祝你成功！
RossyYan
141 1
LuckiBit
|
9月前
|
存储 C语言 开发者
【C语言】字符串操作函数详解
这些字符串操作函数在C语言中提供了强大的功能，帮助开发者有效地处理字符串数据。通过对每个函数的详细讲解、示例代码和表格说明，可以更好地理解如何使用这些函数进行各种字符串操作。如果在实际编程中遇到特定的字符串处理需求，可以参考这些函数和示例，灵活运用。
LuckiBit
339 10