C++面试中string类的一种正确写法

C++面试中string类的一种正确写法

(感谢网友 @bnu_chenshuo 投稿)

C++ 的一个常见面试题是让你实现一个 String 类,限于时间,不可能要求具备 std::string 的功能,但至少要求能正确管理资源。具体来说:

  1. 能像 int 类型那样定义变量,并且支持赋值、复制。
  2. 能用作函数的参数类型及返回类型。
  3. 能用作标准库容器的元素类型,即 vector/list/deque 的 value_type。(用作 std::map 的 key_type 是更进一步的要求,本文从略)。

换言之,你的 String 能让以下代码编译运行通过,并且没有内存方面的错误。

void foo(String x)
{
}

void bar(const String& x)
{
}

String baz()
{
  String ret("world");
  return ret;
}

int main()
{
  String s0;
  String s1("hello");
  String s2(s0);
  String s3 = s1;
  s2 = s1;

  foo(s1);
  bar(s1);
  foo("temporary");
  bar("temporary");
  String s4 = baz();

  std::vector<String> svec;
  svec.push_back(s0);
  svec.push_back(s1);
  svec.push_back(baz());
  svec.push_back("good job");
}

本文给出我认为适合面试的答案,强调正确性及易实现(白板上写也不会错),不强调效率。某种意义上可以说是以时间(运行快慢)换空间(代码简洁)。

首先选择数据成员,最简单的 String 只有一个 char* 成员变量。好处是容易实现,坏处是某些操作的复杂度较高(例如 size() 会是线性时间)。为了面试时写代码不出错,本文设计的 String 只有一个 char* data_成员。而且规定 invariant 如下:一个 valid 的 string 对象的 data_ 保证不为 NULL,data_ 以 '\0' 结尾,以方便配合 C 语言的 str*() 系列函数。

其次决定支持哪些操作,构造、析构、拷贝构造、赋值这几样是肯定要有的(以前合称 big three,现在叫 copy control)。如果钻得深一点,C++11的移动构造和移动赋值也可以有。为了突出重点,本文就不考虑 operator[] 之类的重载了。

这样代码基本上就定型了:

#include <utility>
#include <string.h>

class String
{
 public:
  String()
    : data_(new char[1])
  {
    *data_ = '\0';
  }

  String(const char* str)
    : data_(new char[strlen(str) + 1])
  {
    strcpy(data_, str);
  }

  String(const String& rhs)
    : data_(new char[rhs.size() + 1])
  {
    strcpy(data_, rhs.c_str());
  }
  /* Delegate constructor in C++11
  String(const String& rhs)
    : String(rhs.data_)
  {
  }
  */

  ~String()
  {
    delete[] data_;
  }

  /* Traditional:
  String& operator=(const String& rhs)
  {
    String tmp(rhs);
    swap(tmp);
    return *this;
  }
  */
  String& operator=(String rhs) // yes, pass-by-value
  {
    swap(rhs);
    return *this;
  }

  // C++ 11
  String(String&& rhs)
    : data_(rhs.data_)
  {
    rhs.data_ = nullptr;
  }

  String& operator=(String&& rhs)
  {
    swap(rhs);
    return *this;
  }

  // Accessors

  size_t size() const
  {
    return strlen(data_);
  }

  const char* c_str() const
  {
    return data_;
  }

  void swap(String& rhs)
  {
    std::swap(data_, rhs.data_);
  }

 private:
  char* data_;
};

注意代码的几个要点:

  1. 只在构造函数里调用 new char[],只在析构函数里调用 delete[]。
  2. 赋值操作符采用了《C++编程规范》推荐的现代写法。
  3. 每个函数都只有一两行代码,没有条件判断。
  4. 析构函数不必检查 data_ 是否为 NULL。
  5. 构造函数 String(const char* str) 没有检查 str 的合法性,这是一个永无止境的争论话题。这里在初始化列表里就用到了 str,因此在函数体内用 assert() 是无意义的。

这恐怕是最简洁的 String 实现了。

练习1:增加 operator==、operator<、operator[] 等操作符重载。

练习2:实现一个带 int size_; 成员的版本,以空间换时间。

练习3:受益于右值引用及移动语意,在 C++11 中对 String 实施直接插入排序的性能比C++98/03要高,试编程验证之。(g++的标准库也用到了此技术。)

陈皓注:同时,大家可以移步看看我的一篇老文《STL中String类的问题


关注CoolShell微信公众账号可以在手机端搜索文章

(转载本站文章请注明作者和出处 酷 壳 – CoolShell ,请勿用于任何商业用途)

——=== 访问 酷壳404页面 寻找遗失儿童。 ===——


本广告收入已由广告主捐给Wikipedia

好烂啊有点差凑合看看还不错很精彩 (25 人打了分,平均分: 4.16 )
Loading...

