使用c实现String类型的部分功能

已于 2023-06-01 21:06:34 修改
阅读量99 收藏
点赞数
文章标签： c语言
于 2023-06-01 11:54:59 首次发布
知识人人共享，欢迎阅读
本文链接：https://blog.csdn.net/qq_44692914/article/details/130985478
版权 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>  // 断言库

#pragma warning(disable: 4996)
#define pause system("pause")

// 定义String类型
typedef struct STRING{
	char* data;   // 数据
	int length;   // 实际存储长度
	int capacity; // 容量 = 长度 + 1   字符串有'\0'
} Str;

// malloc  calloc  realloc

/*
当传递给函数的 data 指针 NULL 时，它会分配一个长度为2的字符串 "" 
代替长度为1的字符 '\0'。
这是因为需要一个表示空字符串的字节，
还需要存储表示空字符的 '\0' 字节
*/
// 初始化Str对象数据   initStrByData  // 栈区创建Str结构体变量，data数据在堆区
void initStrByData(Str* str, const char* data) {
	if (NULL == str)
	{
		printf("str is NULL.\n"); // 显示返回
		return;
	}
	if (NULL != str->data && str->capacity >= str->length && str->capacity >= 1 && str->length >= 0) // 如果已经存在数据，就清空释放掉
	{
		free(str->data);
		str->capacity = str->length = 0;
	}

	if (NULL != data)
	{
		str->length = strlen(data);
		str->capacity = str->length + 1;
		str->data = (char*)malloc((str->capacity) * sizeof(char));
		memset(str->data, 0, str->capacity);
		strncpy(str->data, data, str->length);
		str->data[str->length] = '\0'; // 强制设置终止字符，以确保字符串有效 ，其实前面已经清0了
	}
	else
	{
		str->length = 0; //无数据，就当成一个空串""
		str->capacity = 2;
		str->data = (char*)malloc(2 * sizeof(char));
		str->data[0] = '\0';
	}
}

// 初始化Str对象容量   initStrByCapacity
void initStrByCapacity(Str* str, int capacity) {
	if (NULL == str)
	{
		printf("str is NULL.");
		return;
	}  // 有点问题 二次分配data 空间，对于已经有内容的如何处理？
	if (NULL != str->data && str->capacity >= str->length && str->capacity >= 1 && str->length >= 0) // 如果已经存在数据，就清空释放掉
	{
		free(str->data);
		str->capacity = str->length = 0;
	}
	if (capacity <= 0)
	{
		str->capacity = 1;
		str->length = 0; // 实际存储长度
		str->data = (char*)calloc(str->capacity, sizeof(char));
	}
	else
	{
		str->capacity = capacity;
		str->length = 0;
		str->data = (char*)calloc(str->capacity, sizeof(char));
	}
}

// 初始化Str对象容量  //创建于栈区的String     createStrByCapacity
Str* createStrByCapacity(Str** str, int capacity) {
	*str = (Str*)malloc(1 * sizeof(Str)); //申请空间
	initStrByCapacity(*str, capacity);
	return *str;
}

// 初始化Str对象数据  //创建于栈区的String    createStrByData
Str* createStrByData(Str** str, const char* data) {
	*str = (Str*)malloc(1 * sizeof(Str));
	initStrByData(*str, data);
	return *str;
}


// 释放Str对象的data占用的内存
void freeStr(Str* str) {
	if (NULL != str)
	{
		if (NULL != str->data)
		{
			free(str->data);
			str->data = NULL;
		}
		str->capacity = str->length = 0;
	}
}

// 释放Str对象占用的内存
void deleteStr(Str** str) {
	if (NULL != str)
	{
		if (NULL != *str)
		{
			if (NULL != (*str)->data)
			{
				free((*str)->data);
				(*str)->data = NULL;
			}
			(*str)->capacity = (*str)->length = 0;
			*str = NULL;
		}
	}
}


// 获取Str对象的长度
int getStrLength(const Str* str) {
	if (NULL != str){
		return str->length;  
	}
	return -1;
}

// 获取Str对象的容量
int getStrCapacity(const Str* str) {
	if (NULL != str){
		return str->capacity;
	}
	return -1;
}



//注意，返回值应当判断，否则，返回值为-1时，以字符形式输出，其显示可能时未知的。
// 获取Str对象指定位置的字符
char getCharAtIndex(const Str* str, int index) {
	if (NULL != str)
	{
		if (index >= 0 && index < str->length) {
			return str->data[index];
		}
	}
	return -1; // 字符不存在
}

