一个精简的string类

C++string类 就像一个家庭中有两个孩子,但父母只买了一份玩具,两个孩子愿意一块玩,则万事大吉,万一不想分享就你争我夺,玩具损坏。可以采用深拷贝解决浅拷贝问题,即:每个对象都有一份独立的资源,不要和其他对象共享。父母给每个孩子都买一份玩具,各自玩各自的就不会有问题了可以采用深拷贝解决浅拷贝问题,即:每个对象都有一份独立的资源,不要和其他对象共享,父母给每个孩子都买一份玩具,各自玩各自的就不会有问题了。 阅读详情

今天在看数据结构的时候发现一个String类的ADT表示以及实现让人看着很不舒服,于是乎愚蠢的自己实现了一个String类,这个类的接口功能和标准库中的string类是一致的,由于里面的字串操作函数都是自己实现的,所以效率一定很低,(标准库中的字串操作函数是汇编实现的J~~~),经过简单的测试,my String似乎已经正确实现,由于只实现了标准的string的一般的操作,并没有实现迭代操作,所以只能将String类称作“一个精简的,但是异常低效的stringJ”,好了,不说了,看代码吧,有错误大家请热烈的扔鸡蛋 J.

1:类中有些地方使用了“自动构造类型转换”,所以实现的功能还是比较多的。

2:使用了库函数memcpy来实现数据的移动,这样做似乎比循环移动数据要高效

3:实现了字符串模式匹配的KMP算法

 

※     文件String.h

#ifndef STRING_H_

#define STRING_H_

 

#include <iostream>

 

#ifndef NOPOS

#define NOPOS -0

#endif

 

//size_t : long unsigned int

class String {

  

public:

   String();

   String( const char* ch );            //由字符数组构造

   String( const String& str);

   virtual ~String();

  

   String& Append(const String& s );             

//在当前串追加一个字符串

   inline size_t Size() const {   return m_iLength;}

   //当前字符串长度

   const char* c_str() const;                    

//返回当前串的一个拷贝

   int Compare( const String& s, size_t n) const ;  

   //将当前串从n位置与S进行比较,如果比较部分相同,返回0,

   //如果相同部分在N前返回-1,如果在N后,则返回1

   const char* Data() const;                     

//返回串中的内容

   String& Erase( size_t n, size_t m);           

   //删除自串中n到m之间的字符

   size_t Find(const String& s, size_t n=0);     

   //从n位置开始,搜索字串s如果搜到,则返回首次出现该字串的位置,

   //如果没有,返回常数NOPOS

   String& Insert(size_t n, const String& s);    

//在n位置出插入字串s

  

   const char* operator[] (size_t i) const;

   char* operator[](size_t i);                   

//返回索引i处字符的地址

   int rFind(const String& s, int n=NOPOS);      

//反向搜索字串s

   String& operator=(const String& str);

  

   //friend function

friend std::istream& operator>>(std::istream& sin, String& s);

friend std::ostream& operator<<(std::ostream& sout, String& s);

 

   friend String operator+( const String& s1, const String& s2);

   friend bool operator== ( const String& s1, const String& s2);

   friend bool operator!= ( const String& s1, const String& s2);

   friend bool operator>( const String& s1, const String& s2);

   friend bool operator>=( const String& s1, const String& s2);

   friend bool operator<( const String& s1, const String& s2);

   friend bool operator<=( const String& s1, const String& s2);

 

protected:

   //reimplement cstring functions

   char* strcat(char *t, const char *s);

   size_t strlen( const char *s) const;

   char* strcpy( char *t, const char *s);

   int strcmp(const char*t, const char*s, size_t n) const;

   char* strinsert(size_t n, char **dstr, const char *sstr);

  

   void fail(int *fail, const char* ch); //给失效匹配数组赋值的函数

private:

   char* cstr;

   size_t m_iLength;

 

};

 

#endif /*STRING_H_*/

 

※     ※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※

※文件String.cpp

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※

#include "String.h"

 

#include <memory.h>

#include <iostream>

 

 

String::String()

{

   cstr = new char[1];

   *cstr = '/n';   //新建空的字串

   m_iLength= 0;

}

 

String::String(const char* ch )

{

  

   m_iLength = strlen(ch);

   cstr = new char[m_iLength+1];

   strcpy(cstr, ch);  //拷贝字符串,包括'/0'

}

 

String::String( const String& str)

