c语言 字符串 string.h

最新推荐文章于 2025-11-13 19:44:56 发布
原创 最新推荐文章于 2025-11-13 19:44:56 发布 · 1.2k 阅读 · 24 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#单片机 #stm32 #嵌入式硬件

C语言字符串(windows)

字符串的定义

 #include <stdio.h>
 ​
 int main(void) {
     
     //单个字符
     char c = 'c';
 ​
     //多个字符 串起来 String
     char arr[] = { "Hello" };   // 隐式定义
     //'H' 'e' 'l' 'l' 'o' '\0'
     /*
     错误示范
     char str[5] = "Hello";
     
     printf("%c", str);
     
     输出结果为 烫烫烫
     */
     //字符串如果不用于修改定义成const char arr[] = "Hello";
     
     //char* ptr = "Hello";  ptr指向H 指针形式定义的字符串不可修改  
     const char* ptr = "Hello"; //这样定义以免对字符串进行修改而报错
     //修改字符串的的字母（元素）
     arr[0] = 'q';
     
     printf("%s", arr);
 ​
     return 0;
 }

strcpy_s用法

string copy:复制字符串

 #include <stdio.h>
 #include <string.h>
 int main(void) {
 ​
     const char src[] = "Hello";
 ​
     char dest[50];
 ​
     //strcpy(dest ,src);    早期函数，有安全问题
     strcpy_s(dest, 50, src); //50写成sizeof(dest)也行
     //strcpy_s(dest, 4, src);   缓冲区太小导致src不能copy到dest里 缓冲区溢出
     printf("%s", dest);
 ​
     return 0;
 }

VS编译器捕获字符串异常

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <crtdbg.h>
 ​
 void my_invalid_parm_handler(const wchar_t* expression, const wchar_t* function, const wchar_t* file, unsigned int line, uintptr_t p_reserved) {
     wprintf(L"Invalid parameter detected in function %s.File:%s Line %d\n", function, file, line);
     wprintf(L"Expression:s\n", expression);
 ​
 };
 ​
 int main(void) {
     _set_invalid_parameter_handler(my_invalid_parm_handler);
 ​
     const char src[] = "Hello";
 ​
     char dest[2];
 ​
     errno_t err = strcpy_s(dest, sizeof(dest), src);
 ​
     if (err != 0) {
         printf("Error copying string.Error code:%d\n, err");
     }
     else {
         printf("%s\n", dest);
     }
 ​
     printf("%s\n", dest);   //buffer is too small 捕获异常
 ​
 ​
     return 0;
 }

通过release可以捕获错误

strlen

string length:计算字符串长度（不计算'\0'）

 #include <stdio.h>
 ​
 int main(void) {
     //strlen:string length
 ​
     char dest[50] = "Hello";
 ​
     printf("%zd", strlen(dest)); //不统计'\0'
     
 ​
     return 0;
 }

微软认为不安全 以下是消除警告的代码

 #include <stdio.h>
 #include <string.h>
 ​
 int main(void) {
     
     char dest[50] = {0};
 ​
     strcpy_s(dest, sizeof(dest), "Hello");
 ​
     printf("%zd\n", strlen(dest));
 ​
     return 0;
 }

strcat_s

string concatenate:拼接字符串

 #include <stdio.h>
 #include <string.h>
 ​
 int main(void) {
     
     char dest[50] = {0};
 ​
     strcpy_s(dest, 50, "Hello");
 ​
     const char* src = ", world!\n";
 ​
     //dest = "Hello, world!"
 ​
     rsize_t dest_size = sizeof(dest) - strlen(dest) - 1;    //dest剩下的位置 = dest能放下的位置 - 已经存进去的位置 - '\0'
 ​
     //strcat(dest, src); 原始函数，不安全
     strcat_s(dest, dest_size, src);
 ​
     printf("%s", dest);
 ​
     return 0;
 }

sprintf_s

