自定义的String类

最新推荐文章于 2024-07-01 02:56:08 发布

天道殷勤

最新推荐文章于 2024-07-01 02:56:08 发布

阅读量4.8k

点赞数 4

分类专栏： c++

本文链接：https://blog.csdn.net/qq_41939248/article/details/80112877

版权

c++ 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、简介

C++标准库中包含一个string类，提供了一套封装好的数据以及处理这些数据的函数。为了熟悉这个类的内存管理情况，实现一下自定义的String类，涉及构造函数、复制构造函数、析构函数、重载运算符的操作，主要关注其内部指针的内存的重分配。

二、详解

1、代码实现：

（1）代码String.h：

 
   [html]  
   view plaincopy
#include <iostream>  
using namespace std;  
  
//自定义String类,系统是string类  
class String  
{  
    public:  
        String();                              //默认构造函数,用于创建空字符串  
        ~String();                             //析构函数  
        String(const char*const cstr);           //构造函数,带一个参数用来初始化字符串  
        String(const String &rs);              //复制构造函数,默认是浅层复制,需重载  
        char& operator[](unsigned int length); //重载下标运算符[]  
    char operator[](unsigned int length)const; //重载下标运算符[](const版本)    
        String &operator=(const String &rs);     //重载复制运算符=，用于两个字符串之间的赋值  
    String operator+(const String &rs);    //重载加法运算符+  
    String operator+=(const String &rs);     //重载组合运算符+=  
        friend ostream &operator<<(ostream &output, const String &str); //重载输出流运算符<<  
        friend istream &operator>>(istream &input, String &str);        //重载输入流运算符>>  
        friend bool operator<(const String&str1,const String &str2);    //重载小于运算符<  
        friend bool operator>(const String&str1,const String &str2);    //重载大于运算符>  
        friend bool operator==(const String&str1,const String &str2);   //重载等于运算符==  
  
        unsigned int getlen()const;            //获取字符串长度  
    const char*getstr()const;              //获取字符串  
      
    //int operator++(){cout<<"++i\n";tmp++;return tmp;}    //int的重载自加运算符  
    //int operator++(int){cout<<"i++\n";int tmp=rs;rs++;return tmp;}  
    protected:  
    private:  
        unsigned int len;  
    char *str;  
};  

（2）代码String.cpp：

 
   [html]  
   view plaincopy
