C++实现string类

C++实现string类

    • string类
      • 数据成员
      • 默认构造函数
      • 含参构造函数
      • 析构函数
      • 拷贝构造函数
      • 赋值运算符
      • 加号运算符和+=运算符
      • 代码


string类

写一个string类,能够完成string类的操作:

  1. 构造函数,能使用=构造,构造函数传入的参数为const char* 类型
  2. 拷贝构造函数
  3. 析构函数
  4. operator =
  5. operator +
  6. operator +=
  7. operator <<
  8. 从string类型转换成const char*类型,data()方法
  9. 将string转成int类型
  10. 统计string的长度,也就是size()方法
  11. 清空字符串
  12. 判断字符串是否为空
  13. 追加append函数,类似于+=

数据成员

  • char* ptr:指向堆内存空间,从堆内存申请空间。
  • int len:记录字符串实际长度,不包含结束符。

默认构造函数

默认构造函数中,为ptr申请一个字节的堆内存,这样任何情况下,ptr都不为nullptr,避免了ptr是否为nullptr的情况,在随时访问的时候,就可以少写很多if判断。

myString::myString(){
    ptr = (char*)malloc(1); //为ptr申请一个字节的堆内存
    memset(ptr,0,1);
    len = 0; //字符串实际长度为0
}

含参构造函数

  1. 传入一个const char* r,让构造函数接受字符串字面量作为参数,因为字符串字面量在C++中是const char[]类型的,自然会转换为const char*类型。
  2. 先为ptr申请字符串r长度+1的内存空间,多一个字节是为了保存结束符’\0’。
  3. 再将r所指的内存空间中的内容,拷贝给ptr所指的内存空间,使用memmove,memmove被用来将字符串从一个内存位置复制到另一个位置。
  4. 在实际的调用中,用一个“=”赋值的时候,就会调用含餐构造函数。
myString::myString(const char* r){
// 先为ptr申请字符串r长度+1的内存空间,多一个字节是为了保存结束符'\0'
    len = strlen(r);
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
// 将r所指的内存空间中的内容,拷贝给ptr所指的内存空间,为了避免内存泄漏,使用memmove
    memmove(ptr,r,len+1);
}

析构函数

  1. 释放ptr指向的内存空间
myString::~myString(){
    free(ptr);
}

拷贝构造函数

  1. 因为有指针进行new堆内存操作,需要重写拷贝构造函数进行深拷贝。
  2. 如果不重写拷贝构造函数的话,会调用系统默认的拷贝构造。
  3. 默认的拷贝构造是浅拷贝,在包含堆内存操作的类中,会出现重复释放,造成段错误。
// 拷贝构造,深拷贝
myString::myString(const myString& r){
    //free(ptr);
    len = r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);// 为p的ptr申请独立的空间
// 将r中的ptr拷贝给p的ptr
    memmove(ptr,r.ptr,len+1); // 拷贝数据
}

赋值运算符

  • 防止自赋值
  • 注意对原本非空指针的释放
myString myString::operator= (const myString& r){
    if(this != &r) { // 防止自赋值
        if(ptr != nullptr)
            free(ptr);
        len = r.len;
        ptr = (char*)malloc(len+1);
        memset(ptr, 0, len+1);
        memmove(ptr, r.ptr, len+1);
    }
    return *this; // 应该返回对象的引用
}

加号运算符和+=运算符

  • p1 = p1+“hello”
  • p1 = p1+p2; 两种都有可能,要写全参数类型
  • +=运算符和+类似
// p1 = p1+"hello";
myString myString::operator+(const char* r){
    // 创建新的对象,新对象的长度以及ptr指向内存空间是this+r的总和
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放,否则会出现内存泄漏
    newStr.len = this->len+strlen(r);
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r);
    return newStr;
}

// p1 = p1+p2
myString myString::operator+(const myString& r){
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放,否则会出现内存泄漏
    newStr.len = this->len+r.len;
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r.ptr);
    return newStr;
}
myString myString::operator+=(const char* r){
    char* temp = ptr;
    int l = len; // 保存原来的ptr和len
    this->len = this->len+strlen(r);
    this->ptr = (char*)malloc(this->len+1); //ptr指向新的内存空间
    memset(ptr,0,len+1);
    memmove(ptr,temp,l); // 把原来的ptr内容拷贝给新的ptr
    strcat(ptr,r);
    free(temp);
    return *this;
}


myString myString::operator+=(const myString& r){
    char* temp = ptr;
    int l = len;
    len = len+r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
    memmove(ptr,temp,l);
    strcat(ptr,r.ptr);
    free(temp); //temp记得free
    return *this;
}

代码

#include
#include 

using std::cout;
using std::endl;