string print:字符串格式化输出

 #include <stdio.h>
 #include <string.h>
 ​
 int main(void) {
     //sprintf() sprintf_s()
 ​
     //避免缓冲区溢出
 ​
     char buffer[50] = {0};
     int number = 3;
     double pi = 3.14159;
 ​
     int ret = sprintf_s(buffer, sizeof(buffer), "Integer:%d, Double:%.2f", number, pi);
 ​
     if (ret > 0) {
     
         printf("Formatted string:%s\n", buffer);
     
     }
     else {
     
         printf("Error formatting string!\n");
     
     }
     return 0;
 }

strncpy_s

复制指定数量的字符

 #include <stdio.h>
 #include <string.h>
 ​
 int main(void) {
     
     //strncpy strncpy_s
 ​
     char dest[20];
     const char* src = "Hello, world!\n";
 ​
     size_t max_cpy = 10; //最多复制10个字符
 ​
     errno_t result = strncpy_s(dest, sizeof(dest), src, max_cpy);
 ​
     if (result == 0) {
         printf("Copied string :%s\n", dest);
     }
     else {
         printf("Error copying string.");
     
     }
 ​
     return 0;
 }

strncat_s

拼接指定数量的字符

 #include <stdio.h>
 #include <string.h>
 ​
 int main(void) {
     // strncat_s 
     // 最多追加多少个字符
 ​
     char dest[20] = {0};
 ​
     strcpy_s(dest, sizeof(dest), "Hello");
 ​
     const char* src = ", world!\n";
 ​
     size_t max_append = 7; //最多追加7个字符
 ​
     errno_t result = strncat_s(dest, sizeof(dest), src, max_append);
 ​
     if (result == 0) {
         printf("Concatenated String:%s\n", dest);
     }
     else {
         printf("Error concatenating string\n");
     }
 ​
     return 0;
 }

puts & gets_s

puts

 #include <stdio.h>
 ​
 int main(void) {
 ​
     //puts();
 ​
     puts("hello");
 ​
     const char* str = "Hello";
 ​
     puts(str);  //专门输出字符串
 ​
     return 0;
 }

gets_s

 #include <stdio.h>
 ​
 int main(void) {
 ​
     // gets() 原始函数 ---- gets_s()
 ​
     char buffer[100];
 ​
     gets_s(buffer, sizeof(buffer));
     
     printf("You enter:%s\n", buffer);
     /*更加安全
     
     if (gets_s(buffer, sizeof(buffer)) != NULL)
     {
         printf("You enter:%s\n", buffer);
     }
     else
     {       
     printf("Error or end of the file");
     }
     */
 ​
     return 0;
 }

strtok_s

string tokenize:分解字符串

 #include <stdio.h>
 #include <string.h>
 int main(void) {
     // strtok()原始函数 ——————————————strtok_s
 ​
     // 按照要求分解字符串
 ​
     char str[] = "This is a sample string";
     char delim[] = " ";
     char* token;
     char* context = {0};    // 保存strtok_s函数在其内部位置之间的上下文指针
 ​
     token = strtok_s(str, delim, &context);
 ​
     while (token != NULL) {
         printf("Token:%s\n", token);
         token = strtok_s(NULL, delim, &context);
     }
 ​
 ​
     return 0;
 }

strcmp

string compare:比较字符

 #include <stdio.h>
 #include <string.h>
 int main(void) {
 // 但凡是涉及到字符串修改的都有函数都带有_s
 ​
     // strcmp;
     //strncmp;
 ​
     const char* str1 = "Hello, world!";
     const char* str2 = "Hello, world!";
     const char* str3 = "Hello, guys!";
 ​
     if (strcmp(str1, str2) == 0) {
         printf("Str1 and str2 are equal!\n");
     }
     else {
         printf("Str1 and str2 are not equal!\n");
     }
     if (strcmp(str1, str3) == 0) {
         printf("Str1 and str3 are equal!\n");
     }
     else {
         printf("Str1 and str3 are not equal!\n");
     }
 ​
     int value1 = strcmp(str1, str3);    // ASCII码 g < w str3 < str1
 ​
     printf("%d\n", value1);// > 0
 ​
     int value2 = strcmp(str3, str1);
 ​
     printf("%d\n", value2);// < 0
 ​
     return 0;
 }

