《C++ Primer》第12章 12.1节习题答案

《C++ Primer》第12章 动态内存

导读本章介绍了智能指针与动态内存管理，包括：

●智能指针的基本概念，特别是用它来管理动态内存的好处。

●用allocator管理动态数组。

●用文本查询这样一个较大的例子来展示动态内存管理。

本章练习的重点是让读者熟悉智能指针的使用，包括使用shared_ptr和unique_ptr管理动态内存时要注意的一些问题；用allocator管理动态数组；以及基于文本查询例子的一些较大的练习。

12.1节动态内存与智能指针 习题答案

练习12.1：在此代码的结尾，b1和b2各包含多少个元素？

StrBlob b1;
{
    StrBlob b2 = {"a", "an", "the"};
    b1 = b2;
    b2.push_back("about");
}

【出题思路】

理解智能指针的基本特点。

【解答】

由于StrBlob的data成员是一个指向string的vector的shared_ptr，因此StrBlob的赋值不会拷贝vector的内容，而是多个StrBlob对象共享同一个（创建于动态内存空间上）vector对象。代码第3行创建b2时提供了3个string的列表，因此会创建一个包含3个string的vector对象，并创建一个shared_ptr指向此对象（引用计数为1）。第4行将b2赋予b1时，创建一个shared_ptr也指向刚才创建的vector对象，引用计数变为2。因此，第4行向b2添加一个string时，会向两个StrBlob共享的vector中添加此string。最终，在代码结尾，b1和b2均包含4个string。

练习12.2：编写你自己的StrBlob类，包含const版本的front和back。

【出题思路】

本题练习智能指针的简单使用。

【解答】

参考书中代码，并补充front和back对const的重载，即可完成自己的StrBlob类：

#ifndef SYSTRBLOB_H
#define SYSTRBLOB_H

#include <vector>
#include <string>
#include <initializer_list>
#include <memory>
#include <stdexcept>

using namespace std;

class StrBlob
{
public:
    typedef vector<string>::size_type size_type;
    StrBlob();
    StrBlob(initializer_list<string> i1);
    size_type size() const { return data->size(); }
    bool empty() const { return data->empty(); }
    //添加和删除元素
    void push_back(const string &t) { data->push_back(t); }
    void pop_back();
    //元素访问
    string& front();
    const string& front() const;
    string& back();
    const string& back() const;

private:
    shared_ptr<std::vector<std::string>> data;
    //如果data[i]不合法，抛出一个异常
    void check(size_type i, const std::string &msg) const;
};

#endif // SYSTRBLOB_H

#include "SYStrBlob.h"

StrBlob::StrBlob():data(make_shared<vector<string>>())
{

}

StrBlob::StrBlob(initializer_list<string> i1):data(make_shared<vector<string>>(i1))
{

}

void StrBlob::check(size_type i, const string &msg) const
{
    if(i >= data->size())
        throw out_of_range(msg);
}

string& StrBlob::front()
{
    //如果vector为空，check会抛出一个异常
    check(0, "front on empty StrBlob");
    return data->front();
}

//const版本front
const string& StrBlob::front() const
{
    check(0, "front on empty StrBlob");
    return data->front();
}

string& StrBlob::back()
{
    check(0, "back on empty StrBlob");
    return data->back();
}

//const版本back
const string& StrBlob::back() const
{
    check(0, "back on empty StrBlob");
    return data->back();
}

void StrBlob::pop_back()
{
    check(0, "pop_back on empty StrBlob");
    data->pop_back();
}

#include <iostream>
#include "SYStrBlob.h"

using std::cout;
using std::endl;

int main(int argc, const char * argv[])
{
    StrBlob b1;
    {
        StrBlob b2 = {"a", "an", "the"};
        b1 = b2;
        b2.push_back("about");
        cout << "b2.size==================" << b2.size() << endl;
    }
    cout << "b1.size==================" << b1.size() << endl;
    cout << b1.front() << "  " << b1.back() << endl;

    const StrBlob b3 = b1;
    cout << b3.front() << "  " << b3.back() << endl;
    return 0;
}

运行结果：

 

练习12.3：StrBlob需要const版本的push_back和pop_back吗？如果需要，添加进去。否则，解释为什么不需要。

【出题思路】

理解const版本和非const版本的差别。

【解答】

push_back和pop_back的语义分别是向StrBlob对象共享的vector对象添加元素和从其删除元素。因此，我们不应为其重载const版本，因为常量StrBlob对象是不应被允许修改共享vector对象内容的。

练习12.4：在我们的check函数中，没有检查i是否大于0。为什么可以忽略这个检查？

【出题思路】

理解私有成员函数和公有成员函数的差别。

【解答】

我们将check定义为私有成员函数，亦即，它只会被StrBlob的成员函数调用，而不会被用户程序所调用。因此，我们可以很容易地保证传递给它的i的值符合要求，而不必进行检查。

练习12.5：我们未编写接受一个initializer_list explicit（参见7.5.4节，第264页）参数的构造函数。讨论这个设计策略的优点和缺点。

【出题思路】

复习隐式类类型转换和显式转换的区别。

【解答】

未编写接受一个初始化列表参数的显式构造函数，意味着可以进行列表向StrBlob的隐式类型转换，亦即在需要StrBlob的地方（如函数的参数），可以使用列表进行替代。而且，可以进行拷贝形式的初始化（如赋值）。这令程序编写更为简单方便。

但这种隐式转换并不总是好的。例如，列表中可能并非都是合法的值。再如，对于接受StrBlob的函数，传递给它一个列表，会创建一个临时的StrBlob对象，用列表对其初始化，然后将其传递给函数，当函数完成后，此对象将被丢弃，再也无法访问了。对于这些情况，我们可以定义显式的构造函数，禁止隐式类类型转换。

