【C++复习】实现一个简单的string类【C++面试小题】

写在前面

写一个简单的string类，在面试中经常出现，如果我们被问到要求手写一个简单的string类，我们要实现的主要就是

• 只处理资源，不考虑增删。
• 查改最好写现代写法。
• 如果可以，写上右值引用移动构造 + 移动赋值(c++11内容)

string类

简单、不考虑增删的string类实现

namespace Amor{
	class string
	{
	private:
		char* str_;
	public:
		string();//无参构造
		string(const char* str);//带参构造
		string(const string& s);//拷贝构造
		string(string&& s);//移动构造
    
		~string();//析构
		
		string& operator=(const string& s);//赋值
    string& operator=(string&& s);//移动赋值
    
		char& operator[](size_t pos);//访问
		
	};
}

既然要简单的实现，就不需要考虑太多增删（就是不设计size 和capacity 成员变量），而是多考虑资源的申请和释放。

construction

//无参构造
string::string()
	:str_(new char[1])
{
	str_[0] = '\0';
}
//const char* 带参构造
string::string(const char* str)
{
  str_ = new char
}
//拷贝构造
    string::string(const string& s)
        :str_(nullptr)
    {
        string tmp(s.str_);
        swap(str_,tmp.str_);
    }
    template<class T>
    void swap(T& a, T& b){
        T tmp(a);
        a = b;
        b = tmp;
    }
    /* 移动构造 */
    string::string(string&& s)
        :str_(nullptr)
    {
        swap(str_,s.str_);
    }

destruction

    string::~string()
    {
        delete[] str_;
        str_ = nullptr;
    }
//删除资源，指针置空。

赋值

    /* 移动赋值 */
    string& string::operator=(string&& s)
    {
        if(this != &s)
        {
            string tmp(s.str_);
            swap(str_, tmp.str_);
        }
        return *this;
    }
    string& string::operator=(const string& s)
    {
        if(this != &s)
        {
            string tmp(s.str_);
            swap(str_, tmp.str_);
        }
        return *this;
    }
    //写法2:
    string& string::operator=(string s)
    {
        swap(str_,s.str_);
        return *this;
    }

访问

    //[]
    char& string::operator[](size_t pos)
    {
        assert(pos >= 0);
        return str_[pos];
    }
    const char& string::operator[](size_t pos) const
    {
        assert(pos >= 0);
        return str_[pos];
    }

这里写两个版本的，因为const 属性的字符串是无法访问不带const的 []重载的。

总结

简单的、不考虑增删的string类实现是非常简单，关键点就在于：string类的设计：只要const char* 类型的一个成员变量。然后围绕这个成员变量展开

• 查（operator[]）
• 构造函数 （无参、带参、移动构造、拷贝构造）
• 析构函数
• 赋值 （现代写法 和 移动赋值）

主干写好，就可以完成简单的string类，如果大家想研究的更深入包括整个string类的模拟实现，包括operator=, +=, >, <, ==, swap, reverse等等函数的模拟实现，请移步：如何完整的实现一个string类