c++ string的简单实现

最新推荐文章于 2025-12-02 18:24:55 发布
最新推荐文章于 2025-12-02 18:24:55 发布 · 96 阅读 · 0
文章标签：

#c/c++

本文详细介绍了C++标准中string类的简单实现，包括构造函数、赋值运算符、比较运算符、拼接运算符以及访问字符串元素等功能。

c++标准中的string采用模板实现，扩展性比较好；下面的代码简单实现了string类。


/*
 *  CCString.h
 *  c++_common_codes
 *
 *  Created by xichen on 12-1-11.
 *  Copyright 2012 cc_team. All rights reserved.
 *
*/

#ifndef CC_STRING_BASE_H
#define CC_STRING_BASE_H

// #include "ccIOBase.h"
#include <iostream>

using namespace std;

class CCString
{
public:
	CCString();
	~CCString();

	CCString(const CCString & newStr);
	CCString(const char * charStr);
	
public:
	CCString &operator=(const CCString & newStr);
	CCString &operator=(const char * newStr);

public:
	friend bool operator==(const CCString &leftStr, const CCString &rightStr);
	friend bool operator==(const CCString &leftStr, const char *rightCharStr);
	friend bool operator==(const char *leftCharStr, const CCString &rightStr);
	
	friend bool operator!=(const CCString &leftStr, const CCString &rightStr);
	friend bool operator!=(const CCString &leftStr, const char *rightCharStr);
	friend bool operator!=(const char *leftCharStr, const CCString &rightStr);
	
	friend bool operator>(const CCString &leftStr, const CCString &rightStr);
	friend bool operator>(const CCString &leftStr, const char *rightCharStr);

	friend bool operator<(const CCString &leftStr, const CCString &rightStr);
	friend bool operator<(const CCString &leftStr, const char *rightCharStr);

	friend bool operator>=(const CCString &leftStr, const CCString &rightStr);
	friend bool operator>=(const CCString &leftStr, const char *rightCharStr);

	friend bool operator<=(const CCString &leftStr, const CCString &rightStr);
	friend bool operator<=(const CCString &leftStr, const char *rightCharStr);

public:
	friend CCString operator+(const CCString &leftStr, const CCString &rightStr);
	friend CCString operator+(const CCString &leftStr, const char *rightCharStr);

	CCString & operator+=(const CCString &newStr);
	CCString & operator+=(const char *rightCharStr);

public:
	friend ostream & operator<<(ostream & os, const CCString & ccStr);
	friend istream & operator>>(istream & is, CCString & ccStr);

public:
	char	& operator[](int index);
	const char &operator[](int index) const;
	operator char * ();

public:
	char	* pointer() const;
	char	* c_str() const;
	int		length() const;
	bool	empty() const;

private:
	char	*str;
	int		len;
};

#endif

/*
 *  CCString.cpp
 *  c++_common_codes
 *
 *  Created by xichen on 12-1-11.
 *  Copyright 2012 cc_team. All rights reserved.
 *
*/

#include "ccStringBase.h"
#include <cstring>

CCString::CCString()
{
	str = new char[1];
	str[0] = '\0';
	len = 0;
}

CCString::CCString( const CCString &newStr )
{
	if(this == &newStr)
	{
		return;
	}

	int newStrLen = newStr.length();
	str = new char[newStrLen + 1];
	::memcpy(str, newStr.pointer(), newStrLen);
	str[newStrLen] = '\0';
	len = newStrLen;
}

CCString::CCString( const char * charStr )
{
	int newStrLen = strlen(charStr);
	str = new char[newStrLen + 1];
	::memcpy(str, charStr, newStrLen);
	str[newStrLen] = '\0';
	len = newStrLen;
}

CCString::~CCString()
{
	delete []str;
}

CCString & CCString::operator=( const CCString &newStr )
{
	if(this == &newStr)
		return *this;

	delete str;
	int newStrLen = newStr.length();
	str = new char[newStrLen + 1];
	::memcpy(str, newStr.pointer(), newStrLen);
	str[newStrLen] = '\0';
	len = newStrLen;
	return *this;
}

CCString & CCString::operator=(const char *newStr)
{
	delete str;
	int newStrLen = ::strlen(newStr);
	str = new char[newStrLen + 1];
	::memcpy(str, newStr, newStrLen);
	str[newStrLen] = '\0';
	len = newStrLen;
	return *this;
}

char	* CCString::pointer() const
{
	return str;
}

int CCString::length() const
{
	return len;
}