{

   m_iLength = str.m_iLength;

   cstr = new char[m_iLength+1];

   strcpy(cstr, str.cstr);

}

 

String::~String()

{

   delete[] cstr;

}

 

 

String& String::Append(const String& s)

{

   char *ch ;

   if(s.m_iLength>0)

   {

      ch = new char[m_iLength+s.m_iLength+1];

      memcpy(ch, cstr, m_iLength+1);

      strcat(ch, s.cstr);

      m_iLength = strlen(ch);

      delete[] cstr;

      cstr = ch;

   } 

   return *this;  

}

 

 

const char*  String::c_str() const

{

   return cstr;

}

 

int String::Compare(const String& s, size_t n) const

{

   return strcmp(cstr, s.cstr, n);  

}

 

const char* String::Data() const

{

   return cstr;

}

 

String& String::Erase( size_t n, size_t m)

{

   if(m==0) return *this;

   if((n+m) > m_iLength) m = m_iLength - n;

   char* str2 = new char[m_iLength-m+1];

  

   //拷贝内存区

   memcpy(str2, cstr, n);

   memcpy(str2+n, cstr+n+m, m_iLength-m+1);

   delete[] cstr;

   cstr = str2;

  

   m_iLength -= m; //重设字串长度;

   return *this;

  

}

 

String& String::Insert( size_t n, const String& s)

{

 

   strinsert(n, &cstr, s.cstr);//&cstr 显然,这里要改变cstr 指针

   m_iLength = strlen(cstr);

   return *this;  

}

 

String& String::operator=(const String& str)

{

   m_iLength = str.m_iLength;

   cstr = new char[m_iLength+1];

   strcpy(cstr, str.cstr); 

   return *this;

}

 

const char* String::operator[] (size_t i) const

{

   if(i<0) i=0;

   if(i>m_iLength+1) i=m_iLength+1;

   return cstr+i; 

}

char* String::operator[](size_t i)

{

  

   if(i<0) i=0;

   if(i>m_iLength+1) i=m_iLength+1;

   return cstr+i; 

}

 

String operator+( const String& s1, const String& s2)

{

   String ts1(s1);

   return ts1.Append(s2);  

}

 

bool operator== ( const String& s1, const String& s2)

{

   if( s1.Size() != s2.Size()) return false;

   if(!s1.Compare(s2,s2.Size())) return true;  //利用字符比较

   return false;

}

 

bool operator!= ( const String& s1, const String& s2)

{

   return !operator==(s1, s2);

}

 

bool operator>( const String& s1, const String& s2)

{

   return (s1.Compare(s2,s2.Size()) >0);

}

 

bool operator>=( const String& s1, const String& s2)

{

   return (s1.Compare(s2,s2.Size()) >0 || s1.Compare(s2,s2.Size()) == 0);

}

 

bool operator<( const String& s1, const String& s2)

{

   return (s1.Compare(s2,s2.Size()) < 0); 

}

 

bool operator<=( const String& s1, const String& s2)

{

   return (s1.Compare(s2,s2.Size()) < 0 || s1.Compare(s2,s2.Size()) == 0);

}

 

 

std::istream& operator>>(std::istream& sin, String& s)

{

   char* ch;

   sin >> ch;

   s = ch;

   return sin;

}

 

std::ostream& operator<<(std::ostream& sout, String& s)

{

   sout << s.cstr;

   return sout;

}

 

 

//----------------------------------------------------

//Protected function defines

//练手,愚蠢的再次实现几个字符串操作函数

//以后再也不能干这样的蠢事!!!!!!!!!

//----------------------------------------------------

 

size_t String::strlen( const char *s) const

{

   if(s == NULL) return 0;

   const char* p = s;

   size_t size = 0;

   while(*p++)

   {

      size++; 

   }

   return size;

}

 

char* String::strcpy( char *t, const char *s)

{

   if(t!=NULL && s!=NULL)

   {

      char* tmptr1 = t;

      const char* tmptr2 = s;

      while((*tmptr1++ = *tmptr2++) != '/0');

   }

   return t;

}

 

char* String::strcat(char *t, const char *s)

{

   if( t==NULL && s==NULL ) return t;

   char* tmptr1 = t;

   const char* tmptr2 = s;

   while((*tmptr1)) tmptr1++;

   while((*tmptr1++ = *tmptr2++) != '/0');

   return t;

}

 

int String::strcmp(const char *t, const char *s, size_t n) const