strncmp

比较指定个数字符

 #include <stdio.h>
 #include <string.h>
 int main(void) {
 // 但凡是涉及到字符串修改的都有函数都带有_s
 ​
     // strcmp;
     //strncmp;
 ​
     const char* str1 = "Hello, world!";
     const char* str2 = "Hello, world!";
     const char* str3 = "Hello, guys!";
 ​
     size_t max_count = 8; // 比较前8个字符
 ​
     if (strncmp(str1, str2, max_count) == 0) {
         printf("Str1 and str2 are equal!\n");   //相同
     }
     else {
         printf("Str1 and str2 are not equal!\n");
     }
     if (strncmp(str1, str3, max_count) == 0) {
         printf("Str1 and str3 are equal!\n");
     }
     else {
         printf("Str1 and str3 are not equal!\n");   //不同
     }
 ​
     return 0;
 }

strchr & strrchr

string chararacter:寻找指定char(从第一个开始)

string reverse char:寻找指定char（从最后一个开始）

得到的char的位置都是从第一个字符开始数

 #include <stdio.h>
 #include <string.h>
 int main(void) {
     const char* str = "Hello, worwlwd!";
 ​
     //strchr()
     //strrchr()
 ​
     char to_find = 'w';
 ​
     char* ptr_char = strchr(str, to_find);
 ​
     char* ptr_reverse_char = strrchr(str, to_find);
 ​
     if (ptr_char) {
         printf("找到了，%c的位置是：%td\n", to_find, ptr_char - str + 1);    //w的位置 -"Hello, world!"首地址 + 数组下标与实际顺序的差值（1） ptrdiff_t
     }
     else {
         printf("没有找到");
     }
 ​
     if (ptr_reverse_char) {
         printf("找到了，从后面找%c的位置是%td\n", to_find, ptr_reverse_char - str+1);
     }
     else {
         printf("没有找到");
     }
 ​
     return 0;
 }

strstr

string string:在一个string中寻找另一个string

 #include <stdio.h>
 #include <string.h>
 int main(void) {
     //strstr
     const char* text = "This is a simple test simple string";   //母字符串
     const char* sub = "simple"; //子字符串 大小写敏感 注意长度不要溢出
         
     char* result = strstr(text, sub);   // 子字符串为" " result值是NULL
 ​
     if (result != NULL) {
         printf("Found %s in %s at position :%td\n", sub, text, result - text + 1);
     }
     else {
         printf("Substring %s not found in %s\n", sub, text);
     }
 ​
     return 0;
 }

strspn & strcspn

string span:字符串前面相同的字符数

 #include <stdio.h>
 #include <string.h>
 int main(void) {
     
     // strcspn()
     const char* str1 = "12345abcdefghi678910";
     const char* str2 = "12345678910";
 ​
     size_t len = strspn(str1, str2);
 ​
     printf("%zu\n", len);
 ​
     return 0;
 }

string compliment span:字符串相同字符之前不同的字符数

 #include <stdio.h>
 #include <string.h>
 int main(void) {
     
     // strcspn()
     const char* str1 = "abcdefg12345";
     const char* str2 = "12345678910";
 ​
     size_t len = strcspn(str1, str2);
 ​
     printf("%zu\n", len);
 ​
     return 0;
 }
 #include <stdio.h>
 #include <string.h>
 int main(void) {
     //验证字符串是否有非法字符
     char input[] = "filename.txt";
 ​
     char invalid_chars[] = "/\\:*?\"<>|";
 ​
     if (strcspn(input, invalid_chars) < strlen(input)) {
         printf("Input contains invalid characters\n");
     }
     else {
         printf("Input is valid\n");
     }
 ​
     return 0;
 }