C++面试中string类的一种正确写法》的相关评论

  1. 问一下,赋值函数使用《C++编程规范》推荐的现代写法,具体是指什么?
    不使用引用传递而使用值传递,是如何考虑的呢?

  2. 代码第10行以及上文的描述中,字符串结束标志是” ,不应该是’ ‘,估计是在发布文章时候,被博客的排版系统给修改了吧。

  3. String& operator=(String&& rhs)
    {
    swap(rhs);
    return *this;
    }
    swap 会自动考虑 内存扩展的问题的嘛?比如 string1=“d”。string2=“ddddddd”,string1的_data会自动变长嘛?

  4. 请教下,用swap(值操作下,实现copy),比strcpy高在哪里?swap内部实现只是,拷贝个指针?

  5. 学习了下,swap的好处(完整的来龙去脉,还有C++11 的 move constructor)请参考http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom
    string类的copy on write 的实现,在不同版本的C++ compiler上 不同或不实现,别太在意。

  6. String& operator=(String rhs) // yes, pass-by-value
    {
    swap(rhs);
    return *this;
    }
    这个也没看懂,不是一个复制符吗?为什么要swap呢?

  7. String& operator=(String rhs) // yes, pass-by-value
    {
    swap(rhs);
    return *this;
    }
    使用swap的原因是,这个String类涉及到内存分配操作,这个操作可能会抛出异常;
    上面的实现分3步:
    1 把“源对象”拷贝到参数rhs里
    2 rhs对象和this对象做一下交换(仅仅交换指针)
    3 返回this对象

    第一步有可能发生异常(new操作失败),然后在这一步退出;这是下两歩操作还没有进行,所以不会污染this对象。保证了:
    1 赋值操作失败,但是this对象没有被污染,或者
    2 赋值操作成功

  8. String& operator=(String&& rhs)
    {
    swap(rhs);
    return *this;
    }
    这个没有必要,而写你没有把rhs的内容null掉
    那个pass-by-value的operator=可以做完这里的工作
    性能没啥损失,代码还简洁

  9. jerry :
    String& operator=(String&& rhs)
    {
    swap(rhs);
    return *this;
    }
    这个没有必要,而写你没有把rhs的内容null掉
    那个pass-by-value的operator=可以做完这里的工作
    性能没啥损失,代码还简洁

    Sorry, 不需要null掉,脑子抽经了
    不过确实不需要写,代码多了坏事

  10. 我是一个老了的程序员,看到“char* data_;”还是感觉很陌生的,因为我常写成“char* m_lpszData”,可能是我脑子里没有什么规范了。

    另外,第一第二个构造函数我喜欢合并到一块,会写成:
    String(const char* lpszStr = NULL)
    {
    if(lpszStr == NULL)
    {
    m_nDataSize = 0; //成员变量,记录数据长度
    m_nBuffSize = 8; //成员变量,记录内存长度

    m_lpszData = new char[m_nBuffSize];
    m_lpszData[0] = ”;
    }
    else //if(lpszStr != NULL)
    {
    m_nDataSize = strlen(lpszStr); //数据长度
    m_nBuffSize = 8 * (m_nDataSize / 8 + 1);//按8为粒度分配内存

    m_lpszData = new char[m_nBuffSize];
    strcpy(m_lpszData, lpszStr);
    }
    }
    不仅仅是字符串类,一般支持增长的数据结构我都习惯于增加两个成员变量,一个记录数据的长度,一个记录内存分配的长度,这样在一定程度上可以减少内存分配拷贝释放等操作的次数以提升性能,其它小好处还有一些,不多说了。

    另外,对于字符串类,不管是MFC中的CString还是各个版本的STL,我认为还有一些可以优化的空间,比如:
    一、“+=”操作,在很多项目中都会频繁地做尾部追加操作的,而这个操作如果能得到优化,那么对整体性能的提升比较明显。这个相对比较重复,我在别处有详细描述。
    二、格式化输出操作,传统的处理方案在实现上会有两次的格式化,第一次是为了获取所需要内存长度,第二次才是真正的格式化输出。在性能要求比较高的场合,比如服务器,完全可以省掉第一步的操作而获得近一倍性能的提升。

    还有太多的想法,不说了,这只是我个人的习惯,或者对或者错,我也不多想了,如果你有兴趣多想想或许也不差。

  11. 热爱这项工作,开发也有十几年了,可是看了大牛的作品后,就觉得还没得精髓。总之,一步一个脚印,希望能在某个领域做到精通。

  12. String& operator=(String rhs) // yes, pass-by-value
    {
    swap(rhs);
    return *this;
    }

    String& operator=(String&& rhs)
    {
    swap(rhs);
    return *this;
    }

    这个重载有歧义,这么长时间了竟然没人发现?不知道都看的是什么。

  13. @哎
    没有歧义啊。
    如果是右值的话,第二个函数是更好匹配了,会调用第二个。
    如果是一个左值会调用第一个。

  14. 有memory leak,用valgrind查了以后证明的确有,在复制一个String对象的时候,假如接收的String本身data_不为空,你的String(const char *str, std::size_t len)函数会直接把data_指向了新allocate的memory而没有释放之前allocate的memory。

  15. 求问:
    类的swap方法代码如下:
    void swap(String& rhs)
    {
    std::swap(data_, rhs.data_);
    }
    为什么可以直接访问 rhs参数的私有成员 data_ ?

发表评论

电子邮件地址不会被公开。 必填项已用*标注