AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C++string的模拟实现(上篇)

2023-02-09 75
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++string的模拟实现(上篇)

目录

一.命名空间的封装与交换函数模板

1.命名空间的封装与类的定义

2.交换函数模板

二.string类的四个重要默认成员函数

1.构造函数的类外定义：

2.析构函数在类外的定义

3.拷贝构造函数在类外的定义

4.赋值运算符重载在类外的定义

5.关于两个string对象的内容交换问题

三.string类的迭代器

四.string类的[]成员重载

一.命名空间的封装与交换函数模板
1.命名空间的封装与类的定义
模拟实现的string类最好用一个命名空间封装起来避免发生命名冲突。

命名空间定义：

namespace mystring
{

//.....

}
类的定义(为了方便整理和维护,成员方法的声明和定义分离)：

(本期不含增删查改的接口)

namespace mystring
{

class string
{
    public:
        typedef char * iterator;                  //宏定义string类的迭代器
        typedef const char* const_iterator;



        string(const char* nstr);                  //类中四个重要的默认成员函数
        string(const string& nstr);
        ~string();
        string& operator=(string nstr);


        void copyswap(string &nstr);               //复用交换函数的接口
        iterator begin();                          //string类用于获取迭代器的接口
        iterator end();
        const_iterator begin()const;
        const_iterator end()const;
        const char * C_str()const;                 //用于返回C类型字符串的函数
        char & operator[](int pos);                //用于返回pos下标字符的引用的[]重载
        const char & operator[](int pos) const;     
        size_t size() const;                       //获取有效字符个数size和容量的接口
        size_t capacity() const;
    private:
        char * _str;
        size_t _size;
        size_t _capacity;
};

}

2.交换函数模板
template
void myswap (T& e1 , T&e2)
{
T tem = e1;
e1 = e2;
e2 =tem;
}
该模板可以根据传入的实参类型生成用于交换对应类型数据的函数实例。

二.string类的四个重要默认成员函数
1.构造函数的类外定义：
类外声明方法时注意表明方法所在命名空间和类域

mystring::string::string(const char* nstr = "")

:_size(strlen(nstr))                            
,_capacity (_size)

{

_str = new char[_capacity+1];                
strcpy(_str,nstr);

}

设计缺省参数是为了保证类的构造函数可以被无参调用，(形参缺省值可用于构造空字符串)(会完成'\0'的拷贝)(注意参数缺省值只能写在函数的声明和定义其中一个之中)
strlen函数中有关于空指针的断言,所以构造函数中无须进行空指针断言
+1是为了保存'\0'(不计入容量和有效字符).
2.析构函数在类外的定义
mystring::string::~string()
{

if(_str)
{
    delete[] _str;      释放堆区空间
    _str=nullptr;
}
_size=0;
_capacity=0;

}
3.拷贝构造函数在类外的定义

mystring::string::string(const string& nstr)
:_size(nstr._size)
,_capacity(nstr._capacity)
{
    _str = new char[_capacity+1];             
    strcpy(_str,nstr._str);
}

这是一种非复用的写法，现代STL中比较喜欢使用复用的写法，拷贝构造函数可以通过复用构造函数来实现，从而使代码更加简洁：

先在类中定义一个成员交换函数(该函数通过复用swap函数实现)：

//template <typename T>
//void myswap (T& e1 , T&e2)
//{
//   T tem = e1;
//   e1 = e2;
//   e2 =tem;
//}
void mystring::string::copyswap(string & nstr)
{
    myswap(_str,nstr._str);
    myswap(_size,nstr._size);
    myswap(_capacity,nstr._capacity);
}

调用该成员函数可以将两个string对象的各个成员变量进行交换

复用构造函数实现拷贝构造函数：

mystring::string::string(const string& nstr)     //复用构造函数完成拷贝构造
:_str (nullptr)                                  //防止tem中_str作为野指针被释放
,_size(0)
,_capacity(0)
{
    string tem(nstr._str);                       //拷贝构造拷贝的是不含'\0'的有效字符
    this->copyswap(tem);                         //为了方便阅读加上this指针
}

该实现方法的思想是通过形参对象中的字符串构造tem临时对象,再将tem对象中的内容通过交换函数置换到被构造的对象中去。

tem在函数体执行完后会自动调用自身的析构函数并销毁。