练习12.6：编写函数，返回一个动态分配的int的vector。将此vector传递给另一个函数，这个函数读取标准输入，将读入的值保存在vector元素中。再将vector传递给另一个函数，打印读入的值。记得在恰当的时刻delete vector。

【出题思路】

本题练习用new和delete直接管理内存。

【解答】

直接内存管理的关键是谁分配了内存谁就要记得释放。在此程序中，主函数调用分配函数在动态内存空间中创建int的vector，因此在读入数据、打印数据之后，主函数应负责释放vector对象。

#include <iostream>
#include <vector>
#include <new>

using std::cout;
using std::endl;
using std::vector;
using std::nothrow;
using std::cin;

vector<int> *new_vector(void)
{
    return new (nothrow) vector<int>;
}

void read_ints(vector<int> *pv)
{
    int v;
    while(cin >> v)
    {
        pv->push_back(v);
    }
}

void print_ints(vector<int> *pv)
{
    for(const auto &v: *pv)
        cout << v << " ";
    cout << endl;
}

int main(int argc, const char * argv[])
{

    vector<int> *pv = new_vector();
    if(!pv)
    {
        cout << "内存不足！" << endl;
        return -1;
    }

    read_ints(pv);
    print_ints(pv);
    delete pv;
    pv = nullptr;
    std::cout << "Hello, World!\n";
    return 0;
}

运行结果：

 练习12.7：重做上一题，这次使用shared_ptr而不是内置指针。

【出题思路】

本题练习用智能指针管理内存。

【解答】

与上一题相比，程序差别不大，主要是将vector<int> *类型变为shared_ptr<vector<int>>类型，空间分配不再用new而改用make_shared，在主函数末尾不再需要主动释放内存。最后一点的意义对这个小程序还不明显，但对于大程序非常重要，它省去了程序员释放内存的工作，可以有效避免内存泄漏问题。

#include <iostream>
#include <vector>
#include <memory>

using namespace std;

shared_ptr<vector<int>> new_vector(void)
{
    return make_shared<vector<int>>();
}

void read_ints(shared_ptr<vector<int>> spv)
{
    int v;
    while(cin >> v)
        spv->push_back(v);
}

void print_ints(shared_ptr<vector<int>> spv)
{
    for(const auto &v: *spv)
        cout << v << " ";
    cout << endl;
}

int main(int argc, const char * argv[])
{
    auto spv = new_vector();

    read_ints(spv);
    print_ints(spv);

    return 0;
}

运行结果：

 

练习12.8：下面的函数是否有错误？如果有，解释错误原因。

bool b() {
    int *p = new int;
    // ...
    return p;
}

【出题思路】

理解用new分配内存成功和失败的差别，以及复习类型转换。

【解答】

从程序片段看，可以猜测程序员的意图是通过new返回的指针值来区分内存分配成功或失败——成功返回一个合法指针，转换为整型是一个非零值，可转换为bool值true；分配失败，p得到nullptr，其整型值是0，可转换为bool值false。

但普通new调用在分配失败时抛出一个异常bad_alloc，而不是返回nullptr，因此程序不能达到预想的目的。

可将new int改为new (nothrow)int来令new在分配失败时不抛出异常，而是返回nullptr。但这仍然不是一个好方法，应该通过捕获异常或是判断返回的指针来返回true或false，而不是依赖类型转换。

练习12.9：解释下面代码执行的结果：

int *q = new int(42), *r = new int(100);
r = q;
auto q2 = make_shared<int>(42), r2 = make_shared<int>(100);
r2 = q2;

【出题思路】

理解直接管理内存和智能指针的差别。

【解答】

这段代码非常好地展示了智能指针在管理内存上的优点。

对于普通指针部分，首先分配了两个int型对象，指针分别保存在p和r中。接下来，将指针q的值赋予了r，这带来了两个非常严重的内存管理问题：

1．首先是一个直接的内存泄漏问题，r和q一样都指向42的内存地址，而r中原来保存的地址——100的内存再无指针管理，变成“孤儿内存”，从而造成内存泄漏。

2．其次是一个“空悬指针”问题。由于r和q指向同一个动态对象，如果程序编写不当，很容易产生释放了其中一个指针，而继续使用另一个指针的问题。继续使用的指针指向的是一块已经释放的内存，是一个空悬指针，继续读写它指向的内存可能导致程序崩溃甚至系统崩溃的严重问题。

而shared_ptr则可很好地解决这些问题。首先，分配了两个共享的对象，分别由共享指针p2和q2指向，因此它们的引用计数均为1。接下来，将q2赋予r2。赋值操作会将q2指向的对象地址赋予r2，并将r2原来指向的对象的引用计数减1，将q2指向的对象的引用计数加1。这样，前者的引用计数变为0，其占用的内存空间会被释放，不会造成内存泄漏。而后者的引用计数变为2，也不会因为r2和q2之一的销毁而释放它的内存空间，因此也不会造成空悬指针的问题。

练习12.10：下面的代码调用了第413页中定义的process函数，解释此调用是否正确。如果不正确，应如何修改？

shared_ptr<int> p(new int(42));
process(shared_ptr<int>(p));

【出题思路】

理解智能指针的使用。

【解答】

此调用是正确的，利用p创建一个临时的shared_ptr赋予process的参数ptr，p和ptr都指向相同的int对象，引用计数被正确地置为2。process执行完毕后，ptr被销毁，引用计数减1，这是正确的——只有p指向它。