// 输出Str对象的内容  
void printStr(const Str* str) {
	if (NULL != str){
		if (NULL != str->data)
		{
			//printf("%s\n", str->data);
			puts(str->data);
		}
	}
	else
	{
		printf("%s\n","\"NULL\"");
	}
}

// 拼接两个Str对象
Str* concatStr(Str* str1, const Str* str2) {
	if(NULL != str1)
	{
		if (NULL != str2)
		{
			int len1 = str1->length;
			int len2 = str2->length;
			if ((len1 - len2) < (len2 + 1))
			{
				char* tmp = (char*)realloc(str1->data, len1 + len2 + 1);
				if (NULL == tmp) {
					return NULL; // 内存分配失败
				}
				// 重新分配存储空间 
				str1->data = tmp;
			}
			strcat(str1->data, str2->data);
			str1->length = len1 + len2;  // 更新实际长度
			str1->capacity = str1->length + 1;  // 更新容量
			str1->data[len1 + len2] = '\0'; // 防止打印越界
			
		}
		return str1;

	}
	return NULL;

}

// 比较两个Str对象是否相等
int compareStr(const Str* str1, const Str* str2) {
	if (NULL != str1 && NULL != str2)
	{
		if (NULL != str1->data && NULL != str2->data)
		{
			// 为了避免strcmp的返回值造成混淆，定义其返回结果
			int cmp = strcmp(str1->data, str2->data);
			if (cmp == 0) return 0; // str1 == str2
			else if (cmp < 0) return -1; // str1 < str2
			else return 1; // str1 > str2
		}
	}
	return -2;  // 无法比较
	
}

// 截取Str对象的子字符串  
Str* subStr(const Str* str, int startIndex, int length) {   // && 具有短路效果，条件必须全部满足
	if (NULL != str && str->data != NULL && startIndex >= 0 && length >= 0)  
	{
		// 因为 当str->data，没有正确的初始化，strlen函数的结果可能时未知的
		// 好在初始化的时候就已经设置为'\0'结尾，还需判断str->data != NULL就行了
		int strLength = strlen(str->data);  // 和str->length一个效果
		if (startIndex <= strLength && length <= strLength - startIndex)
		{			
			// 可截取长度  length <= strLength - startIndex		
			Str* result = (Str*)malloc(1 * sizeof(Str));
			initStrByCapacity(result, length + 1);  // 为新字符串分配空间
			strncpy(result->data, (str->data) + startIndex, length);  // 复制数据
			result->length = strlen(result->data); // 更新实际长度
			return result;
		}
	}
	return NULL;
}


// 查找字符串中第一次出现指定子字符串的位置
int findSubStr(const Str* str, const char* subStr) {
	if (NULL != str && NULL != subStr)
	{
		// subStr的长度是否大于str，不做校验，因为使用strlen可能会出问题
		char* found = strstr(str->data, subStr);
		if (NULL != found) {
			return found - str->data;
		}
	}
	return -1; // 不存在返回-1
}

// 替换字符串中的指定子字符串
Str* replaceSubStr(Str* str, const char* oldSubStr, const char* newSubStr) {
	if (NULL != str && NULL != oldSubStr && NULL != newSubStr)
	{
		int oldSubStrLen = strlen(oldSubStr);
		int newSubStrLen = strlen(newSubStr);

		// 先搜索old字串是否存在
		char* found = strstr(str->data, oldSubStr);
		if (NULL != found) {
			// todo
			// 首先计算新字符串的长度
			int newStrLen = str->length - oldSubStrLen + newSubStrLen;
			// 然后为新字符串分配内存空间
			char* newStrData = (char*)malloc(newStrLen + 1);
			if (NULL == newStrData) {
				// 内存空间不足
				return NULL;
			}
			// 将基础字符串str前found的部分拷贝至新字符串中
			memcpy(newStrData, str->data, found - str->data);
			// 将newSubStr拷贝到新字符串中
			memcpy(newStrData + (found - str->data), newSubStr, newSubStrLen);
			// 将基础字符串str中oldSubStr末尾的部分拷贝到新字符串中
			memcpy(newStrData + (found - str->data) + newSubStrLen, found + oldSubStrLen, str->length - (found - str->data) - oldSubStrLen);
			// 为新字符串结尾添加'\0'
			newStrData[newStrLen] = '\0';

			// 在释放原字符串内存的前提下，更新str的data，length和capacity
			free(str->data);
			str->data = newStrData;
			str->length = newStrLen;
			str->capacity = newStrLen + 1;

			// 返回更新后的字符串str
			return str;			
		}
	}
	return NULL;
}