4.赋值运算符重载在类外的定义
string& mystring::string::operator=(const string& nstr)
{

   if(this != &nstr)                           //判断重载操作数是否为同一个对象
   {
      char * tem = new char[nstr._capacity+1];  
      strcpy(tem,nstr._str);
      delete[] _str;                           //释放原来的堆区空间
      _str = tem;
      _size = nstr._size;
      _capacity = nstr._capacity;
    }
    return *this;

}
注意不能直接用_str去接收新申请的堆区空间地址(因为new可能会失败)
注意返回对象本身的引用*this(使=重载可以满足连等赋值)
赋值运算符重载也可以通过复用拷贝构造来实现：

string& mystring::string::operator=(string nstr)     
{
    copyswap(nstr);
    return (*this);
}

复用拷贝构造实现赋值运算符重载的思路：
5.关于两个string对象的内容交换问题
STL的标准库中string类中有成员交换函数swap(相当于本篇模拟实现中的copyswap成员函数),使用成员函数完成两个string对象的内容交换效率远高于直接使用全局swap函数(相当于本篇模拟实现中的myswap函数)完成两个string对象的内容交换
直接调用全局交换函数交换两个string对象会额外调用对象的拷贝构造函数和赋值运算符重载从而增加性能消耗(new申请空间的性能消耗是很大的)
比如：

using mystring::string;
using mystring::myswap;

int main()
{

string a("hello");
string b("world");

myswap(a,b);    交换方式一(直接调用全局交换函数)

a.copyswap(b);  交换方式二(调用成员交换函数)

return 0;

}

两种对象交换的方式差异图解：

三.string类的迭代器
string类的迭代器可以typedef为字符指针

mystring::string::iterator mystring::string:: begin()
{
    return _str;
}
mystring::string::iterator mystring::string::end()
{
    return _str+_size; 
}
mystring::string::const_iterator mystring::string::begin()const
{
    return _str;
}
mystring::string::const_iterator mystring::string::end()const
{
    return _str+_size;
}

四.string类的[]成员重载
string类的[]成员重载用于返回字符串中指定下标的字符的引用

char &  mystring::string::operator[](int pos)
{
    assert(pos<_size);
    return _str[pos];
}
const char &  mystring::string::operator[](int pos) const
{
    assert(pos<_size);
    return _str[pos];
}

const修饰的重载成员是供const修饰的string对象调用的
完整代码：

include

include

include <assert.h>

//只要不涉及寻址，一定要注意编译器的顺序编译机制

namespace mystring
{

class string
{
    public:
        typedef char * iterator; 
        typedef const char* const_iterator;



        string(const char* nstr);                  //类中四个重要的默认成员函数
        string(const string& nstr);
        ~string();
        string& operator=(string nstr);