{

   size_t len1 = strlen(t);

   size_t len2 = strlen(s);

   if(len1 < len2)

   {

      n = len1;

   }

   else

   {

      n = len2;

   }

  

   int cmpresult = 0; //字典序比较结果

   const char* tmpch1 = t;

   const char* tmpch2 = s;

  

   size_t i = 0;

   while( (*tmpch1 == *tmpch2) && i<n )

   {

      i++;

      tmpch1++;

      tmpch2++;

   }

 

   if(   *tmpch1 > *tmpch2 )

   {

      cmpresult = 1;

   }

   else if(*tmpch1 < *tmpch2)

   {

      cmpresult = -1;

   }

   return cmpresult;

}

 

char* String::strinsert(size_t n, char** dstr, const char *sstr)

{

 

   size_t len1 = strlen(*dstr);

   size_t len2 = strlen(sstr);

   size_t len3 = len1+len2;

  

   if(len2>0)

   {

      if(n<0) n=0;

      if(n>len1) n=len1;      

      char* tmptr = new char[len3+1];

      memcpy(tmptr, *dstr, n); //拷贝前n个字符串

      memcpy(tmptr+n, sstr, len2);   //插入sstr

      memcpy(tmptr+n+len2, *dstr+n,len1-n+1); //拷贝后n+1个字符串

      delete[] *dstr;

      *dstr = tmptr;

   }

   return *dstr;  

}

 

 

//----------------------------

//经典的字符串模式匹配KMP算法!

//----------------------------

size_t String::Find(const String& s, size_t n)

{

  

   if((m_iLength-n)<s.m_iLength || n>m_iLength) return NOPOS; //没必要进行匹配

   int *Fary = new int[s.m_iLength]; //失效匹配数组

   fail(Fary, s.cstr);               //初始化失效匹配数组

   size_t posT = n;   //目标串长索引

   size_t posP = 0;   //匹配串长索引

   while( posT < m_iLength && posP < s.m_iLength)

   {

      while(cstr[posT++] == s.cstr[posP++]); 

//注意最后一次比较 posP越界

  

      if((posP-1) == s.m_iLength)           //查到匹配串

      { 

         break;

//退出while( posT < m_iLength && posP < s.m_iLength)

      }

      else

      { 

         //未匹配成功,重新设定POS,并在匹配

         posT += Fary[posP] + 1;

         posP = Fary[posP] + 1;  

      } 

   }

  

   delete[] Fary;  //删除失效匹配数组

   if( posP < s.m_iLength)

   {

      //没有查找到匹配项目

      return NOPOS;  

   }

   else

   {

      return posT - s.m_iLength;

   }

}

 

//-------------------------------------------

//用于失效匹配数组的初始化

//-------------------------------------------

void String::fail(int *fail, const char* ch)

{

   int len = strlen(ch);

   fail[0] = -1;      //首匹配字符

   for(int i=1; i<len; i++)

   {

      fail[i] = -1;

     

      // 循环计算fail[i] ,注意,i在while循环内会增加

      while(ch[i] == ch[fail[i-1]+1])

      {

         fail[i] = fail[i-1]+1;

         i++; 

      }

      if(ch[i] == ch[fail[i-1]])     //不可以丢失这里的比较

      {

         fail[i] = 0;

      }

      else

      {

         fail[i] = -1;

      }    

   } 

}

//一个反向匹配函数rFind()函数没有实现,但是算法和正向匹配相似,只需反向的建立失效数组和反向的索引字串就可以了,这里就不在实现它了。
Claude Code vs Codex Claude Code 提供了一个生产就绪(production-ready)的实现,包含良好的错误处理、优雅的关闭逻辑、详细注释和文档,以及内置测试。Claude Code 输出了一个可运行的 Next.js + TypeScript 前端,但错过了一些设计里的黄色主题元素;Codex 则生成自己的版本,没有导出设计中的图片,也没严格遵照设计主题。Codex 完成同样功能,但更简洁直接,文档和注释少一些但功能达标。任务都用同样的提示,使用 TypeScript 实现,并在一天内完成。 阅读详情

相关推荐

Tinder养号防封攻略来了:最新Tinder养号流程和运营攻略

今天,我就来给大家分享一下Tinder养号的具体操作,以及针对Tinder账号被封的一些常见问题为大家做个答疑。

m0_67768117的博客 2万+

string类精简版

string精简类的传统写法和现代写法

weixin_43164548的博客 439

