C++字符串以及字符串的封装_C

#include using namespace std; int main() { string name1 = "gaowanxi"; cout << name1 << endl; string name2 = "zhangsan"; //at()接口 cout << name2.at(2) << endl; //cout << name2.at(100) << endl; //size()接口 cout << name2.size() << endl; //不包含尾部的'<< name1 + name2 << endl; string str = name1 += name2; cout << str << "," << name1 <' //[]中括运算符函数的重载 cout << name2[100] << endl; //在使用string定义的字符串，当访问指定的字符时，我们更推荐使用at,因为有边界检查 //terminate called after throwing an instance of 'std::out_of_range' //what(): basic_string::at: __n (which is 6) >= this->size() (which is 5) operator+ +号运算符重载 cout

3.封装string类型 3.1 构造函数 //构造函数 MyString(const char* c_str = nullptr){ //1.获取外部字符串的长度 int len = strlen(c_str); //2.开辟空间放置字符串 this->my_data = new char[len+1];//+1 因为下标从0开始的 //3.拷贝将字符串数据 memmove(this->my_data,c_str,len); //4.结尾处加'\0' this->my_data[len]='\0'; } //拷贝构造函数 MyString(const MyString& other){ int len = strlen(other.my_data); this->my_data = new char[len+1]; memmove(this->my_data,other.my_data,len); this->my_data[len]='\0'; }

3.3 运算符重载函数 < 0 || index > //获取字符串长度 int size(){ return strlen(this->my_data); } //括号运算符重载 char operator[](int index){ //1.判断index是否合法 if(index <<"越界"< this->size()){ coutmy_data[index]; } // = 号运算符重载 MyString& operator=(const MyString& other){ if(this == &other){ //1.相等直接返回即可 return *this; } //2.获取另一个字符串的长度 int len = strlen(other.my_data); //3.如果本对象有指向空间需要先释放再开辟足够大的空间 if(this->my_data != nullptr){ delete []my_data; this->my_data = new char[len+1]; }else{ this->my_data = new char[len+1]; } //4.拷贝数据 memmove(this->my_data,other.my_data,len); this->my_data[len] = '\0'; return *this; } //+号运算符重载 MyString operator+(const MyString& other){ //方法1. 使用系统函数 //this->my_data = strncat(this->my_data,other.my_data,strlen(this->my_data) + strlen(other.my_data)); //方法2. 使用自定义方法 //1.重新定义长度 int len = strlen(this->my_data) + strlen(other.my_data); //2. 开辟临时空间 char *temp = new char[len+1]; //3.分别将数据拷贝到临时空间中 memmove(temp,this->my_data,strlen(this->my_data)); memmove(temp + strlen(other.my_data),other.my_data,strlen(other.my_data)); temp[len] = '\0'; //4.清空this->my_data delete []this->my_data; //5.将临时空间赋值给this空间 this->my_data = temp; return *this; } // 提供公有接口 char* getMy_data(){ return this->my_data; }