/**
 * 当myString对象没有保存任何字符串的时候,应该至少为该对象中的ptr申请至少一个字节的空间
 * 这样任何情况下,ptr都不为nullptr,避免了ptr是否为nullptr的情况,在随时访问的时候,
 * 就可以少写很多if判断。
 *  · 无参构造函数要重写。
 *  · 因为有指针进行new堆内存操作,默认的拷贝构造是浅拷贝,需要重写拷贝构造,否则会出现重复释放,造成段错误。
*/
class myString{
public:
    myString(); //无参构造函数
    myString(const char* r); //单参构造函数
    myString(const myString& r); //单参构造函数
    ~myString();
    void show(){cout<<ptr<<endl;}
    int size(){return len;}
    void clear();
    bool empty();
    myString operator= (const myString& r);
    myString operator+ (const char* r);
    myString operator+(const myString& r);
    myString operator+= (const char* r);
    myString operator+= (const myString& r);
    char operator[](int n);

    void append(const char* r);
    void append(const myString& r);

    friend std::ostream& operator<< (std::ostream& out, const myString& r);
    friend std::istream& operator>> (std::ostream& in, myString& r);

    const char* data(){return this->ptr;};
    int toInt();
private:
    char* ptr; //指向堆内存空间
    int len; // 字符串实际长度,不包含结束符
};

myString::myString(){
    ptr = (char*)malloc(1); //为ptr申请一个字节的堆内存
    memset(ptr,0,1);
    len = 0;
}

myString::myString(const char* r){
// 先为ptr申请字符串r长度+1的内存空间,多一个字节是为了保存结束符'\0'
    len = strlen(r);
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
// 将r所指的内存空间中的内容,拷贝给ptr所指的内存空间,为了避免内存泄漏,使用memmove
    memmove(ptr,r,len+1);
}

// 拷贝构造,深拷贝
myString::myString(const myString& r){
    len = r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);// 为p的ptr申请独立的空间
// 将r中的ptr拷贝给p的ptr
    memmove(ptr,r.ptr,len+1); // 拷贝数据
}

myString::~myString(){
    free(ptr);
}

void myString::clear(){
    free(ptr);
    ptr=(char*) malloc(1);
    memset(ptr,0,1);
    len = 0;
}

bool myString::empty(){
    return !len;
}

myString myString::operator= (const myString& r){
    if(this != &r) { // 防止自赋值
        if(ptr != nullptr)
            free(ptr);
        len = r.len;
        ptr = (char*)malloc(len+1);
        memset(ptr, 0, len+1);
        memmove(ptr, r.ptr, len+1);
    }
    return *this; // 应该返回对象的引用。
}

// p1 = p1+"hello";
myString myString::operator+(const char* r){
    // 创建新的对象,新对象的长度以及ptr指向内存空间是this+r的总和
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放,否则会出现内存泄漏
    newStr.len = this->len+strlen(r);
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r);
    return newStr;
}

// p1 = p1+p2
myString myString::operator+(const myString& r){
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放,否则会出现内存泄漏
    newStr.len = this->len+r.len;
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r.ptr);
    return newStr;
}

myString myString::operator+=(const char* r){
    char* temp = ptr;
    int l = len; // 保存原来的ptr和len
    this->len = this->len+strlen(r);
    this->ptr = (char*)malloc(this->len+1); //ptr指向新的内存空间
    memset(ptr,0,len+1);
    memmove(ptr,temp,l); // 把原来的ptr内容拷贝给新的ptr
    strcat(ptr,r);
    free(temp);
    return *this;
}


myString myString::operator+=(const myString& r){
    char* temp = ptr;
    int l = len;
    len = len+r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
    memmove(ptr,temp,l);
    strcat(ptr,r.ptr);
    free(temp); //temp记得free
    return *this;
}

char myString::operator[](int n){
    return ptr[n];
}

void myString::append(const char* r){
    char* temp = ptr;
    int l = len; // 保存原来的ptr和len
    this->len = this->len+strlen(r);
    this->ptr = (char*)malloc(this->len+1); //ptr指向新的内存空间
    memset(ptr,0,len+1);
    memmove(ptr,temp,l); // 把原来的ptr内容拷贝给新的ptr
    strcat(ptr,r);
    free(temp);
}

void myString::append(const myString& r){
    char* temp = this->ptr;
    int l = len;
    len = len+r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
    memmove(ptr,temp,l);
    strcat(ptr,r.ptr);
    free(temp); //temp记得free
}

std::ostream& operator<< (std::ostream& out, const myString& r){
    out<<r.ptr;
    return out;
}

std::istream& operator>> (std::ostream& in, myString& r){
    char buf[1024];
    std::cin>>buf;
    free(r.ptr);
    r.len = strlen(buf);
    r.ptr = (char*)malloc(r.len+1);
    memset(r.ptr,0,r.len+1);
    memmove(r.ptr,buf,r.len+1);

}

int myString::toInt(){
    return atoi(this->ptr);
}

int main(){
    myString str = "hello"; // 转换构造函数,也就是单参构造函数
    myString ptr(str); // 拷贝构造
    myString atp = str; //拷贝构造
    ptr = str; //运算符 operator=
    ptr = ptr + " world";
    ptr.show(); 
    myString str2 = " world";
    str2 = str+str2;
    str += " world";
    str.show();
    ptr+=str2;
    ptr.show();
    atp.append(" world");
    atp.show();
    return 0;
}

你可能感兴趣的:(C++,c++)