CCString & CCString::operator+=( const CCString &newStr )
{
	int newStrLen = newStr.length();
	if(newStrLen > 0)
	{
		int currStrNewLen = len + newStrLen;
		char * newCharStr = new char[currStrNewLen + 1];
		if(newCharStr)
		{
			strcpy(newCharStr, str);
			strcat(newCharStr, newStr.pointer());
			
			delete str;
			str = newCharStr;
			len = currStrNewLen;
		}
		else
		{
			throw "NoEnoughMemoryException";
		}
	}
	return *this;
}

CCString & CCString::operator+=( const char *rightCharStr )
{
	int newStrLen = strlen(rightCharStr);
	if(newStrLen > 0)
	{
		int currStrNewLen = len + newStrLen;
		char * newCharStr = new char[currStrNewLen + 1];
		if(newCharStr)
		{
			strcpy(newCharStr, str);
			strcat(newCharStr, rightCharStr);

			delete str;
			str = newCharStr;
			len = currStrNewLen;
		}
		else
		{
			throw "NoEnoughMemoryException";
		}
	}
	return *this;
}

char & CCString::operator[]( int index )
{
	return str[index];
}

const char & CCString::operator[]( int index ) const
{
	return str[index];
}

CCString::operator char * ()
{
	return str;
}

char	* CCString::c_str() const
{
	return str;
}

bool CCString::empty() const
{
	return (len == 0);
}

bool operator==( const CCString &leftStr, const CCString &rightStr )
{
	if(leftStr.pointer() == rightStr.pointer())
		return true;
	return (!strcmp(leftStr.pointer(), rightStr.pointer()));
}

bool operator==( const CCString &leftStr, const char *rightCharStr )
{
	if(leftStr.pointer() == rightCharStr)
		return true;
	return (!strcmp(leftStr.pointer(), rightCharStr));
}

bool operator==(const char *leftCharStr, const CCString &rightStr)
{
	return operator==(rightStr, leftCharStr);
}

bool operator!=( const CCString &leftStr, const CCString &rightStr )
{
	return !(operator==(leftStr, rightStr));
}

bool operator!=( const CCString &leftStr, const char *rightCharStr )
{
	return !(operator==(leftStr, rightCharStr));
}

bool operator!=( const char *leftCharStr, const CCString &rightStr)
{
	return !(operator==(rightStr, leftCharStr));
}

bool operator>( const CCString &leftStr, const CCString &rightStr )
{
	if(leftStr.pointer() == rightStr.pointer())
		return false;
	return (strcmp(leftStr.pointer(), rightStr.pointer()) > 0);
}


bool operator>( const CCString &leftStr, const char *rightCharStr )
{
	if(leftStr.pointer() == rightCharStr)
		return false;
	return (strcmp(leftStr.pointer(), rightCharStr) > 0);
}


bool operator<( const CCString &leftStr, const CCString &rightStr )
{
	if(leftStr.pointer() == rightStr.pointer())
		return false;
	return (strcmp(leftStr.pointer(), rightStr.pointer()) < 0);
}


bool operator<( const CCString &leftStr, const char *rightCharStr )
{
	if(leftStr.pointer() == rightCharStr)
		return false;
	return (strcmp(leftStr.pointer(), rightCharStr) < 0);
}


bool operator>=( const CCString &leftStr, const CCString &rightStr )
{
	if(leftStr.pointer() == rightStr.pointer())
		return true;
	return (strcmp(leftStr.pointer(), rightStr.pointer()) >= 0);
}


bool operator>=( const CCString &leftStr, const char *rightCharStr )
{
	if(leftStr.pointer() == rightCharStr)
		return true;
	return (strcmp(leftStr.pointer(), rightCharStr) >= 0);
}


bool operator<=( const CCString &leftStr, const CCString &rightStr )
{
	if(leftStr.pointer() == rightStr.pointer())
		return true;
	return (strcmp(leftStr.pointer(), rightStr.pointer()) <= 0);
}


bool operator<=( const CCString &leftStr, const char *rightCharStr )
{
	if(leftStr.pointer() == rightCharStr)
		return true;
	return (strcmp(leftStr.pointer(), rightCharStr) <= 0);
}


CCString operator+( const CCString &leftStr, const CCString &rightStr )
{
	int leftStrLen = leftStr.length();
	int rightStrLen = rightStr.length();
	CCString str;

	char * newCharStr = new char[leftStrLen + rightStrLen + 1];
	if(newCharStr)
	{
		strcpy(newCharStr, leftStr.pointer());
		strcat(newCharStr, rightStr.pointer());
		str = newCharStr;
		delete []newCharStr;
		return str;
	}
	else
	{
		throw "NoEnoughMemoryException";
	}
}