        void copyswap(string &nstr);               //复用交换函数的接口
        iterator begin();                          //string类用于获取迭代器的接口
        iterator end();
        const_iterator begin()const;
        const_iterator end()const;
        const char * C_str()const;                 //用于返回C类型字符串的函数
        char & operator[](int pos);                //用于返回pos下标字符的引用的[]重载
        const char & operator[](int pos) const;     
        size_t size() const;                       //获取有效字符个数size和容量的接口
        size_t capacity() const;
    private:
        char * _str;
        size_t _size;
        size_t _capacity;
};



template <typename T>
void myswap (T& e1 , T&e2)
{
    T tem = e1;
    e1 = e2;
    e2 =tem;
}
void mystring::string::copyswap(string & nstr)
{
    myswap(_str,nstr._str);
    myswap(_size,nstr._size);
    myswap(_capacity,nstr._capacity);
}
const char * mystring::string::C_str() const
{
    return _str;
}


mystring::string::string(const char* nstr = "")  //缺省值用于构造空字符串(会完成'\0'的拷贝)(注意缺省参数只能写在声明和定义其中一个之中)
:_size(strlen(nstr))                             //strlen函数中有关于空指针的断言,所以构造函数中无须进行空指针判断
,_capacity (_size)
{                          
    _str = new char[_capacity+1];                // +1是为了保存'\0'(不计入容量和有效字符),同时保证_str不为空指针(对象只要创建出来就一定维护一块堆空间)
    strcpy(_str,nstr);
}
// mystring::string::string(const string& nstr)  //非复用式写法
// :_size(nstr._size)
// ,_capacity(nstr._capacity)
// {
//     _str = new char[_capacity+1];             // +1是为了保存'\0'(不计入容量和有效字符),同时保证_str不为空指针
//     strcpy(_str,nstr._str);
// }
mystring::string::string(const string& nstr)     //复用构造函数完成拷贝构造
:_str (nullptr)                                  //防止tem中_str作为野指针被释放
,_size(0)
,_capacity(0)
{
    string tem(nstr._str);                       //拷贝的是不含'\0'的有效字符
    this->copyswap(tem);                         //为了方便阅读加上this指针
}


// string& mystring::string::operator=(const string& nstr)
// {
//     if(this != &nstr)                             //判断重载操作数是否为同一个对象
//     {
//         char * tem = new char[nstr._capacity+1];  // +1是为了保存'\0'(不计入容量和有效字符)
//         strcpy(tem,nstr._str);
//         delete[] _str;
//         _str = tem;
//         _size = nstr._size;
//         _capacity = nstr._capacity;
//     }
//     return *this;
// }
string& mystring::string::operator=(string nstr)     //与直接交换对象作对比
{
    copyswap(nstr);
    return (*this);
}
mystring::string::~string()
{
    if(_str)
    {
        delete[] _str;
        _str=nullptr;
    }
    _size=0;
    _capacity=0;
}




mystring::string::iterator mystring::string:: begin()
{
    return _str;
}
mystring::string::iterator mystring::string::end()
{
    return _str+_size; 
}
mystring::string::const_iterator mystring::string::begin()const
{
    return _str;
}
mystring::string::const_iterator mystring::string::end()const
{
    return _str+_size;
}




char &  mystring::string::operator[](int pos)
{
    assert(pos<_size);
    return _str[pos];
}
const char &  mystring::string::operator[](int pos) const
{
    assert(pos<_size);
    return _str[pos];
}


size_t mystring::string::size() const
{
    return _size;
}
size_t mystring::string::capacity() const
{
    return _size;
}

string类模拟实现(下) ：http://t.csdn.cn/aMGuP

文章标签：
C++
编译器
关键词：
C++ string
String c++
认真写博客的夏目浅石.
目录
相关文章
ephemerals__
|
2月前
|
C语言 C++ 容器
【c++丨STL】string模拟实现（附源码）
本文详细介绍了如何模拟实现C++ STL中的`string`类，包括其构造函数、拷贝构造、赋值重载、析构函数等基本功能，以及字符串的插入、删除、查找、比较等操作。文章还展示了如何实现输入输出流操作符，使自定义的`string`类能够方便地与`cin`和`cout`配合使用。通过这些实现，读者不仅能加深对`string`类的理解，还能提升对C++编程技巧的掌握。
ephemerals__
101 5
ephemerals__
|
2月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
78 2
努力学习的小廉
|
3月前
|
C++ 容器
【C++】 —— string的使用（二）
【C++】 —— string的使用
努力学习的小廉
110 2
【C++】 —— string的使用（二）
白子寰
|
3月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
白子寰
39 1
努力学习的小廉
|
3月前
|
C++ 容器
【C++】—— string模拟实现（二）
【C++】—— string模拟实现
努力学习的小廉
41 1
努力学习的小廉
|
3月前
|
C++ 容器
【C++】—— string模拟实现（一）
【C++】—— string模拟实现
努力学习的小廉
75 1
努力学习的小廉
|
3月前
|
存储 C++ 容器
【C++】 —— string的使用（一）
【C++】 —— string的使用
努力学习的小廉
43 1
半截诗
|
3月前
|
安全 C语言 C++
【C++篇】探寻C++ STL之美：从string类的基础到高级操作的全面解析
【C++篇】探寻C++ STL之美：从string类的基础到高级操作的全面解析
半截诗
60 4
半截诗
|
3月前
|
存储 编译器 程序员
【C++篇】手撕 C++ string 类：从零实现到深入剖析的模拟之路
【C++篇】手撕 C++ string 类：从零实现到深入剖析的模拟之路
半截诗
90 2
是店小二呀
|
3月前
|
编译器 C语言 C++
【C++】C++ STL 探索：String的使用与理解（三）
【C++】C++ STL 探索：String的使用与理解
是店小二呀
78 2