// 替换字符串中的指定字符
Str* replaceChar(Str* str, char oldChar, char newChar) {
	if (NULL != str)
	{
		// 循环控制条件为长度，而不是容量，因为处理的是有内容的字符
		for (int i = 0; i < str->length; i++) {
			if (str->data[i] == oldChar) {
				str->data[i] = newChar;
			}
		}
		str->data[str->capacity] = '\0';  // 添加'\0'到新字符串的末尾
		return str;
	}
	return NULL;
}


// 使用 isalpha()函数来检查输入的字符是否为字母，
// 是，使用 toupper() 函数，如果不是，不变。

// 将字符串全部转换为大写
Str* toUpperCase(Str* str) {
	for (int i = 0; i < str->length; i++) {
		if (isalpha(str->data[i])) {  
			str->data[i] = toupper(str->data[i]);
		}
	}
	//str->data[str->length] = '\0';
	return str;
}

// 将字符串转换为小写
Str* toLowerCase(Str* str) {
	for (int i = 0; i < str->length; i++) {
		if (isalpha(str->data[i])) {
			str->data[i] = tolower(str->data[i]);
		}
	}
	str->data[str->length] = '\0';
	return str;
}


// 测试用例
int main(int argc, char* argv[]) {
	
	// 测试创建Str对象
	Str* str = createStrByData(&str,"Hello World!");
	assert(str != NULL); // 断言
	printf("str addr 0x%p\n", str);

	// 测试计算字符串长度
	assert(getStrLength(str) == 12);
	assert(strcmp(str->data, "Hello World!") == 0);

	// 测试删除Str对象
	deleteStr(&str);
	assert(str == NULL);

	// 测试字符串子串截取
	str = createStrByData(&str, "Hello World!");
	Str* substr = subStr(str, 6, 5);
	assert(substr != NULL);
	assert(substr->length == 5);
	assert(strcmp(substr->data, "World") == 0);
	deleteStr(&substr);

	// 测试字符串子串截取（越界）
	substr = subStr(str, 13, 1);
	assert(substr == NULL);

	// 测试字符串子串截取（！）
	substr = subStr(str, 11, 1);
	assert(substr != NULL);
	assert(substr->length != 0);
	deleteStr(&substr);

	// 测试查找子字符串
	int index = findSubStr(str, "World");
	assert(index == 6);

	// 测试查找子字符串（不存在）
	index = findSubStr(str, "Goodbye");
	assert(index == -1);

	// 测试查找子字符串（空字符串）
	index = findSubStr(str, "");
	assert(index == 0);

	// 测试将字符串转换为小写
	initStrByData(str, "HELLO WORLD!");  // 再次初始化str
	toLowerCase(str);
	assert(strcmp(str->data, "hello world!") == 0);

	// 测试替换字符
	replaceChar(str, 'o', 'x');
	assert(strcmp(str->data, "hellx wxrld!") == 0);

	// 测试释放Str对象内存
	deleteStr(&str);         // bug,程序卡死
	printf("del:str add 0x%p\n", str);

	pause;
	return 0;
}
qcon20
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言string类的实现
06-07
C语言 string类的实现。配有C标准库函数原型
[C++]String类的实现
毛佳茗de代码
01-23 1万+
//代码参考C++primer.//String类的实现,清翔兔 06,Jan.#includeusing namespace std; class String{    friend ostream& operatorpublic:    String(const char* str=NULL);                //赋值构造兼默认构造函数(char
string类的模拟实现
弯弯传奇的博客
01-25 284
说明：有些函数返回的是String&amp;amp;（引用），有些是String（值），这取决于返回的对象是函数的局部变量还是全局变量。 String.h #include &amp;lt;string&amp;gt; #include &amp;lt;iostream&amp;gt; #include &amp;lt;assert.h&amp;gt; using namespace std; class String { public: Stri
C++ string类的实现
m0_60447315的博客
08-21 3216
C++ string类实现
c/c++实现string类的重写
Mr_fightingboy的博客
07-27 1108
  实现string类是一道考验c++基础知识的好题，接下来看这样一道题目，顺便了解string类的内部实现 已知string类的原型代码如下，请编写l类string的7个函数： #ifndef STRING_H #define STRING_H #include&lt;iostream&gt; using namespace std; class String { public:     S...