TI DSP从COFF切换到EABI输出格式的5个关键修改点(TMS320F280025实测)

本文基于TMS320F280025实测,详细解析了TI DSP从COFF切换到EABI输出格式的5个关键修改点。核心差异在于EABI遵循ELF标准,涉及链接器优化、RAM数据共享、工具链升级、double数据类型位宽变化及链接器命令文件重构。迁移时需使用.retain指令防止关键数据被优化,利用NOINIT段保护共享RAM,并更新hex2000等工具,以确保BootLoader与应用程序稳定运行。

weixin_29189381的博客 266

实现精简版string类

c语言利用数组保存字符串,经常在不经意中浪费了大量的空间,使用起来十分的不方便,而且容易出错,为了解决c语言字符串的问题,c++增加了一个string类。本例就是为了说明通过运算符的重载而实现的。 代码如下: [cpp] view plaincopy #include   using namespace std;   cla

World_2015的专栏 559

基于eBPF和LSM的强制文件访问控制系统架构设计和实现

本文介绍了一种基于 eBPF 与 Linux 安全模块(LSM)实现的强制文件访问控制系统。该系统利用 eBPF 的高性能和动态加载能力以及 LSM 的系统调用拦截功能,提供了灵活且强大的文件访问控制策略。文章详细描述了系统的设计思路、架构组成、关键代码实现及错误处理方式。通过用户空间程序与内核态 eBPF 程序的协作,实现了对文件操作的实时监控和控制,支持动态更新安全策略而无需重启系统。此外,文中还讨论了未来可能的扩展方向,如增加更多 hook 点、集成其他安全模块以及性能优化等。

Linux内核研究者 1842

因时机器人-灵巧手配置方案(Ubuntu18.04)

因时机器人-灵巧手配置方案(Ubuntu18.04)

CH_monsy的博客 3856

重载运算符实现精简版string类

c语言利用数组保存字符串,经常在不经意中浪费了大量的空间,使用起来十分的不方便,而且容易出错,为了解决c语言字符串的问题,c++增加了一个string类。本例就是为了说明通过运算符的重载而实现的。 代码如下: [cpp] view plaincopyprint? #include  using namespace std;  class String  {

ljy050618的专栏 439

Web前端开发技术:实验14-16

实验14 1. 编写JavaScript程序实现“九九乘法口诀”表,如图14-40所示。 &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;九九乘法表&lt;/title&gt; &lt;/head&gt; &lt;body&gt; &lt;h1&gt;九九乘法表&lt;/h1&gt; &lt;/body&gt; &lt;scri

KslgmrDry的博客 1万+

自定义的精简版String类,重载了各种字符串的运算符操作

最近几天温习了字符串的相关知识,比较了C语言的字符串操作以及C++的string类字符串的操作,个人觉得C++的string类字符串操作方便很多。至少不用太在意字符串的内存分配,而且它还有比较方便的字符串搜索、插入等方法,便于对字符串的各种操作。出于学习巩固知识的目的,自己写了一个精简版的String类,这个类只是重载了几种简单的字符串运算操作符,还没有写搜索、插入等方法。以后再慢慢完善!

u010628991的专栏 853

【遥感物候】植被物候与气候(气温和降水)条件的空间相关性分析

植被生长与气候的关系最为密切,通过计算植被各个生长季参数和气温、降水之间的相关系数可以分析生长季参数的变化与气温、降水之间的关系的程度。本文计算30年的植被物候参数和气候数据之间的相关性,最终效果如下: 一、相关性分析原理 植被生长季及其变化是其生长环境中多个影响因子综合作用的耦合过程,其中气候是最重要、最活跃的环境因子。通过计算各个生长季参数和气温、降水之间的相关系数...

智慧空间实验室 8262

基于业务目标的Agent自动化评测体系设计:超越准确率的有效性衡量

我们还是以电商全链路服务Agent我们还是以电商全链路服务Agent。

AI架构全栈开发实战笔记 318

Java String类常用方法(附精简使用例子)

看极客学院视频讲解String类的使用,花了点时间稍微整理了下,感觉要用到的时候,应该还是不错的。

336

WorkBuddy 技能指南:基础办公与文档处理

WorkBuddy 不仅仅是一个对话工具——它通过技能(Skills)系统,将通用 AI 助手转变为具备专业领域能力的智能助手。每个技能都是一套经过精心设计的"能力包",包含专业知识、工作流程和专用工具。本文聚焦于文档处理类技能——这是日常工作中使用频率最高、最实用的能力集合。

