【C++】string类模拟实现过程中值得注意的点

👀樊梓慕：个人主页

🎥个人专栏：《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》

🌝每一个不曾起舞的日子，都是对生命的辜负

前言

1.有关const的使用

（1）const修饰形参

（2）const修饰返回值

（3）const修饰成员函数

2.有关声明与定义分离可能出现的问题

（1）合并命名空间

（2）指定类域

（3）当声明与定义分离时，缺省参数只需要在声明中体现

（4）函数重定义问题

3.有关模拟实现的传统写法与现代写法

4.有关string类流插入和流提取操作符的实现思维定势陷阱

前言

本篇文章旨在记录博主在模拟实现string类中遇到的一些问题，希望与大家共勉，在模拟实现string类的过程中运用了之前所学的很多知识，包括一些问题的出现都是对之前所学知识的考验，为了更加深入的了解和掌握string类，大家不妨跟随博主的步伐一起，看看遇到这些问题时，你是否可以轻松应对，利用之前所学解决实际问题。

欢迎大家📂收藏📂以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。

=========================================================================

GITEE相关代码：🌟fanfei_c的仓库🌟

=========================================================================

1.有关const的使用

（1）const修饰形参

首先我们来看string类中这些函数的模拟实现：

//relational operators
bool operator>(const string& s);
bool operator==(const string& s);
bool operator<=(const string& s);
bool operator<(const string& s);
bool operator>=(const string& s);      
bool operator!=(const string& s);

为什么用const修饰形参？

const修饰形参的意义主要体现在输入型参数上，尤其是指针类型和引用，const修饰某个变量，肯定是为了保护该变量的值不被改变。

那什么时候我们需要保护这个值不会被改变呢？

当然是我们需要他作为函数的输入时，输出型参数我们需要他根据函数功能做出改变，所以肯定不需要用const修饰。

那我为什么又说const修饰输入型参数尤其在指针类型和引用呢？其他普通类型呢？

因为我们知道形参是实参的一份临时拷贝，形参的改变不会影响实参，所以我们也就不需要保护它，因为它的改变不会影响到实参本身。

那为什么要用引用，我直接传不就得了，反正也只是拷贝，不会影响本身，这样也省得使用const来保护了。

这里传递引用的价值就在于可以极大的优化节省调用函数的代价！

我们知道引用就是本身的一个别名，实际上就是本身，所以当我们传递引用时，就节省了拷贝的代价，为了效率我们值得做出这样的操作，但为了保护好我们本身不被修改，一定要用const修饰，这样可以增强程序的健壮性！防止我们的程序崩溃。

（2）const修饰返回值

同样我们用模拟实现来引入。

//access
char& operator[](size_t index);
const char& operator[](size_t index)const;

这里为什么要实现两个版本的下标访问？

类的有些对象可能可以改变，有的不能改变，举个例子来说，对于string对象来说，有的我们可能希望定义的string对象可以改变，有的则不能改变：

string str1= "hello world";

const string str2 = "hello world";

我们如果进行下标操作符运算，str1[0]='f'这是允许的，而str2[1]='f'则是不允许的。

并且这两个操作调用的成员函数也是不一样的，前一个调用的是string类的非const成员函数，后一个调用的是string类的const成员函数

如果我们没有定义const成员函数，则str2会调用相应的非const成员函数，从而导致我们本来不想其被修改的对象被意外修改。

const修饰返回值的意义何在？

实际上，如果函数返回的是普通的变量，即值传递，那确实没有什么意义，因为根据前面的学习，函数是如何返回值的呢，实际上是拷贝，拷贝一份内容相同的常量返回，那它本来就是常量你再用const修饰那不多此一举了么。

是的，所以如果函数返回采用值传递的方式，那const这里就没有任何意义。

const修饰返回值真正的意义在于指针传递返回，用来赋值给const修饰的指针内容。

例如函数：

const char* string::c_str()const
{
    return _str;
}

接收这个函数的返回值我们需要：

void test5()
{
    string s1 = "hello world!!!!!!!!!!!!!!!!";
    const char* tmp=s1.c_str();
    cout << tmp << endl;
}

为什么要使用引用做返回值？

首先明确：