#include <string.h>  
#include "String.h"  
#include <stdio.h>  
//默认构造函数,用于创建空字符串  
String::String()  
{  
    cout<<"---String constructor---"<<endl;  
    len = 0;  
    str = new char[1];  
    str[0] = '\0';  
}  
//析构函数  
String::~String()  
{  
      //cout<<"---String destructor---"<<endl;  
    delete []str;  
    len=0;  
}  
//构造函数,带一个参数用来初始化字符串  
String::String(const char*const cstr)  
{  
    /*len = strlen(cstr);  
    str = new char[len+1];  
    for (unsigned int i =0; i < len; i++) {  
      str[i] = cstr[i];  
    }  
    str[len]='\0';*/  
    cout<<"---String constructor:char*---"<<endl;  
    if (cstr == NULL) {  
        len = 0;  
    str = new char[1];  
    memset(str, 0, len+1);  
    if (str == NULL) return;  
  }  
  else {  
     len = strlen(cstr);  
     str = new char[len + 1];  
     memset(str, 0, len+1);  
     if (str == NULL) return;  
     strncpy(str, cstr, len);  
   }  
}  
//复制构造函数,默认是浅层复制,需重载  
String::String(const String &rs)  
{  
    cout<<"---String copy constructor---"<<endl;  
    len = rs.getlen();  
  str = new char[len + 1];  
  for(unsigned int i = 0 ;i < len; i++) {  
    str[i] = rs.str[i];  
  }  
  str[len] = '\0';  
  /*len = rs.getlen();  
  str = new char[len+1];  
  if (str == NULL) return;  
  strcpy(str, rs.str);*/  
}  
//重载下标运算符[]  
char&String::operator[](unsigned int length)  
{  
  if(length>len) return str[len-1];  
  else return str[length];  
}  
//重载下标运算符[](const版本)  
char String::operator[](unsigned int length)const  
{  
    //cout<<"String::operator[] const"<<endl;  
  if(length>len) return str[len-1];  
  else return str[length];  
}  
//重载复制运算符=，用于两个字符串之间的赋值  
String &String::operator=(const String &rs)  
{  
    cout<<"String::operator="<<endl;  
    if (this == &rs) return *this;  
  delete []str;  
  len = rs.getlen();  
  str = new char[len + 1];  
  for(int i = 0; i < len; i++) {  
    str[i] = rs[i];     //重载下标运算符[]才可使用  
    //str[i] = rs.str[i];  
  }  
  str[len] = '\0';  
  return *this;  
}  
//重载加法运算符+  
String String::operator+(const String &rs)  
{  
    /*char *st= new char[len + rs.getlen() + 1];  
  memset(st, 0, len + rs.getlen() + 1);  
  strcat(st, str);  
  strcat(st, rs.str);  
  return String(st);*/  
  cout<<"String::operator+"<<endl;   
  unsigned int total = len + rs.getlen();  
  char *tmpstr = new char[total + 1];  
  unsigned int i, j;  
  for (i = 0; i < len; i++) {  
    tmpstr[i] = str[i];  
  }  
  for( j = 0; j < rs.getlen(); j++, i++) {  
    tmpstr[i] = rs[j];  
  }  
  tmpstr[total] ='\0';  
  String st(tmpstr);  
  delete tmpstr;  
  tmpstr = NULL;  
  return st;   
}  
//重载组合运算符+=  
String String::operator+=(const String &rs)  
{  
  cout<<"String::operator+="<<endl;   
    int total = len + rs.getlen();  
  //delete []str;  
  char *tmpstr = new char[total + 1];     
  unsigned int i,j;  
  for(i = 0; i < len; i++) {  
    tmpstr[i] = str[i];  
  }  
  for(j = 0; j < rs.getlen(); j++,i++) {  
    tmpstr[i] = rs[j];  
  }  
  tmpstr[total]='\0';  
  delete []str;  
  str = new char[total + 1];  
  strncpy(str, tmpstr, total + 1);  
  return *this;  
  /*  
  char *temp = str;    
  len = len + rs.getlen();   
  str = new char[len + 1];    
  strcpy(str, temp);    
  strcat(_str, rs.getstr());    
  delete[] temp;    
  return *this;*/  
}  
//重载输出流运算符<<  
ostream &operator<<(ostream &output, const String &str)  
{  
    output<<str.str;  
  return output;  
}  
//重载输入流运算符>>  
istream &operator>>(istream &input, String &str)  
{  
    input>>str.str;  
  return input;  
}  
//重载小于运算符<  
bool operator<(const String&str1,const String &str2)  
{  
    if(strcmp(str1.str, str2.str) < 0) return 1;  
  else return 0;  
}  
//重载大于运算符>  
bool operator>(const String&str1,const String &str2)  
{  
    if(strcmp(str1.str, str2.str) > 0) return 1;  
  else return 0;  
}  
//重载等于运算符==  
bool operator==(const String&str1,const String &str2)  
{  
    if(strcmp(str1.str, str2.str) == 0) return 1;  
  else return 0;  
}  
//获取字符串长度  
unsigned int String::getlen()const  
{  
    return len;  
}  
//获取字符串  
const char*String::getstr()const  
{  
    return str;  
}  

（3）代码main.cpp：

 
   [html]  
   view plaincopy
#include <iostream>  
#include <stdio.h>  
#include "String.h"  
using namespace std;  
  
int main()  
{  
    String str1;                  //默认构造函数  
    String str2(NULL);            //带参构造函数  
    String str3("helloworld");    //带参构造函数  
    cout<<"str3="<<str3.getstr()<<endl;  
      
    String str4(str3);            //复制构造函数  
    //String str4 = str3;         //复制构造函数  
    cout<<"str4="<<str4.getstr()<<endl;   
      
      
    const String str5("tai");     //重载下标运算符[](const版本)   
    cout<<"str5[0]="<<str5[0]<<endl;  
      
    String str6;  
    str6 = str3;                  //重载复制运算符=  
    cout<<"str6="<<str6.getstr()<<endl;  
  
    String str7 = str3 + str5;    //重载加法运算符+  
    cout<<"str7="<<str7.getstr()<<endl;  
    
    String str8("123");  
    str8 += str7;                 //重载组合运算符+=  
    cout<<"str8="<<str8.getstr()<<endl;  
      
    String str9;  
    cin>>str9;                    //重载输入流运算符>>  
    cout<<"str9="<<str9<<endl;    //重载输出流运算符<<  
      
    String str10("compare String");  
    String str11("compare string");  
    int comp = str10 > str11;  
    cout<< "str10大于str11:" << comp <<endl;      
    return 0;  
}  

天道殷勤

关注

4
点赞
踩
37

收藏

觉得还不错? 一键收藏
2
评论
自定义的String类

一、简介 C++标准库中包含一个string类，提供了一套封装好的数据以及处理这些数据的函数。为了熟悉这个类的内存管理情况，实现一下自定义的String类，涉及构造函数、复制构造函数、析构函数、重载运算符的操作，主要关注其内部指针的内存的重分配。二、详解1、代码实现：（1）代码String.h：[html] view plain copy#include &lt;iostream&gt...
复制链接

扫一扫

专栏目录