u011186532的专栏 705

基于对象设计(二)含有指针的类——string精简版设计(C++实现)

基于对象设计(二)含有指针的类——string精简版设计(C++实现) 从头开始设计精简版string,分析实现细节

m0_46269109的博客 226

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

C++【string类,模拟实现string类】

就像一个家庭中有两个孩子,但父母只买了一份玩具,两个孩子愿意一块玩,则万事大吉,万一 不想分享就你争我夺,玩具损坏。可以采用深拷贝解决浅拷贝问题,即:每个对象都有一份独立的资源,不要和其他对象共享。父 母给每个孩子都买一份玩具,各自玩各自的就不会有问题了。

qq_67578580的博客 3698

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

【C++】string类

C++ string类解析摘要 本文全面解析C++ string类,重点包括: string类解决了C语言字符串的4大痛点:安全性问题、内存管理复杂、功能有限、不符合面向对象思想 string类基础用法和C++11新特性(auto关键字和范围for循环) 详细介绍了5类核心接口: 构造函数(空字符串、C字符串构造等) 容量操作(size()/length()、resize()等) 元素访问和遍历(下标操作、迭代器、范围for) 通过代码示例演示string类的实际应用,包括字符串处理和安全操作 string

凤年徐的博客 3479

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

【C++驾轻就熟】string类以及string类的模拟实现

C语言中,字符串是以'\0'结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数, 但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。 sring类的文档介绍总结:在使用string类时,必须包含#include头文件以及using namespace std; 2. string类对象的容量操作 注意:注意: 上面已经对string类进行了简单的介绍,大家只要能够正常使用即可。在面试中,面试官总喜欢让学

2201_75537851的博客 1182

string类

string类

m0_69323023的博客 549

String类详细介绍

size计算字符串长度。

xuecde的博客 5004

C++中简单自己实现一个string类

工具VS2017 MyString.h #pragma once #include&lt;iostream&gt; using namespace std; class MyString { friend ostream &amp; operator&lt;&lt;(ostream &amp;os, const MyString&amp; s); friend istream &amp; ...

Dxs4396的博客 4275

String类与StringBuilder类

String类和StringBulider类是java中常见的两种类。1 String 类在 java.lang 包下,所以使用的时候不需要导包​ 2 String 类代表字符串,Java 程序中的所有字符串文字(例如“abc”)都被实现为此类的实例也就是说,Java 程序中所有的双引号字符串,都是 String 类的对象​ 3 字符串不可变,它们的值在创建后不能被更改。

junflightzzz的博客 1860

String类和StringBuffer类

String类和StringBuffer类 在应用程序中经常会用到字符串,所谓字符串就是指一连串的字符,它是由许多单个字符连接而成的,如多个英文字母所组成的一个英文单词。字符串中可以包含任意字符。这些字符必须包含在一对双引号" "之内,例如"abc"。在Java中定义了String和SringBuffer两个类来封装字符串,并提供了一系列操作字符串的方法,它们都位在java.lang包中,因此不需要导包就可以直接使用。接下来针对String类和StringBuffer类进行详细讲解。 String类的初始化

xswl2000的博客 2544

【C++】理解string类的核心理念(实现一个自己的string类)

实现自己的string类是学习 C++ 语言和面向对象编程的一个好方法。通过编写一个简单的字符串类,可以深入理解等核心理念。理解了string类的底层逻辑之后会发现,一些在上层看似复杂的操作在底层其实很简单。下面就让我们来实现一个自己的string类吧!

谁在夜里看海.的博客 1947

《String类》

在Java中,Sting类是用来表示字符串的。字符串是一个字符序列,例如"Hello, World!String类位于java.lang包中,这个包是Java语言的核心包之一,不需要显示导入就可以使用。

m0_73881123的博客 1221

【C++之string类】

C++学习笔记009 -- string类的介绍以及基本使用

m0_69455439的博客 996

一个string类的实现

下面是一个string 类一般实现,重点在于操作符的重载,以后会继续更新 #include using namespace std; class String{ friend ostream& operator<< (ostream&,String&); public: String(const char* str=NULL); //赋值构造兼默认构造函数(char) St

923
上一篇: 3-10月 -06摘录
下一篇: 用户与厂商对话:IT是企业创新的引擎吗?
CLassic_Ms
博客等级 码龄21年 13粉丝 12原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值