C++string的实现
qq_53558968的博客
07-03 4099
文章目录前言一、string类的特点二、string类的常用接口2.1 4大默认成员函数2.2 容量操作：2.3 string类对象的访问及遍历操作2.4 string类对象的修改操作2.5 判断的接口2.6 string类非成员函数三、string类的实现3.1 考虑成员变量该有什么3.1.1 为什么使用size_t3.2 4大默认成员函数的实现3.2.1 几个错误&&深浅拷贝3.2.2 拷贝构造和赋值现代写法3.2.3 C++11 noexcept， 移动构造和移动赋值3.
Redis数据结构：String类型全面解析
栗筝i的博客
08-21 3253
Redis，作为一个开源的、内存中的数据结构存储系统，以其出色的性能和灵活的数据类型，广泛应用于缓存、消息队列、发布订阅系统等多种场景。在 Redis 的五种基本数据类型中， String 类型是最基本也是最常用的一种。它不仅可以存储字符串，还可以存储整数和浮点数，甚至可以执行原子操作，如自增和自减。这使得 Redis 的 String 类型在实际应用中有着广泛的用途，从简单的键值对存储，到复杂的实时系统，都离不开 String 类型的支持。
string_DBS.rar_string c++ 实现_visual c
09-21
首先，让我们来看标题"string_DBS.rar_string c++ 实现_visual c"，这表明我们将使用C++语言，特别是关注字符串的实现，而且是在Visual C++的环境下进行。"DBS"可能是"数据库系统"（Database System）的缩写，暗示...
JavaScript中使用webuploader实现上传视频功能(demo)
11-28
在JavaScript中，使用WebUploader库实现上传视频功能与上传图片的功能在原理上是相同的，都是通过浏览器提供的API来实现文件的选取、传输和处理。WebUploader是一个轻量级且功能强大的上传组件，它允许开发者自定义...
c_cPP_log.rar_log c实现
09-23
本文将深入探讨如何使用C++语言来实现一个基本的日志模块，展示日志的显示和保存功能。 首先，我们需要理解日志的基本概念。日志是程序运行过程中的事件记录，通常包括时间戳、事件级别（如信息、警告、错误）以及...
string函数实现
07-12
总的来说，`string`函数实现是编程基础中的重要组成部分，无论是C语言的`strlen`等函数，还是C++的`std::string`类，都为我们处理字符串提供了强大的工具。理解并熟练掌握这些函数和类的用法，对于编写高效、安全的...
C-源码(包括stdio,stdlib和string三大部分)
10-12
C语言是一种广泛使用的编程语言，它的标准库是其核心组成部分，为程序员提供了丰富的函数和功能。在提供的信息中，我们关注的是"stdio", "stdlib", 和 "string" 这三个关键部分，它们分别是C语言标准输入输出、内存...
C++string类的实现
热门推荐
编程鸟
09-04 1万+
C++中提供了一种新的数据类型——字符串类型(string)。实际上string并不是C++的基本类型，它是在C++标准库中声明的一个字符串类，用这种数据类型可以定义对象，每一个字符串变量都是string类的一个对象。标准库类型string表示可变长的字符序列，使用string类型必须首先包含它的头文件。 作为标准库的一部分，string定义在命名空间std中。 【例】#include<str
C/C++string类的实现
无香花自开
12-16 933
#include #include #include #include using namespace std; int mystrlen(const char* p); char* mystrcpy(char* dest, const char* src); class MyString { private: char* m_pData; public: MyString(ch
x264 编码器 CAVLC 熵编码原理分析：cavlc_block_residual_internal函数
人生只有一次，不妨大胆一点～～
07-22 372
x264 编码器 CAVLC 熵编码原理分析：cavlc_block_residual_internal函数
C语言 之 理解指针（3）
fallzzzzz的博客
07-21 1094
本章主要内容是对数组名的理解、使⽤指针访问数组、⼀维数组传参的本质、⼆级指针、指针数组、指针数组模拟⼆维数组
C 观察者模式 Demo
最新发布
我要出家当道士
07-24 323
本文简单介绍了观察者模式，并提供了 C Demo
C语言——字符串中sizeof和strlen的辨析
weixin_45720999的博客
07-19 435
在C语言中，sizeof 和 strlen 函数在处理字符串时有明显不同的作用和结果。使用不当很容易出现错误......
C/C++与Java实现DES加密算法示例与操作指导
1. 导入必要的库，如`stdio.h`、`stdlib.h`和`string.h`，这些库提供了基本的输入输出和字符串处理功能。 2. 定义一个函数来处理密钥管理和加密/解密操作，这部分可能涉及DES的子函数，例如`des_encrypt()`和`des_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值