之前我们说过，除了函数作用域，返回对象就会被销毁，不能用引用返回，否则结果是不确定的。

那这里为什么可以这样使用呢？

是因为string所使用的空间为动态内存new来的，我们说引用做返回值，可用静态变量或动态内存。

引用做返回值的主要目的就是能够修改返回的内容，加const是为了适配const string str="abc"这种被const修饰了的字符串。

（3）const修饰成员函数

同样我们用string类的模拟实现引入：

// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const;
// 返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos = 0) const;

const修饰成员函数实际上修饰的是该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

任何不会修改数据成员的函数都应该声明为const 类型（这样const对象和非const对象都可以调用该函数）。如果在编写const 成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提高程序的健壮性。

即，

const对象不可以调用非const成员函数；
非const对象可以调用const成员函数；
const成员函数内部不能调用其他非const成员函数；
非const成员函数内部可以调用其他const成员函数。

总结为：权限可以缩小，但是权限不可以放大！

2.有关声明与定义分离可能出现的问题

博主在实现string类时，统一的把函数定义都以内联的形式实现了，当然后期实现完成尝试着想要声明与定义分离下，但却出现了很多报错，这里我梳理一下，形成了以下内容。

（1）合并命名空间

首先分离后的第一个问题就是，由于我之前在头文件中类的实现部分都包含在了命名空间内部。

即，

所以首先需要解决这一问题，我们可以采用左图这种方式，当然右面的方式显然更好：

（2）指定类域

由于声明定义分离，所以我们需要指定类域：

（3）当声明与定义分离时，缺省参数只需要在声明中体现

（4）函数重定义问题

如果.h文件中存在函数定义（不包括成员函数），只要存在多个cpp文件，并且他们都包含了string.h头文件，那他们在展开时就会出现重定义的问题。

3.有关模拟实现的传统写法与现代写法

我们来观察一下两种实现方式的区别：

//传统写法
string::string(const string& s)
{
    _str = new char[s._capacity + 1];
    strcpy(_str, s._str);
    _size = s._size;
    _capacity = s._capacity;
}
//现代写法
string::string(const string& s)
{
    string tmp(s._str);
    swap(tmp);
}
//结合swap来观察
void string::swap(string& s)
{
    std::swap(_str, s._str);
    std::swap(_size, s._size);
    std::swap(_capacity, s._capacity);
}

那现代写法优越在哪呢？

现代写法非常巧妙，他完全利用了我们学习构造函数部分的知识。

首先完成用s._str完成构造tmp对象，然后交换*this与tmp，交换后tmp析构。

4.有关string类流插入和流提取操作符的实现思维定势陷阱

在之前的学习中，我们知道流插入与流提取的实现要放在全局从而保证第一个参数不为this指针，但当时面临一个问题，我们实现的是日期类，想要打印日期类就必须访问到类的成员变量，但我们知道成员变量一般都是私有的，所以我们引入了友元的概念用来解决这一问题。

=========================🐸这部分忘了的老铁可以戳🐸=========================

樊梓慕---类和对象（中）之拷贝构造与运算符、操作符重载【CSDN】http://t.csdnimg.cn/2wbiI🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸🐸

但这里我们需不需要利用友元呢？

ostream& operator<<(ostream& _cout, const F::string& s)
{
    for (auto e : s)
    {
        _cout << e;
    }
    return _cout;
}
istream& operator>>(istream& _cin, F::string& s)
{
    s.clear();
    char buff[128];
    char ch = _cin.get();
    int i = 0;
    while (ch != ' ' && ch != '\n')
    {
        buff[i++] = ch;
        if (i == 127)
        {
            buff[i] = '\0';
            s += buff;
            i = 0;
        }
        ch = _cin.get();
    }

    if (i > 0)
    {
        buff[i] = '\0';
        s += buff;
    }
    return _cin;
}

我们并没有访问string类的成员变量，所以这里不需要利用友元！

🚨请不要形成思维定势，要活学活用🚨

=========================================================================

如果你对该系列文章有兴趣的话，欢迎持续关注博主动态，博主会持续输出优质内容

🍎博主很需要大家的支持，你的支持是我创作的不竭动力🍎

🌟~ 点赞收藏＋关注 ~🌟

=========================================================================