定义
在C语言中，顺序串是一种使用数组来存储字符串的方式。顺序串通常定义为一个字符数组，并使用字符串结束符（'\0'）来标识字符串的结尾。
特点
C语言字符串有以下特点：
-
字符串是以空字符'\0'结尾的。这个空字符的ASCII码为0，用于表示字符串的结束，所以在处理字符串时需要注意这个特点。
-
字符串长度不固定。在定义字符串时，可以使用字符数组来存储字符串，而数组的长度可以根据字符串的实际长度来定义。
-
C语言中没有原生字符串类型，而是通过字符指针来间接实现字符串。也就是说，字符指针指向字符串的起始地址，而字符串在内存中其实就是多个字节连续分布构成的。
总的来说，C语言中的字符串是一个以空字符结尾的字符数组，其长度可以根据实际需要定义，并通过字符指针进行间接管理。
基本运算
C语言顺序字符串的基本运算包括连接、复制、比较、子串等操作。以下是一些基本运算的介绍：
-
连接
两个字符串可以通过连接操作合并成一个字符串。可以使用strcat函数来实现连接操作。 -
复制
一个字符串可以通过复制操作生成另一个相同的字符串。可以使用strcpy函数来实现复制操作。 -
比较
两个字符串可以通过比较操作来判断它们是否相等。可以使用strcmp函数来实现比较操作。 -
子串
一个字符串可以通过子串操作获取另一个字符串的一部分。可以使用strstr函数来实现子串操作。
实现
初始化
- 申请内存空间
- 令长度等于零
int init(sstring *S, int max)
{
S->data = (char*)malloc(sizeof(char)*max);
if(!S->data)
{
printf("申请内存失败！1000");
return 1000;
}
S->max = max;
S->len = 0;
}
从字符常量拷贝
- 定义一个字符指针变量，用于存储字符常量的地址。
- 将字符常量的地址赋给该指针变量。
- 定义一个新的字符数组（用于存放拷贝的字符），并确保其长度等于或大于原始字符常量。
- 在目标字符数组的最后添加 '\0' 结束符。
/*从字符常量拷贝*/
int sstrcpy(sstring *S, char* from)
{
int i;
int len = strlen(from);
if(len>S->max)
{
printf("超出了字符串S的长度！1001\n");
return 1001;
}
for(i=0;i<len;i++)
{
S->data[i] = from[i];
}
S->data[i] = '\0';
S->len = len;
return 0;
}
模式匹配
检查一个主字符串中是否包含一个子字符串 。如果包含，它返回子字符串在主字符串中第一次出现的位置；如果不包含，它返回 -1。
/*模式匹配*/
int sstrmatch(sstring *S, sstring *sub)
{
int i, j, k;
int m = S->len;
int n = sub->len;
for(i=0;i<=m-n;i++)
{
j=0;
k=i;
while(j<n && S->data[k] == sub->data[j])
{
j++;
k++;
}
if(j==n)
{
return i;
}
}
return -1;
}
串长
通过访问成员变量len,可以获得字符串的长度。
//串长
int slength(sstring* str) {
return str->len;
}
串比较
- 首先比较两个字符串的长度。
- 如果长度相等就比较每个字符。
//串比较
int sstring_compare(const sstring* s1, const sstring* s2)
{
int i;
int result;
// 比较两个字符串的长度
if (s1->len < s2->len) {
return -1;
} else if (s1->len > s2->len) {
return 1;
}
// 长度相等，比较每个字符
for (i = 0; i < s1->len; i++) {
if (s1->data[i] < s2->data[i]) {
return -1;
} else if (s1->data[i] > s2->data[i]) {
return 1;
}
}
// 字符串相等
return 0;
}
串拼接
- 先比较两个字符串的和是否大于其中一个的最大长度。
- 使用strcat()函数来拼接两个字符串并获的一个新的字符出。
//串的拼接
void strcat_sstring(sstring* s1, sstring* s2) {
if (s1->len + s2->len > s1->max) {
s1->data = (char*)realloc(s1->data, (s1->len + s2->len + 1) * sizeof(char));
s1->max = s1->len + s2->len + 1;
}
strcat(s1->data + s1->len, s2->data);
s1->len += s2->len;
}
完整代码
代码实现
sstring.h
/*
sstring.h
顺序字符串
*/
typedef struct
{
char* data;
int max;
int len;
}sstring;
/*初始化串*/
int init(sstring *S, int max);
/*从字符常量拷贝*/
int sstrcpy(sstring *S, char* from);
/*模式匹配*/
int sstrmatch(sstring *S, sstring *sub);
//串比较
int sstring_compare(const sstring* s1, const sstring* s2);
//串长
int slength(sstring* str);
//串的拼接
void strcat_sstring(sstring* s1, sstring* s2);
sstring.c
/*
sstring.c
*/
#include "sstring.h"
/*初始化串*/
int init(sstring *S, int max)
{
S->data = (char*)malloc(sizeof(char)*max);
if(!S->data)
{
printf("申请内存失败！1000");
return 1000;
}
S->max = max;
S->len = 0;
}
/*从字符常量拷贝*/
int sstrcpy(sstring *S, char* from)
{
int i;
int len = strlen(from);
if(len>S->max)
{
printf("超出了字符串S的长度！1001\n");
return 1001;
}
for(i=0;i<len;i++)
{
S->data[i] = from[i];
}
S->data[i] = '\0';
S->len = len;
return 0;
}
/*模式匹配*/
int sstrmatch(sstring *S, sstring *sub)
{
int i, j, k;
int m = S->len;
int n = sub->len;
for(i=0;i<=m-n;i++)
{
j=0;
k=i;
while(j<n && S->data[k] == sub->data[j])
{
j++;
k++;
}
if(j==n)
{
return i;
}
}
return -1;
}
//串比较
int sstring_compare(const sstring* s1, const sstring* s2)
{
int i;
int result;
// 比较两个字符串的长度
if (s1->len < s2->len) {
return -1;
} else if (s1->len > s2->len) {
return 1;
}
// 长度相等，比较每个字符
for (i = 0; i < s1->len; i++) {
if (s1->data[i] < s2->data[i]) {
return -1;
} else if (s1->data[i] > s2->data[i]) {
return 1;
}
}
// 字符串相等
return 0;
}
//串长
int slength(sstring* str) {
return str->len;
}
//串的拼接
void strcat_sstring(sstring* s1, sstring* s2) {
if (s1->len + s2->len > s1->max) {
s1->data = (char*)realloc(s1->data, (s1->len + s2->len + 1) * sizeof(char));
s1->max = s1->len + s2->len + 1;
}
strcat(s1->data + s1->len, s2->data);
s1->len += s2->len;
}
main.c
#include <stdio.h>
#include "sstring.h"
#include <string.h>
int main(int argc, char* argv[])
{
sstring S;
sstring sub;
int index;
char str1[100];
char str2[100];
int cmd;
int result;
int i = 0;
int m = 0;
int n = 0;
do
{
printf("-----------串演示-----------\n");
printf(" 1. 初始化\n");
printf(" 2. 输入串\n");
printf(" 3. 从字符常量拷贝\n");
printf(" 4. 模式匹配？\n");
printf(" 5. 串比较\n");
printf(" 6. 串长\n");
printf(" 7. 输出串\n");
printf(" 8. 串的拼接\n");
printf(" 9. 帮助\n");
printf(" 0. 退出\n");
printf(" 请选择（0~9）：");
scanf("%d",&cmd);
switch(cmd){
case 1:
init(&S, 1000);
init(&sub, 100);
printf("初始化成功！\n");
break;
case 2:
printf("请输入主串：");
scanf("%s", str1);
printf("请输入子串：");
scanf("%s", str2);
break;
case 3:
sstrcpy(&S, str1);
sstrcpy(&sub, str2);
printf("从字符常量拷贝已完成！\n");
break;
case 4:
index = sstrmatch(&S,&sub);
if(index>=0)
{
printf("匹配成功，子串在主串的%d位置\n", index);
}
else
{
printf("主串中不存在子串！\n");
}
break;
case 5:
if(sstring_compare(&S,&sub) == 1){
printf("主串的长度大于子串的长度\n");
}else if(sstring_compare(&S,&sub) == -1){
printf("主符串的长度小于子串的长度\n");
}
else if(sstring_compare(&S,&sub) == 0){
printf("两个字符串相等\n");
}
else printf("主串和子串的长度相等但字符不一样\n");
break;
case 6:
printf("主串：%s的长度为：%d\n",str1,slength(&S));
printf("子串：%s的长度为：%d\n",str2,slength(&sub));
break;
case 7:
printf("主串打印：%s,",S.data);
printf("子串打印：%s\n",sub.data);
break;
case 8:
strcat_sstring(&S, &sub);
printf("主串和子串的拼接：%s\n",S.data);
break;
case 9:
printf("本程序为顺序字符串的演示程序，由赵梦琪设计开发！\n");
break;
}
}while(cmd!=0);
return 0;
}
运行截图
总结
串(string)是零个或多个字符组成的有限序列。一般记为:S="a1a2…an"(n≥0)其中S是串的名字,用双引号括起来的字符序列是串的值，但双引号是界限符,它不属于串,其作用是避免与变量名或常量混淆。ai(1≤i≤n)称为串的元素，它可以是任意字母、数字或其他字符，是构成串的基本单位，i是它在整个串中的序号。n是串中字符的个数,称为串的长度，表示串中所包含的字符个数。例如串S1="abcd"，串的每一个元素为一个字母，其长度为4。而S2="12345"，串的每一个元素为一个数字，其长度为5。
因为串是字符型的线性表，所以线性表的存储方式仍适用于串，也因为字符的特殊性和字符串经常作为一个整体来处理的特点，串在存储时还有一些与一般线性表不同之处。