4.整体代码 #include #include < 0 || index > using namespace std; class MyString{ private: char* my_data; public: //构造函数 MyString(const char* c_str = nullptr){ //1.获取外部字符串的长度 int len = strlen(c_str); //2.开辟空间放置字符串 this->my_data = new char[len+1];//+1 因为下标从0开始的 //3.拷贝将字符串数据 memmove(this->my_data,c_str,len); //4.结尾处加'\0' this->my_data[len]='\0'; } //拷贝构造函数 MyString(const MyString& other){ int len = strlen(other.my_data); this->my_data = new char[len+1]; memmove(this->my_data,other.my_data,len); this->my_data[len]='\0'; } //析构函数 ~MyString(){ if(my_data != nullptr){ delete []my_data; my_data = nullptr; } } //获取字符串长度 int size(){ return strlen(this->my_data); } //括号运算符重载 char operator[](int index){ //1.判断index是否合法 if(index <<"越界"< this->size()){ coutmy_data[index]; } // = 号运算符重载 MyString& operator=(const MyString& other){ if(this == &other){ //1.相等直接返回即可 return *this; } //2.获取另一个字符串的长度 int len = strlen(other.my_data); //3.如果本对象有指向空间需要先释放再开辟足够大的空间 if(this->my_data != nullptr){ delete []my_data; this->my_data = new char[len+1]; }else{ this->my_data = new char[len+1]; } //4.拷贝数据 memmove(this->my_data,other.my_data,len); this->my_data[len] = '\0'; return *this; } //+号运算符重载 MyString operator+(const MyString& other){ //方法1. 使用系统函数 //this->my_data = strncat(this->my_data,other.my_data,strlen(this->my_data) + strlen(other.my_data)); //方法2. 使用自定义方法 //1.重新定义长度 int len = strlen(this->my_data) + strlen(other.my_data); //2. 开辟临时空间 char *temp = new char[len+1]; //3.分别将数据拷贝到临时空间中 memmove(temp,this->my_data,strlen(this->my_data)); memmove(temp + strlen(other.my_data),other.my_data,strlen(other.my_data)); temp[len] = '\0'; //4.清空this->my_data delete []this->my_data; //5.将临时空间赋值给this空间 this->my_data = temp; return *this; } // 提供公有接口 char* getMy_data(){ return this->my_data; } };

1.重载

C++预定义中的运算符的 *** 作对象只局限于基本的内置数据类型，但是对于我们自定义的类型

（类）是没有办法 *** 作的

但是大多时候我们需要对自定义的类型进行类似的运算，这个时候就需要我们对运算符进行

重新定义，赋予其新的功能，以满足自身的需求

2.string

C语言之中是没有字符串类型的只有字符串的表现形式 1.字符指针 2.字符数组

在C使用字符串要注意：字符长度及尾\0的问题

在C++的面向对象这个世界中，对于底层数据元素 *** 作，我们把这个底层 *** 作封装了起来，成

为了一个专属性字符串类型----string类型

2.1 C++中string的API接口