本章练习

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 ​
 #define TEXT_SIZE 100
 #define WORD_SIZE 50
 #define DELIMS " ,.!?\n"
 ​
 void replaceWord(const char* text, const char* oldWord, const char* newWord, const char* result);
 int countChar(const char* text, char ch);
 int countWords(const char* text);
 void extractUniqueWords(const char* text, char uniqueWords[][WORD_SIZE], int* uniqueCount);
 ​
 int main(void) {
 ​
     char text[TEXT_SIZE] = "This is a simple test.This text is for testing";
 ​
     char replacedText[TEXT_SIZE] = { 0 };
 ​
     char oldWord[] = "test";
 ​
     char newWord[] = "example";
 ​
     char countCharTarget = 's';
 ​
     char uniqueWords[TEXT_SIZE][WORD_SIZE] = { 0 };
 ​
     int uniqueCount = 0;
     // 替换指定单词
     replaceWord(text, oldWord, newWord, replacedText);
     printf("Replaced Text:%s\n", replacedText);
     // 计算特定字母数量
     int charCount = countChar(replacedText, countCharTarget);
     printf("Char %c appears %d times\n", countCharTarget, charCount);
     // 计算特定单词数量
     int wordCount = countWords(replacedText);
     printf("Total number of words :%d\n", wordCount);
     // 提取特定单词
     extractUniqueWords(replacedText, uniqueWords, &uniqueCount);
     puts("Unique words:");
 ​
     for (int i = 0; i < uniqueCount; i++) {
         printf("%s\n", uniqueWords[i]);
 ​
     }
 ​
     return 0;
 }
 void replaceWord(const char* text, const char* oldWord, const char* newWord, const char* result) {
 ​
     char buffer[TEXT_SIZE] = { 0 };
     const char* pos = text;
     const char* temp = text;
     size_t oldLen = strlen(oldWord);
 ​
     while ((temp = strstr(pos, oldWord)) != NULL) {
         strncat_s(buffer, sizeof(buffer), pos, temp - pos);
         strcat_s(buffer, sizeof(buffer), newWord);
         pos = temp + oldLen;
 ​
     }
 ​
     strcat_s(buffer, sizeof(buffer), pos);
     strcpy_s(result, TEXT_SIZE, buffer);
 ​
 }
 int countChar(const char* text, char ch) {
     int count = 0;
     while (*text) {
         if (*text == ch) {
             count++;
         }
         text++;
     }
 ​
 ​
     return count;
 }
 int countWords(const char* text) {
     int count = 0;
     char buffer[TEXT_SIZE] = { 0 };
 ​
     strcpy_s(buffer, TEXT_SIZE, text);
 ​
     char* context = NULL;
 ​
     char token = strtok_s(buffer, DELIMS, &context);
 ​
     while (token != NULL) {
         count++;
         token = strtok_s(NULL, DELIMS, &context);
 ​
 ​
     }
     return count++;
 }
 void extractUniqueWords(const char* text, char uniqueWords[][WORD_SIZE], int* uniqueCount) {
     char tempText[TEXT_SIZE] = { 0 };
     strcpy_s(tempText, TEXT_SIZE, text);
 ​
     char* context = NULL;
     char* token = strtok_s(tempText, DELIMS, &context);
 ​
     while (token != NULL) {
         int found = 0;
 ​
         for (int j = 0; j < *uniqueCount; ++j) {
 ​
             if (strcmp(token, uniqueWords[j]) == 0) {
                 found = 1;
                 break;
             }
 ​
         }
         if (!found) {
             strcpy_s(uniqueWords[*uniqueCount], WORD_SIZE, token);
             (*uniqueCount)++;
         }
         token = strtok_s(NULL, DELIMS, &context);
     }
 ​
 }

[C语言大师：编得狂，骂得响后篇]哔哩哔哩bilibili]

