简介
字符串是一种非常重要的数据类型，但是C语言不存在显式的字符串类型，C语言中的字符串都以字符串常量的形式出现或存储在字符数组中。同时，C 语言提供了一系列库函数来对操作字符串，这些库函数都包含在头文件 string.h 中。
一、字符串常量和字符数组
1.1、什么是字符串常量
C 语言虽然没有字符串类型，但是 C语言提是存在字符串这个概念的，也就是字符串常量：以 NUL 字节结尾的 0 个或多个字符组成的序列。字符串常量是不可被修改的，一般用一对双引号(" ")括起的一串字符来表示字符串常量，如：
“Hello!”、"\aWarning!\a"、“123abc\n”、""
字符串常量可以为空，如""就是一个空的字符串常量，但是即使为空，还是存在一个终止符 NUL 的。（在 C 语言中，常用转义字符 \0 来表示 NUL）
1.2、字符串常量与指针
字符串常量与指针关系密切，因为字符串常量的值，实际上表示的是存储这些字符的内存空间的地址，更准确地说是字符串常量中第 1 个字符的地址，而不是这些字符本身。因此，在 C 语言中是不能直接进行字符串赋值的（因为没有字符串类型嘛）。在 C 语言中，常通过声明一个指向 char 类型的指针并将其初始化为一个字符串常量的方式来访问一个字符串：
char *message = "Hello World!";
// 上面的语句也可以拆分成下面两句
char *message;
message = "Hello World!"; // 这句话看起来像是字符串复制，其实不是，只是涉及到指针操作
上述语句声明了一个指向 char 类型的指针，并用字符串常量中第 1 个字符的地址对该指针进行初始化。可以通过字符指针 message 来访问字符串常量：
#include <stdio.h>
int main()
{
char *message = "Hello World!";
printf("%s\n",message);
while(*message != '\0'){
printf("%c ",*message++);
}
printf("\n");
return 0;
}
/* output:
* Hello World!
* H e l l o W o r l d !
*/
这段代码，使用字符指针遍历了字符串常量中的每一个字符。
1.3、字符数组
用于存放字符的数组称为字符数组。在 C 语言中，除了字符串常量外，其他所有字符串都必须存储于字符数组或动态分配的内存中。定义一个字符数组和定义一个普通数组一样，不同的是字符数组中存放的是字符数据而已：
char charArray[] = {‘H’,‘e’,‘l’,‘l’,‘o’}; // 声明并初始化一个字符数组
这句话定义并初始化了一个字符数组 charArray。这个数组的长度实际上为 6 ，因为会自动添加一个字符串结束符 ‘\0’。
C 语言提供了一种更简洁的方法来对字符数组进行初始化：
char charArray[] = “Hello World!”; // 声明并初始化一个字符数组
上述两种声明方式等价。
可以对一个字符数组做出修改：
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "hello world!";
int len = strlen(str);
int i;
for(i = 0; i < len; i++){
if( str[i] <= 'z' && str[i] >= 'a'){
str[i] = str[i] - 32;
}
}
printf("%s\n",str);
}
这段代码可以将字符数组中的小写字母转换成大写字母后输出。
1.4、 字符串常量与字符数组的区别
1）字符串常量是一个字符数组，但是内容和长度在初始化时就已经固定了，不可更改；可以通过一个指向字符串常量第一个元素的指针来访问该字符串常量；
2）字符数组是一个用于存放字符的数组，字符数组的值是可以更改的
二、获取字符串长度
字符串的长度就是这个字符串所包含字符的个数，但是这个长度是不包含 NUL 字符的。C 语言中使用库函数 strlen 来计算字符串长度：
size_t strlen(char const *string);
需要注意的是 strlen 的返回值类型：size_t 类型，这是一个无符号整数类型。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char str1[] = "Hello World!";
printf("%d\n",strlen(str1));
return 0;
}
/* output:
* 12
*/
三、复制字符串
C 语言中使用库函数 strcpy 来进行字符串复制操作：
char *strcpy(char *dst , char const *src);
函数 strcpy 接收两个字符串参数，并将参数 src 字符串复制到 dst 参数。使用 strcpy 函数时需要注意的是，必须保证目标字符数组 dst 的长度足够存放源字符数组 src 的内容。如果 src 比 dst 长，则 src 剩余部分的字符仍会被复制，而且它们会覆盖 dst 后面的内存空间的值，如果这除内存空间原本就存放有值，则会导致原本的数据丢失，这样会造成很严重的后果。为了解决这个问题， C 语言中提供了一种更为安全的方式来进行字符串复制操作——strncpy 函数：
char *strncpy(char *dst , char const *src , size_t len);
strncpy 函数有三个参数，与 strcpy 函数一样，它也是将 src 字符串中的字符复制到目标数组 dst 中去，但是 strncpy 函数提供的第三个参数 len 规定了可以向 dst 中写入的字符的个数：
1）如果 strlen(src) > len，则只有 len 个字符被复制到 dst 中去，此时 dst 将不会以 NUL 字节结尾（也就是说，strncpy 调用的结果可能不是一个字符串）；
2）如果 strlen(src) < len，则 src 中的字符全被复制到 dst 中去，dst 中剩余的部分用 NUL 填充。
四、连接字符串
C 语言中使用库函数 strcat 来连接两个字符串：
char *strcat(char *dst,char const *src);
函数 strcat 将参数 src 字符串连接到参数 dst 字符串的后面。与 strcpy 函数一个同样的问题是，必须保证 dst 的剩余空间足够存放下 src 整个字符串。C 语言中提供了 strncat 函数来解决这个问题：
char *strncat(char *dst , char const *src , size_t len);
strncat 函数从 src 中最多复制 len 个字符到目标数组 dst 后面，并且，strncat 总是在结果字符串后面添加一个 NUL 字节，而且不会像 strncpy 函数那样对 dst 剩余的空间用 NUL 进行填充。
五、字符串比较
C 语言中使用库函数 strcmp 来进行字符串比较。strcmp 函数会对被比较的两个字符串进行逐字符地比较，直到发现不匹配为止：最先不匹配的字符中较小的那个字符所对应的字符串即被认为小于另一个字符串；如果两者所有字符都匹配，则认为这两个字符串相等；
int strcmp(char const *s1 , char sonst *s2);`
该函数的返回值如下：
1）s1 小于 s2，返回一个负值；
2）s1 等于 s2，返回 0；
3）s1 大于 s2，返回一个正值。
char *strncmp(char const *s1 , char const *s2 , size_t len);
可以使用 strncmp 函数限定比较的字符的个数，返回值与 strcmp 一样，但是只针对前 len 个字符进行比较。
六、字符串的查找
6.1 查找一个字符
可以使用 strchr 函数或 strrchr 函数来在一个字符串中查找一个特定的字符：
char *strchr(char const *str,int ch); // int ch 是字符的ASCII码值
char *strrchr(char const *str,int ch);
函数 strchr 在字符串 str 中查找字符 ch 第一次出现的位置，并返回一个指向该位置的指针；如果没有找到相应的字符，则返回一个 NULL 指针。函数 strrchr 在字符串中查找字符 ch 最后一次出现的位置，并返回指向该位置的指针
6.2 查找任意几个字符
可以使用 strpbrk 函数来查找任何一组字符第一次在字符串中出现的位置：
char *strpbrk(char const *str , char const *group);
这个函数返回一个指向字符串 str 中第一个匹配 group 中任何一个字符的字符位置，如果没有匹配到，则返回一个 NULL 指针。
6.3 查找一个子串
可以使用 strstr 函数来在一个字符串中查找一个子串：
char *strstr(char const *str1 , char const *str2);
这个函数在 str1 中查找整个字符串 str2 第一次出现的起始位置，并返回一个指向该位置的指针；如果 str2 并没有完整的出现在 str1 中，则函数将返回一个 NULL 指针；如果 str2 是一个空字符串，则返回str1.
七、字符串去重
#include <stdio.h>
void killsame(char *o, char *n)
{
int i=0, j, k=0;
int label;
while(o[i] != '\0')
{
label = 1;
for(j=0; j<i; j++)
{
if (o[i] == n[j])
label = 0; //一旦相同标志位置0
}
if(label) // 不相等
n[k++]=o[i];
i++;
}
n[k]='\0'; //结尾给\0
puts(n); //输出
}
int main(void)
{
printf("Please input a string you want:\n");
char old[126];
char new[126];
scanf("%s",old);
killsame(old, new);//去重
return 0;
}
八、字符串倒序
inverted_order(char *p)
{
char *s1,*s2,tem;
s1=p;
s2=s1+strlen(p)-1;
while(s1<s2)
{
tem=*s1;
*s1=*s2;
*s2=tem;
s1++;
s2--;
}
}
特殊要求比如
1无空格字符构成一个单词。
2输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
3如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define IN 1
#define OUT 0
void reverse(char *start, char *end) {
while (start <= end) {
int t = *start;
*start = *end;
*end = t;
start += 1;
end -= 1;
}
}
void reverse_word(char *s) {
int flag = OUT;
char *word_start = NULL;
char *end = s + strlen(s) - 1;
while (s <= end) {
if (!isalnum(*s) && flag == IN) {
reverse(word_start, s - 1);
flag = OUT;
} else if (isalnum(*s) && flag == OUT) {
flag = IN;
word_start = s;
}
s += 1;
}
if (flag == IN) {
reverse(word_start, end);
}
}
void filling_space(char *s) {
int flag = OUT;
int i = 0;
int j = 0;
int len = strlen(s);
for (i = 0; i < len; i++) {
if (isalnum(s[i]) && flag == OUT) {
s[j++] = s[i];
flag = IN;
} else if (isalnum(s[i]) && flag == IN) {
s[j++] = s[i];
} else if (!isalnum(s[i]) && flag == IN) {
s[j++] = s[i];
flag = OUT;
}
}
s[j] = 0;
}
int main(int argc, char *argv[]) {
char s[100] = "";
printf("Enter character: ");
fgets(s, sizeof(s), stdin);
s[strlen(s) - 1] = 0;
reverse(s, s + strlen(s) - 1);
reverse_word(s);
filling_space(s);
printf("%s\n", s);
return EXIT_SUCCESS;
}
普通c++
C++
class Solution {
public:
string reverseWords(string s) {
// 反转整个字符串
reverse(s.begin(), s.end());
int n = s.size();
int idx = 0;
for (int start = 0; start < n; ++start) {
if (s[start] != ' ') {
// 填一个空白字符然后将idx移动到下一个单词的开头位置
if (idx != 0) s[idx++] = ' ';
// 循环遍历至单词的末尾
int end = start;
while (end < n && s[end] != ' ') s[idx++] = s[end++];
// 反转整个单词
reverse(s.begin() + idx - (end - start), s.begin() + idx);
// 更新start，去找下一个单词
start = end;
}
}
s.erase(s.begin() + idx, s.end());
return s;
}
};
九、字符串提取空格
int countSegments(char * s){
int cnt = 0;
while (*s) {
if (*s != ' ' && (*(s + 1) == ' ' || *(s + 1) == '\0'))
cnt++;
s++;
}
return cnt;
}
十、字符串判断回文
//该代码使用Microsoft Visual Studio2019编写
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int fun(const char* p)
{
int i;
int len = strlen(p);
for (i = 0; i <= len; i++) {
if (p[i] == p[len -1])
len--;
else
return 0;
}
return 1;
}
int main(void)
{
char x[100];
gets(x);
char* p=x;
int n=fun(p);
if (n==1)
printf("是回文串");
else if(n==0)
printf("不是回文串");
return 0;
}
十一、字符串匹配并返回字符串
//string match function
char *matchString(const char* buf, const char* sub) {
char* tbuf = buf;
char* tsub = sub;
int i = 0;//tbuf 主串的元素下标位置，从下标0开始找，可以通过变量进行设置，从其他下标开始找！
int j = 0;//tsub 子串的元素下标位置
while (i <= strlen(tbuf ) - 1 && j <= strlen(tsub )-1)
{
//字符相等，则继续匹配下一个字符
if (tbuf [i] == tsub [j])
{
i++;
j++;
}
//在匹配过程中发现有一个字符和子串中的不等，马上回退到 下一个要匹配的位置
else
{
i = i - j + 1;
j = 0;
}
}
//循环完了后j的值等于strlen(tsub) 子串中的字符已经在主串中都连续匹配到了
if (j == strlen(tsub))
{
return tsub;
}
return NULL;
}
十二、把字符串里个别符号提前
#include <stdio.h>
//把字符串中*全部移到字符串的头部
void moveCharToHead(char *str)
{
if(str == NULL)
return ;
char *pString = str;
char *tmp = NULL;
while(*pString != '\0')
{
if(*pString == '*')
{
tmp = pString;
while(tmp > str)
{
*tmp = *(tmp - 1);
tmp --;
}
*tmp = '*';
str ++;
}
pString ++;
}
}
int main()
{
char str[] = "*th*an*k* yo*u *v*er*y* m**uc*h !";
int len = sizeof(str) / sizeof(char);
moveCharToHead(str);
printf("%s\n",str);
}
4248
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