#include 
using namespace std;
int main()
{
    string name1 = "gaowanxi";
    cout << name1 << endl;
    string name2 = "zhangsan";
    //at()接口
    cout << name2.at(2) << endl;
    //cout << name2.at(100) << endl;
    //size()接口
    cout << name2.size() << endl; //不包含尾部的'<< name1 + name2 << endl;
    string str = name1 += name2;
    cout << str << "," << name1 <'
    //[]中括运算符函数的重载
    cout << name2[100] << endl;
    //在使用string定义的字符串，当访问指定的字符时，我们更推荐使用at,因为有边界检查
    //terminate called after throwing an instance of 'std::out_of_range'
    //what():  basic_string::at: __n (which is 6) >= this->size() (which is 5)

    operator+  +号运算符重载
    cout

 
3.封装string类型 
        3.1 构造函数 
   //构造函数
    MyString(const char* c_str = nullptr){
        //1.获取外部字符串的长度
        int len = strlen(c_str);
        //2.开辟空间放置字符串
        this->my_data = new char[len+1];//+1 因为下标从0开始的
        //3.拷贝将字符串数据
        memmove(this->my_data,c_str,len);
        //4.结尾处加'\0'
        this->my_data[len]='\0';
    }
      //拷贝构造函数
    MyString(const MyString& other){
        int len = strlen(other.my_data);
        this->my_data = new char[len+1];
        memmove(this->my_data,other.my_data,len);
        this->my_data[len]='\0';
    }

 
        3.2 析构函数

//析构函数
    ~MyString(){
        if(my_data != nullptr){
            delete []my_data;
            my_data = nullptr;
        }
    } 
        3.3 运算符重载函数 
< 0 || index  >    //获取字符串长度
    int size(){
        return strlen(this->my_data);
    }

    //括号运算符重载
    char operator[](int index){
        //1.判断index是否合法
        if(index <<"越界"< this->size()){
            coutmy_data[index];
    }

    // = 号运算符重载
    MyString& operator=(const MyString& other){
        if(this == &other){
            //1.相等直接返回即可
            return *this;
        }
        //2.获取另一个字符串的长度
        int len = strlen(other.my_data);
        //3.如果本对象有指向空间 需要先释放 再开辟足够大的空间
        if(this->my_data != nullptr){
            delete []my_data;
            this->my_data = new char[len+1];
        }else{
            this->my_data = new char[len+1];
        }
        //4.拷贝数据
        memmove(this->my_data,other.my_data,len);
        this->my_data[len] = '\0';
        return *this;
    }

    //+号运算符重载
    MyString operator+(const MyString& other){
        //方法1. 使用系统函数
        //this->my_data = strncat(this->my_data,other.my_data,strlen(this->my_data) + strlen(other.my_data));

        //方法2. 使用自定义方法
        //1.重新定义长度
        int len = strlen(this->my_data) + strlen(other.my_data);
        //2. 开辟临时空间
        char *temp = new char[len+1];
        //3.分别将数据拷贝到临时空间中
        memmove(temp,this->my_data,strlen(this->my_data));
        memmove(temp + strlen(other.my_data),other.my_data,strlen(other.my_data));
        temp[len] = '\0';
        //4.清空this->my_data
        delete []this->my_data;
        //5.将临时空间赋值给this空间
        this->my_data = temp;

        return *this;
    }

    // 提供公有接口
    char* getMy_data(){
        return this->my_data;
    }
 
4.整体代码 
#include 
#include < 0 || index  >

using namespace std;
class MyString{
private:
    char* my_data;
public:
    //构造函数
    MyString(const char* c_str = nullptr){
        //1.获取外部字符串的长度
        int len = strlen(c_str);
        //2.开辟空间放置字符串
        this->my_data = new char[len+1];//+1 因为下标从0开始的
        //3.拷贝将字符串数据
        memmove(this->my_data,c_str,len);
        //4.结尾处加'\0'
        this->my_data[len]='\0';
    }
    //拷贝构造函数
    MyString(const MyString& other){
        int len = strlen(other.my_data);
        this->my_data = new char[len+1];
        memmove(this->my_data,other.my_data,len);
        this->my_data[len]='\0';
    }
    //析构函数
    ~MyString(){
        if(my_data != nullptr){
            delete []my_data;
            my_data = nullptr;
        }
    }
    //获取字符串长度
    int size(){
        return strlen(this->my_data);
    }
    //括号运算符重载
    char operator[](int index){
        //1.判断index是否合法
        if(index <<"越界"< this->size()){
            coutmy_data[index];
    }
    // = 号运算符重载
    MyString& operator=(const MyString& other){
        if(this == &other){
            //1.相等直接返回即可
            return *this;
        }
        //2.获取另一个字符串的长度
        int len = strlen(other.my_data);
        //3.如果本对象有指向空间 需要先释放 再开辟足够大的空间
        if(this->my_data != nullptr){
            delete []my_data;
            this->my_data = new char[len+1];
        }else{
            this->my_data = new char[len+1];
        }
        //4.拷贝数据
        memmove(this->my_data,other.my_data,len);
        this->my_data[len] = '\0';
        return *this;
    }
    //+号运算符重载
    MyString operator+(const MyString& other){
        //方法1. 使用系统函数
        //this->my_data = strncat(this->my_data,other.my_data,strlen(this->my_data) + strlen(other.my_data));

        //方法2. 使用自定义方法
        //1.重新定义长度
        int len = strlen(this->my_data) + strlen(other.my_data);
        //2. 开辟临时空间
        char *temp = new char[len+1];
        //3.分别将数据拷贝到临时空间中
        memmove(temp,this->my_data,strlen(this->my_data));
        memmove(temp + strlen(other.my_data),other.my_data,strlen(other.my_data));
        temp[len] = '\0';
        //4.清空this->my_data
        delete []this->my_data;
        //5.将临时空间赋值给this空间
        this->my_data = temp;

        return *this;
    }
    // 提供公有接口
    char* getMy_data(){
        return this->my_data;
    }

};
 
					
										


					
						欢迎分享，转载请注明来源：内存溢出
原文地址: https://outofmemory.cn/langs/2990501.html

C++字符串以及字符串的封装

发表评论

评论列表（0条）