CCString operator+( const CCString &leftStr, const char *rightCharStr )
{
	int leftStrLen = leftStr.length();
	int rightStrLen = strlen(rightCharStr);
	CCString str;

	char * newCharStr = new char[leftStrLen + rightStrLen + 1];
	if(newCharStr)
	{
		strcpy(newCharStr, leftStr.pointer());
		strcat(newCharStr, rightCharStr);
		str = newCharStr;
		delete []newCharStr;
		return str;
	}
	else
	{
		throw "NoEnoughMemoryException";
	}
}

ostream & operator<<( ostream & os, const CCString & ccStr )
{
	os << ccStr.str;
	return os;
}


istream & operator>>( istream & is, CCString & ccStr )
{
	ccStr.str = new char[128];		// I am sorry, but I don't know the exact buffer size, 128 is just thought just now.
	is >> ccStr.str;
	ccStr.len = strlen(ccStr.str);

	return is;
}

简单测试代码：

#include "ccTestStringBase.h"


void ccTestStringBase()
{
#if 1 || ENABLE_ALL_TEST	// CCString
	CCString str;
	//COUT_LINE(str.pointer())
	//COUT_LINE(str.length())
	CC_ASSERT_EQUAL(str, "", "Not equal");
	CC_ASSERT_EQUAL(str.length(), 0, "Not equal");

	str = "xichen";
	//COUT_LINE(str.pointer())
	//COUT_LINE(str.length())
	CC_ASSERT_EQUAL(str, "xichen", "Not equal");
	CC_ASSERT_EQUAL(str.length(), strlen("xichen"), "Not equal");

	CCString str1 = str;
	//COUT_LINE(str1.pointer())
	CC_ASSERT_EQUAL(str1, "xichen", "Not equal");

	/*
	COUT_LINE(str == str1)
	COUT_LINE(str != str1)
	COUT_LINE(str == "xichen2")
	COUT_LINE(str != "xichen2")

	COUT_LINE(str > str1)
	COUT_LINE(str < str1)
	COUT_LINE(str >= str1)
	COUT_LINE(str <= str1)
	COUT_LINE(str > "xichen2")
	COUT_LINE(str < "xichen2")
	COUT_LINE(str >= "xichen2")
	COUT_LINE(str <= "xichen2")
	*/

	CC_ASSERT(str == str1, "Not right");
	CC_ASSERT_EQUAL(str != str1, 0, "Not right");
	CC_ASSERT_EQUAL(str == "xichen2", 0, "Not right");
	CC_ASSERT_EQUAL(str != "xichen2", 1, "Not right");
	CC_ASSERT_EQUAL(str > str1, 0, "Not right");
	CC_ASSERT_EQUAL(str < str1, 0, "Not right");
	CC_ASSERT_EQUAL(str >= str1, 1, "Not right");
	CC_ASSERT_EQUAL(str <= str1, 1, "Not right");
	CC_ASSERT_EQUAL(str > "xichen2", 0, "Not right");
	CC_ASSERT_EQUAL(str < "xichen2", 1, "Not right");
	CC_ASSERT_EQUAL(str >= "xichen2", 0, "Not right");
	CC_ASSERT_EQUAL(str <= "xichen2", 1, "Not right");

	
	CCString str2 = str + str1;
	//COUT_LINE(str2.pointer())
	CC_ASSERT_EQUAL(str2, "xichenxichen", "Not right");
	CC_ASSERT_EQUAL("xichenxichen", str2, "Not right");
	CC_ASSERT_EQUAL("xichenxichen" == str2, 1, "Not equal");
	
	str2 = str2 + " xuchen";
	//COUT_LINE(str2.pointer())
	CC_ASSERT_EQUAL(str2, "xichenxichen xuchen", "Not right");

	str2 += "ok";
	//COUT_LINE(str2.pointer())
	CC_ASSERT_EQUAL(str2, "xichenxichen xuchenok", "Not right");
	
	str2 += str;
	//COUT_LINE(str2.pointer())
	CC_ASSERT_EQUAL(str2, "xichenxichen xuchenokxichen", "Not right");

	//CC_ASSERT(1 == 2, "Not right");

	CCString str3;
	// cin >> str3;
	// COUT_LINE(str3)

	CC_ASSERT(str[2] == 'c', "not right");
	str[2] = 'd';
	CC_ASSERT(str[2] == 'd', "not right");

	// COUT_LINE((char *)str2)

	CC_ASSERT(str.empty() != true, "not right");
	CC_ASSERT(str3.empty() == true, "not right");
#endif
}