NaclarbCSDN
关注
C语言库函数——string.h
热门推荐
Xa_L
09-01 3万+
在学习C语言的过程中，当使用字符串时，我们会经常使用string.h这个库函数。那么，这个库函数究竟有哪些需要我们学习的，哪些又是我们经常会使用的。string.h是C语言标准库中一个常用的头文件，在使用到字符数组时需要使用。string .h头文件定义了一个变量类型、一个宏和各种操作字符数组的函数。拷贝一个字符串到另一个。...
【c语言】＜string.h＞头文件中所有函数详解
weiweiliude2的专栏
03-22 1万+
c语言最全的string.h头文件中函数详解,包含20个函数的说明和测试使用
C语言标准库介绍：＜string.h＞
一起coding，一起嗨。
02-23 3538
C语言标准库介绍：
C语言string.h函数详解及部分模拟实现
m0_73900674的博客
03-23 9563
一键获取string.h函数解析
C语言标准库——＜string.h＞
TXFBAP的博客
08-30 7877
C语言标准库——
C语言中的字符串操作函数：深入探索string.h头文件
weixin_47712251的博客
08-02 1357
在C语言中，string.h是一个标准头文件，提供了许多用于操作字符串的函数。strlen()函数用于计算字符串的长度，即字符串中非空字符的数量，不包括空字符(’\0’)在内。strcat()函数用于将源字符串追加到目标字符串的末尾，直到遇到空字符(’\0’)为止。strcpy()函数用于将源字符串复制到目标字符串中，直到遇到空字符(’\0’)为止。printf(“字符串”%s"的长度是：%zu\n", str, len);printf(“目标字符串：”%s”\n”, dest);子串: orange。
C语言字符串函数＜string.h＞（部分）
m0_62536353的博客
04-27 3600
string.h库常用函数
＜string.h＞头文件: C 语言字符串处理函数详解
PengXing_Huang的博客
12-23 1483
头文件包含常用函数的详细讲解。
[学习] C语言＜string.h＞中字符串函数全解析
极客不孤独的博客
06-22 1956
C语言<string.h>字符串函数摘要 本文全面解析C标准库<string.h>中的字符串处理函数，提供函数原型说明和实用示例代码。涵盖19个核心函数：strcpy/strncpy（字符串拷贝）、strcat/strncat（字符串拼接）、strcmp/strncmp（字符串比较）、strlen（获取长度）、strchr/strrchr（字符查找）、strstr（子串查找）、strspn/strcspn（前缀匹配计算）以及strpbrk（字符集查找）。每个函数均配有完整可运行的代码
C语言字符串头文件string.h中的strlen，strcat，strcpy，strncpy，strcmp，strlwr，strupr函数
small_is_powerful , small_is_beautiful
08-29 2万+
前言 本博文内容基于VC6.0++， 2.本博文主要介绍包含在string.h中的几个字符串相关的函数； strlen(字符串数组名) 字符串有效长度函数； 功能：用来测量一个字符串的有效长度（所谓有效，就是从字符串中的第一个字符开始，一直到第一个空字符’\0’为止（不包括这个空字符）所占的字节数）； 举例： #include &amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;gt; #include &amp;
C语言字符串string.h详解
微小冷的学习笔记
12-15 9389
网上大部分对C语言标准库的解析都是浓重的机翻风格，可能作者自己都没真正理解。而且机翻也就罢了，关键是原文的风格也很令人抓狂：都是那种新手看了等于没看、老手压根不需要看的那种风格。本文对string.h进行整理，力求详略得当，析其难处而略其易处。
【C语言实战(13)】C语言字符数组与字符串实战：解锁string.h函数的神秘面纱
邓邓子的博客
10-12 1093
本文是 C 语言字符数组与字符串实战系列第二篇，围绕 string.h 库展开。先讲解 strlen（算长度）、strcpy（复制）、strcat（拼接）等函数的原型、功能及使用要点，强调返回值特性与缓冲区安全问题。再通过三类实战案例深化应用：用 strlen 与 strcat 实现拼接并统计长度、strcpy 完成字符串备份修改，用 strcmp 比较字符串，还介绍字符数组操作实现字符串反转、提取指定子串的方法，为开发者提供实用的 C 语言字符串处理指南。
[C语言进阶]字符串与字符函数全解：从 ctype.h 到 string.h，一次搞懂 strlen、strcpy、memcpy 的所有坑！
最新发布
weixin_65182626的博客
11-13 593
本文深入讲解了 C 语言中字符串与字符处理相关的标准库函数，包括字符分类与转换函数（isalpha、isdigit、toupper 等）、字符串长度与内存大小的区别（strlen vs sizeof）、字符串拷贝与拼接（strcpy、strcat）、比较、查找、分割（strtok）、以及内存操作函数（memcpy、memmove、memset 等）。文章以示例和内存图形化方式呈现，结合安全编程建议，帮助读者彻底理解 C 语言字符串的底层原理与最佳实践。
Day 21 C语言基础 字符串 获取字符 ctype.h函数 字符串函数库string.h
qq_59947178的博客
09-05 1442
C语言基础 字符串 获取字符 ctype.h函数 字符串函数库string.h
C语言字符串函数＜string.h＞文件实现
HSS521314的博客
10-13 422
该代码实现了一个完整的字符串处理库String.h，包含25个常用字符串操作函数。主要功能包括：基础操作（字符串长度计算、复制、连接、比较），类型转换（整型/浮点数转字符串、字符串转整型），高级字符串处理（KMP模式匹配算法、字符串反转、动态内存分配），以及可选片段复制等实用功能。其中KMP算法实现了正向/反向匹配、统计匹配次数等功能。所有函数均采用标准C实现，不依赖外部库，具有高效性和可移植性，适用于嵌入式系统等资源受限环境。
string.h库文件下载介绍：C语言字符串操作必备库
gitblog_06734的博客
05-15 782
string.h库文件下载介绍：C语言字符串操作必备库 【下载地址】string.h库文件下载介绍 string.h库文件是C语言标准库中的核心组件，专注于字符串处理操作。它提供了丰富的函数声明，涵盖字符串复制、连接、比较和搜索等常用功能，帮助开发者高效处理文本数据。该文件遵循ANSI标准，兼容性强，适用于各类C语言项目...
【C语言】＜string.h＞中十大字符串函数（用法+模拟实现）
Dear_JIANJIAN的博客
12-04 103
个人认为头文件中常用字符串函数一共有十大，学习完本篇文章，字符串数据处理轻松拿下。零. 贯穿全文的前言关于字符串最重要的知识点： C语言本身是没有字符串类型的，字符串通常放在常量字符串或者字符数组中…【C语言】＜string.h＞中十大字符串函数（用法+模拟实现） - 知乎。
c语言：＜string.h＞头文件中的字符串函数的介绍与用法
qq_34110689的博客
11-08 4249
书接上文，这次我们来讨论一下<string.h>头文件中常用的8个字符串处理函数。 要使用字符串处理函数，首先要包括它们所属的头文件。 #include<string.h> 整行输入输出函数 整行输入函数gets() 用法： gets (字符数组); gets函数表达时，将会从要求键盘输入一串字符，直至遇到换行符’\n’为止；字符串输入后，c语言会将’\0’置于字符串尾部来替代换行符’\n’。 整行输出函数 puts() 用法： puts (字符数组); puts函数表
c语言中的string字符串,C语言 string.h 中的字符串函数
weixin_39922151的博客
05-17 254
C语言标准库头文件 定义了一个变量类型、一个宏和两组字符串函数，一组函数的名字以str开头，还有一组函数的名字以mem开头。1、一个变量类型size_t：无符号整型(unsigned int)，是sizeof操作符返回的结果类型，在64位系统中为 long unsigned int。代码示例运行结果其中，%zu 用来输出 size_t 类型。2、一个宏NULL：空指针常量的值3、以str开头的函...
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(包括
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值