CC_ASSERT和CC_ASSERT_EQUAL宏定义为：

#ifdef _WINDOWS
#define CC_ASSERT(var, msg)	\
{	\
	CCString strTemp19870814_neverUsed;	\
	char line[32] = {0};	\
	strTemp19870814_neverUsed += __FILE__, strTemp19870814_neverUsed += " Line:", itoa(__LINE__, line, 10), strTemp19870814_neverUsed += line;	\
	if(!(var))	COUT_2_VAR_ENDL(strTemp19870814_neverUsed.pointer(), (msg))	\
	else				COUT_LINE("OK!")	\
}

#define CC_ASSERT_EQUAL(var1, var2, msg)	\
	{	\
		CCString strTemp19870814_neverUsed;	\
		char line[32] = {0};	\
		strTemp19870814_neverUsed += __FILE__, strTemp19870814_neverUsed += " Line:", itoa(__LINE__, line, 10), strTemp19870814_neverUsed += line;	\
		if((var1) != (var2))	COUT_2_VAR_ENDL(strTemp19870814_neverUsed.pointer(), (msg))	\
		else				COUT_LINE("OK!")	\
	}

#else
#define CC_ASSERT(var, msg)	\
{	\
	CCString strTemp19870814_neverUsed;	\
	char line[32] = {0};	\
	strTemp19870814_neverUsed += __FILE__, strTemp19870814_neverUsed += " Line:", sprintf(line, "%d",__LINE__), strTemp19870814_neverUsed += line;	\
	if(!(var))	COUT_2_VAR_ENDL(strTemp19870814_neverUsed.pointer(), (msg))	\
	else				COUT_LINE("OK!")	\
}

#define CC_ASSERT_EQUAL(var1, var2, msg)	\
{	\
CCString strTemp19870814_neverUsed;	\
char line[32] = {0};	\
strTemp19870814_neverUsed += __FILE__, strTemp19870814_neverUsed += " Line:", sprintf(line, "%d",__LINE__), strTemp19870814_neverUsed += line;	\
if((var1) != (var2))	COUT_2_VAR_ENDL(strTemp19870814_neverUsed.pointer(), (msg))	\
else				COUT_LINE("OK!")	\
}
#endif

COUT_LINE宏定义为：

#define COUT_LINE(str)		std::cout << (str) << std::endl;

注：欢迎提出代码中的问题，不甚感激；


iteye_6233
关注
C++STL string简单实现
MindbniM的博客
08-18 1385
std::string是C++标准模板库中的一个类，用于处理字符串。与C语言的字符串相比，std::string 提供了更强大的功能和更安全的操作, 这次我们来简单实现一下
C++ String类的简单实现
m0_57234892的博客
03-08 2815
在之前c语言的学习中，对于字符串我们很难像整型和其他变量那样进行比较和直接的复制或者定义去运用。但在C++中为了解决这个问题提供了一种类，String类，以类型的形式对字符串进行封装，它除了作为储存字符的容器外，可以对字序列的一系列操作。 下面我们对String类进行简单的模拟实现： namespace wjx { class string { public: private: char* _str; }; 首先，我们定义一个自己的命名空间，来实现我们的string类，定义初...
C++string的实现
qq_53558968的博客
07-03 5102
文章目录前言一、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.
C++ string类的实现
m0_60447315的博客
08-21 3577
C++ string类实现
C++实现string类
琅嬛福地
04-13 846
C++写一个string类，其实更多的是对C++内存分配，运算符重载的功能的运用。 MyString.h #pragma once #include <iostream> using namespace std; class MyString { public: MyString(); //默认构造函数 MyString(int n, char c); //普通构造函数 ...
C++中string类的实现
m0_65014490的博客
07-22 1762
在c++的标准库中我们处理字符串的时候需要使用string类，库中的使用接口都非常方便。为了让我们更加了解有关库中的相关函数，我们需要自己来实现一遍。
C++（string类的实现）
2301_80475151的博客
10-03 2537
string类的实现
c++ string解析及其实现
2301_80772499的博客
08-02 937
string 的使用，string内外函数的讲解，string的实现
【C++】自主实现string类
qq_75000174的博客
11-28 1850
因为end是int类型的，pos是size_t的，不同类型比较时要先转换成同种类型，所以将int转换成size_t，因为size_t是无符号整型unsigned int，它>=0，因此将end转换成size_t类型的临时变量与pos==0相比较，永久成立，因此会死循环（end会变成负数，但是将end转换成size_t类型的临时变量，该临时变量是>=0的）要求：当n<=_size时，string类对象的内容变为_str[0,n]，_str[n]=’\0’，即有效的字符个数变为n，不缩容。
C++实现简单的string array
fang437385323的专栏
03-23 404
C++实现简单的String Array
C++简单String类的实现
12-22
目前也在学习C++中，昨天正在学习has-a关系中的包含时，例题是将string类包含的，因为是小白嘛，嘿嘿，为了更深的理解包含以及其他相关问题，果断上机边敲代码边理解咯，既然用到了string类，自己突然想写个简易的...
C++实现string存取二进制数据的方法
09-04
然而，对于简单的场景，string仍然是一种可行的解决方案。 总的来说，当在C++中使用string类处理二进制数据时，需特别注意空字符的影响，正确使用构造函数并传递数据长度，以确保数据的完整性和一致性。同时，理解...
使用C++中string实现任意长度的正小数、整数之间加减法方法实例
08-30
使用C++中string实现任意长度的正小数、整数之间加减法方法实例 本文主要介绍了利用C++中string函数实现任意长度的正小数、整数之间加减法方法实例。通过示例代码介绍的非常详细，对大家具有一定的参考学习价值。 ...
探索三相交错并联 Boost 变换器
2508_94198873的博客
12-02 278
三相交错并联boost变换器1、电压外环，电流内环。外环生成给定Iref/3分配给三个电流内环单独做控制2、三相交错并联结构三路开关管采取移相120°的交错调制方式最近一直在研究三相交错并联 Boost 变换器，感觉它真的很有意思，今天就来和大家分享一下。
C++学习------lambda表达式
jndingxin的专栏
11-30 760
优势说明简洁性无需单独定义函数局部性逻辑紧贴使用处闭包能力捕获环境变量，实现状态保持泛型支持C++14+ 支持auto参数STL 友好完美适配算法、容器、线程等✅现代 C++ 编程中，lambda 是不可或缺的工具！
基于单周期控制的两相交错并联无桥Boost型 PFC 变换器 采用两路 Boost PFC 交...
最新发布
2509_94268408的博客
12-02 315
最关键的是，这两路的控制居然是"单周期控制"——这名字听着玄乎，其实原理特直接。但单周期控制的魔法在于，它把输出电压的波动也考虑进去了，相当于闭环自调节。实际硬件中，用CPLD生成两路PWM时，死区时间得控制在50ns以内，否则会导致共通短路。用PLECS搭个模型，输入电压从150V到264V跳变，能看到两路电感的电流波形像跳华尔兹一样交错。采用两路 Boost PFC 交错并联实现的，每一路的控制方式和结构都是相同的，由此推出控制方法相同，都为单周期控制，所以只分析一路的结果就可以类比。
C++基础：Stanford CS106L学习笔记 1 类型与结构
WM2101的博客
12-02 286
本文介绍了C++的类型系统和结构体特性。在类型系统方面，C++采用静态类型，变量类型一旦确定不可更改，与Python的动态类型形成对比。静态类型能提高效率并减少运行时错误。文章还介绍了using类型别名、auto类型推断以及函数重载等现代类型特性。在结构体方面，展示了如何定义和使用结构体，以及使用std::pair模板简化多值返回的实现方式。通过对比Python和C++的代码示例，突出了C++在类型安全性和编译时检查方面的优势。
【下篇】C++20 约束、NCCL 通信与并发模型
MatsumotoChrikk
11-30 897
本文探讨了现代C++在高性能AI系统中的关键应用。C++20引入的Concepts显著优化了模板约束机制，通过编译期类型检查提升算子库开发效率。针对分布式通信，采用RAII封装NCCL库，实现异常安全的资源管理。同时利用C++20协程解决异步IO难题，以同步写法实现高并发推理服务。这些特性使C++在保持硬件级性能的同时，提升了工程可维护性，成为构建AI基底的理想选择。文章展现了C++持续演进的技术价值及其在AI基础设施中的核心地位。
CC++链接数据库（MySQL）超级详细指南
2509_94088022的博客
11-30 1013
在C/C++编程中，与数据库进行交互是一项常见的任务。其中，"host"是数据库服务器的地址，"user"是数据库用户名，"password"是数据库密码，"database"是要连接的数据库名称。在使用C/C++链接MySQL数据库之前，需要确保你的开发环境中已经安装了MySQL数据库以及相应的开发库。你需要在你的C/C++项目中配置这些路径，以便编译器和链接器能够找到MySQL的头文件和库文件。在你的C/C++项目中，你需要引入MySQL的头文件，并在编译时链接MySQL的库文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值