C++ primer 练习 - 12章：动态内存

最新推荐文章于 2022-08-02 21:56:05 发布
最新推荐文章于 2022-08-02 21:56:05 发布
阅读量428 收藏
点赞数
分类专栏： c++ 文章标签： c++ c++-primer 智能指针 内存管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35044025/article/details/77864014
版权

C++ primer 练习 - 12章：动态内存

部分内容参考博客：http://blog.csdn.net/misayaaaaa/article/details/53786215#comments

12.1

b1,b2各有4个元素，因为StrBlob保存的是指针

12.2

using namespace std;
class StrBlob
{
public:
    typedef vector<string>::size_type size_type;
    StrBlob();
    StrBlob(initializer_list<string> il);
    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& back() const;
private:
    shared_ptr<vector<string>> data;
    //如果data[i]不合法，抛出一个异常
    void check(size_type i, const string &msg) const;
};

void StrBlob::check(size_type i, const string &msg) const
{
    if (i >= data->size())
        throw out_of_range(msg);
}
void StrBlob::pop_back()
{
    check(0, "pop_back on empty StrBlob");
    return data->pop_back();
}
string& StrBlob::front() const
{
    check(0, "pop_back on empty StrBlob");
    return data->front();
}
string& StrBlob::back() const
{
    check(0, "pop_back on empty StrBlob");
    return data->back();
}

12.3

没有必要，因为const修饰成员变量函数是为了防止该函数对成员变量的修改。

12.4

因为size_type是一个无符号类型，即使为负数也会转成正数。

12.5

explicit的作用就是抑制构造函数的隐式转换

  • 优点：不会自动的进行类型转换，必须清楚的知道类类型
  • 缺点：必须用构造函数显示创建一个对象，不够方便简单

12.6

using namespace std;
vector<int>* MakeVec()
{
    vector<int> *a = new vector<int>;
    return a;
}
vector<int>* GetVec(vector<int>* vec)
{
    int i;
    while(cin >> i)
    {
        vec->push_back(i);
    }
    return vec;
}
void PrintVec(vector<int>* vec)
{
    for(auto i = vec->cbegin(); i!=vec->cend(); i++)
        cout<< *i <<endl;
}

int main()
{
    vector<int> *vec = MakeVec();
    vec = GetVec(vec);
    PrintVec(vec);
    delete vec;
    vec = nullptr;
    system("pause");
    return 0;
}

12.7

using namespace std;
shared_ptr<vector<int>> MakeVec()
{
    shared_ptr<vector<int>> p(new vector<int>);             //分配空间
    return p;
}
//与第6题相似，此处可以不反回，因为函数内容为指针操作
shared_ptr<vector<int>> GetVec(shared_ptr<vector<int>> p)    
{
    int i;
    while(cin >> i)
    {
        p->push_back(i);
    }
    return p;
}
void PrintVec(shared_ptr<vector<int>> p)        
{
    for(auto i = p->cbegin(); i!=p->cend(); i++)
        cout<< *i <<endl;
}

int main()
{
    shared_ptr<vector<int>> p = MakeVec();
    p = GetVec(p);
    PrintVec(p);
    p = nullptr;
    system("pause");
    return 0;
}

12.8

有问题，p是一个指针返回的是bool类型，这会导致p分配的空间无法得到释放。

12.9

int *q = new int(42), *r = new int (100);
r = q;

这里会导致r分配的空间无法得到释放。

12.10

正确

12.11

利用P.get()函数得到的内置指针来初始化一个临时的智能指针，一旦调用结束，该临时指针被销毁，临时指针的引用计数变为0而释放内存，使得p变为空悬指针。

12.12

void process(shared_ptr<int> ptr)
{
    //使用ptr
}//ptr离开作用域，被销毁

process()只能接受智能指针

  • (a) 合法 sp为智能指针
  • (b) 不合法 临时内置指针
  • (c) 不合法 内置指针
  • (d) 合法 临时智能指针

12.13

会释放sp所指向的空间，使得sp变为空悬指针。

12.14

struct destination;                         //表示我们正在连接什么
struct connection;                          //使用连接所需的信息
connection connect(destination*);           //打开连接
void disconnect(connection);                //关闭给定的连接

void end_connection(connection *p)
{
    disconnect( *p );
}
void f(destination &d)
{
    connection c = connect(&d);
    shared_ptr<connection> p(&c, end_connection);
    //使用连接
    //当f退出时（即使是异常退出），connection会被正确关闭
}

需要对声明进行定义即可使用

12.15

[](connection *p){ disconnect *p; }

12.16

略

12.17

编辑器里除了(a)全部通过。怎么回事也不清楚

  • (a) 不合法： ix不是new返回的指针
  • (b) 不合法： 不支持拷贝
  • (c) 合法： 不支持拷贝
  • (d) 不合法： 不支持赋值
  • (e) 合法
  • (f) 不合法： p2.get()返回一个内置指针，unique_ptr不支持拷贝

12.18

release()函数的作用就是放弃对指针指向对象的控制权，但shared_ptr是多对一的关系，其他的智能指针仍然可以删除这个对象，所以这个函数的话对shared_ptr没意义。

12.19

#include <iostream>
#include <stdlib.h>
#include <vector>
#include <string>
#include <memory>

using namespace std;


class StrBlob
{
    friend class StrBlobPtr;
    StrBlobPtr begin();
    StrBlobPtr end();
public:
    typedef vector<string>::size_type size_type;
    StrBlob(): data(make_shared<vector<string>>()) {}
    StrBlob(initializer_list<string> il);
    StrBlob(string il);
    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& back() const;
private:
    shared_ptr<vector<string>> data;
    //如果data[i]不合法，抛出一个异常
    void check(size_type i, const string &msg) const;
};

StrBlob::StrBlob(initializer_list<string> il)
{
    data = make_shared<vector<string>>(vector<string>{il});
}
StrBlob::StrBlob(string il)
{
    data = make_shared<vector<string>>(vector<string>{il});
}

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

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


class StrBlobPtr
{
public:
    StrBlobPtr() : curr(0) {}
    StrBlobPtr(StrBlob &a, size_t sz = 0) : wptr(a.data), curr(sz) {}
    string& deref() const
    {
        auto p = check(curr, "deference past end");
        return (*p)[curr];
    }
    StrBlobPtr& icur()          //前缀增加
    {
        auto p = check(curr, "deference past end");
        ++curr;
        return *this;
    }
private:
    //若检验成功，check返回一个指向vector的shared_ptr
    shared_ptr<vector<string>> check(size_t i, const string& msg) const
    {
        auto ret = wptr.lock();
        if (!ret)
            throw runtime_error("unbound StrBolbPtr");
        if (i >= ret->size())
        {
            throw out_of_range(msg);
        }
        return ret;
    }
    //保存一个weak_ptr，意味着底层vector可能被销毁
    weak_ptr<vector<string>> wptr;
    size_t curr;
};

StrBlobPtr StrBlob::begin()
{
    return StrBlobPtr(*this);
}
StrBlobPtr StrBlob::end()
{
    return StrBlobPtr(*this, data->size());
}

int main()
{
    StrBlob str = { "first", "second", "third"};
    StrBlobPtr ptr = StrBlobPtr(str);
    cout << ptr.deref() << endl;                //cout "first"
    ptr.icur();
    cout << ptr.deref() << endl;                //cout "second"


    system("pause");
    return 0;
}

12.20

类结果与12.19相似，这里补充main函数

int main()
{
    StrBlob str ;
    ifstream infile("文件.txt");
    string s;
    while(getline(infile, s))
    {
        str.push_back(s);
        cout << str.back() << endl;
    }
    for (StrBlobPtr pbeg = str.begin(), ebeg = str.end(); pbeg.deref() != ebeg.deref(); pbeg.icur())
    {
        cout << pbeg.deref() << endl;
    }


    system("pause");
    return 0;
}

12.19和12.20的总结

StrBlob()在没有形参时，需要创建一个vector<string>作为智能指针data的指向目标，否则对data进行操作就会报错。

也就是说，当智能指针指向的内容为一个容器时，通过指针对容器操作时必须先使指针指向一个容器，否则报错。

看一段代码

int main()
{
    shared_ptr<vector<string>> ptr = make_shared<vector<string>>(vector<string>{});
    ptr->push_back("aaaaa");
    return 0;
}

这种情况下没有问题，因为在创建指正指针ptr时候使它指向一个空的vector<string>容器。

int main()
{
    shared_ptr<vector<string>> ptr;
    ptr->push_back("aaaaa");
    return 0;
}

这种情况下就会报错，因为智能指针ptr未指向一个容器，自然不能进行容器操作了。

12.21

原先的版本好，可读性更强，

12.22

将StrBlobPtr的构造函数定义为const。

12.23

using namespace std;
int main(int argc, char**argv)
{
    char *s1 = "abc";
    char *s2 = "efg";//字符串字面常量,字符串末尾有空格
    string si = "a";
    string sl = "b";//标准库string对象
    char *p = new char[strlen(s1) + strlen(s2) + 1];//必须指明要分配对象的个数
    strcpy(p, s1);//复制
    strcat(p, s2);//接上
    cout << p << endl;
    strcpy(p, (si + sl).c_str());//必须转换为c类型字符串(c中无string类型)
    cout << p << endl;
    delete[] p;
    system("pause");
    return 0;
}

12.24

长度超出会自动补上

int main(int argc, char**argv)
{
    string a;
    cin>>a;
    char *p = new char[2];
    strcpy(p,a.c_str());
    cout<<p<<endl;
    delete [] p;//一定要记得delete
    system("pause");
    return 0;
}

12.25

delete [] pa

12.26

using namespace std;
int main()
{
    allocator<string> alloc;
    auto const p = alloc.allocate(10);
    auto q = p;
    string s;
    while (cin >> s && q != p + 10)
    {
        alloc.construct(q++, s);
    }
    while (p != q)
    {
        alloc.destroy(--q);
    }
    alloc.deallocate(p, 10);
}

12.27~12.30(12.3自己写的程序)

main.cpp

#include "main.h"
using namespace std;

TextQuery::TextQuery(ifstream &infile)
{
    string s;
    size_t lineNum = 0;
    while (getline(infile, s))
    {
        m_text.push_back(s);
        stringstream ss(s);             //字符流
        string word;
        while (ss >> word)
        {
            auto it = m_line.find(word);
            if (it != m_line.end())     //如果map中已有
                it->second.insert(lineNum);
            else
            {
                m_line.insert(make_pair(word, set<size_t>{lineNum}));
            }
        }
        lineNum++;
    }
}

QueryResult TextQuery::query(string &s)
{
    auto it = this->m_line.find(s);
    shared_ptr<vector<string>> data = make_shared<vector<string>>(this->m_text);
    shared_ptr<set<size_t>> line;
    if (it != this->m_line.end())
        line = make_shared<set<size_t>>(it->second);
    else
        line = make_shared<set<size_t>>();          //指向空set
    return QueryResult(s, line, data);

}


void runQueries(ifstream &infile)
{
    // infile是一个ifstream，指向我们需要处理的文件
    TextQuery tq(infile);
    // 与用户交互：提示用户输入要查询的单词，完成查询并打印结果
    while (true)
    {
        cout << "enter word to look for, or q to quit: ";
        string s;
        // 若遇到文件尾或用户输入了'q'时循环终止
        if (!(cin >> s) || s == "q")
            break;
        print(cout, tq.query(s)) << endl;
    }
}

ostream& print(ostream& os, const QueryResult &qr)
{
    os << "element occyrs " << qr.m_row->size() << " times" << endl;
    for (set<size_t>::iterator it = qr.m_row->begin(); it != qr.m_row->end(); it++)
    {
        size_t l = *it;
        os << "( " << l+1 << " )\t";
        os << qr.m_data->at(l) << endl;
    }
    return os;
}

int main()
{
    ifstream infile("文件.txt");
    runQueries(infile);
}

main.h

#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED


#include <string>
#include <iostream>
#include <cctype>
#include <memory>
#include <vector>
#include <map>
#include <set>
#include <fstream>
#include <sstream>

using namespace std;
class QueryResult;
class TextQuery
{
public:
    TextQuery(ifstream&);
    QueryResult query(string &s);
    vector<string> m_text;                      //用于存放文本的每一行内容
    map<string, set<size_t>> m_line;            //set中存放每个单词的行号，用map进行关联
};

class QueryResult {
    friend ostream& print(ostream&, const QueryResult &);
public:
    QueryResult(const string &word, shared_ptr<set<size_t>> &row, shared_ptr<vector<string>> &data)
        :m_word(word), m_row(row), m_data(data) {}
private:
    string m_word;
    shared_ptr<set<size_t>> m_row;
    shared_ptr<vector<string>> m_data;
    set<size_t>::iterator begin() const { return m_row->begin(); }
    set<size_t>::iterator end() const { return m_row->end(); }
    shared_ptr<vector<string>> get_file() const { return m_data; }
};

void runQueries(ifstream &infile);


#endif // MAIN_H_INCLUDED

12.31

vector保存行号会使得在读取单词所属行时读入多个行数存入vector，但是这样可以实现每一行有多少个同样的单词，但是本例中不需要这个功能。

12.32

替换下类名就好了

12.33

set<size_t>::iterator begin() const { return m_row->begin(); }
set<size_t>::iterator end() const { return m_row->end(); }
shared_ptr<vector<string>> get_file() const { return m_data; }

最终结果在12.30题答案下面

第12章：动态内存心得

1. 主要掌握几个知识点，智能指针shared_ptr，unique_ptr，weak_ptr。

  • shared_ptr具有计数器记录共享的智能指针个数，当计数器为0时释放空间。

    其使用make_shared产生在动态内存中分配一个对象并初始化，返回指向该对象的shared_ptr。

    不要混用智能指针和内置指针，不要用智能指针.get()来初始化另一个智能指针或为智能指针赋值。下面这个例子中会对计数器产生混乱。

    using namespace std;
int main()
{
    shared_ptr<int> p(new int(42));
    int *q = p.get();
    shared_ptr<int> c(p);
    cout << p.use_count() << endl;
    system("pause");
    return 0;
}

  • unique_ptr是一对一的，一个指针对应一块区域，指针指向位置改变的时候也会释放空间。

  • weak_ptr是弱的智能指针，指向由sharped_ptr管理的对象，该指针对计数器没有影响。

    weak_ptr初始化需要使用一个sharped_ptr，比如weak_ptr<int>wp(p)，p就是一个sharped_ptr。

    weak_ptr的对象不一定存在，所以需要w.lock()的使用，若存在返回对应的sharped_ptr，否则返回空的sharped_ptr。

2. allocator类

一种自己管理内存的类，比new/delete更有效率，但是用起来还是挺麻烦的。

  • a.allocate(n) : 分配内存,相当于new
  • a.construct(p, args) : args被分配给p指向的内存位置，相当于我们在申请空间之后的赋值行为。
  • a.destroy(p) ： 对p所指向的对象执行析构函数。
  • a.deallocate(p,n) ： 释放从p开始的内存，p必须为创建时返回的指针，n必须为创建时分配的大小。相当于delete行为，但是更麻烦。

3. 还有就是熟悉的new/delete了

Augus_Xu
关注
专栏目录
C++Primer第五版——习题答案+详解(完整版)
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++ Primer Plus（第六版）编程练习答案 第12章 类和动态内存分配
清水河C罗——Leonardo-Liu
09-28 4431
本章所有编程练习的工程源码可在此处下载（点击此链接下载），供大家参考交流！   1. 对于下面的类声明： class Cow {          char name[20];          char *hobby;          double weight; public:          Cow();          Cow(const char * nm, co...
C++ Primer Plus 笔记第十二章
weixin_34208185的博客
10-29 282
类和动态内存分配 本章内容包括： 　　 对类成员使用动态内存分配 　　 隐式和显示复制构造函数 　　 隐式和显示重载赋值运算符 　　 在构造函数中使用 new 所必须完成的工作 　　 使用静态类成员 　　 将定位 new 运算符用于对象 　　 使用指向对象的指针 　　 实现队列抽象数据类型（ADT） 12.1 动态内存和类 　　 C++ 让程序在运行时决定内存分配，而不是在编...
C++ primer 第十二章
qq_30035663的博客
08-02 392
学习c++ primer
《C++primer》第12章：动态内存
z-k的博客
02-14 269
1、动态内存与智能指针 shared_ptr类 支持的操作 make_share函数 make_share定义在memory头文件中，作用是分配一个对象并初始化它，返回指向此对象的shared_ptr指针 使用示例 shared_ptr的拷贝和赋值 可认为每个shared_ptr都有一个引用计数 无论何时拷贝一个shared_ptr，计数器都会递增 当给一个shared_...
C++ Primer 第12章 知识点
Janus
01-21 201
文章目录前置回顾: 简单了解new & delete 前置回顾: 简单了解new & delete 在C语言中, 动态内存的申请使用的是malloc和calloc, 而C++中提供了更加智能的方案:new new的内存申请: ew会自动判断所需内存大小, 并返回合适的指针 typeName * ptrName = new typeName ; //自动判断typeName类型的大小...
C++Primer：第十二章 动态内存 笔记
人在旅途的博客
05-12 535
概述信息1、静态内存用来保存1）局部static对象、2）类static数据成员、3）定义在函数外的变量。2、栈内存保存1）函数内非static对象3、静态内存和栈内存中的对象由编译器自动创建和销毁。1）栈对象：仅在其定义的程序块运行时才存在2）static对象：使用之前分配，程序结束时销毁4、补充一下C++的内存区域1）代码区：存放程序代码2）静态数据区：存放全局变量或对象、static局部变量...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
c++primer第五版习题答案（第12章）
11-12
此外，描述中提及的“真正的C++primer习题集”，这可能表明该习题集是针对教材内容设计的，目的是帮助学生消化和练习书中的理论知识。通过解决这些习题，学生可以加深对C++语言特性的理解，包括类和对象、动态内存...
C++ Primer 第12章 知识点回顾
lgfun的专栏
08-07 492
静态内存（局部static对象，类static成员，全局变量）、栈内存（函数内非static变量）、堆（也叫自由空间，存储动态分配的对象，即运行时分配）。动态对象生存期由程序来控制，其他对象由编译器自动创建和销毁。12.1.1 shared_ptr类 程序使用动态内存处于一下三种原因之一： 程序不知道自己需要使用多少对象 程序不知道所需对象的准确类型 程序需要在多个对象间共享数据 12.1.2 直
C++ Primer Plus 第十二章知识点（一）
Raywit的博客
01-20 508
C++ Primer Plus 第十二章知识点简化1. 动态内存和类 1. 动态内存和类 归纳点： 静态成员变量初始化 习惯加const        每个成
OpenJudge NOI 1.13 51:古代密码
君义NOIP的博客
06-22 958
OpenJudge NOI 1.13 51:古代密码原文经过某种“替换方法”变为密文后，每种字符都转为某一种字符，不同的字符在替换后得到的字符不同。 那么原文和密文的字符出现次数分布规律一定是一样的在经过替换后，即便再进行重新排列，字符出现次数的分布规律也不会改变。 因此，只要原文和密文的字符出现次数的分布规律一样，那么原文一定可以通过替换与重新排列变为密文。将大写字母转为数字，数字i表示字母，也就是0对应A，1对应B，…，25对应Z。 表示i对应的字母出现的次数。 先遍历字符串，统计出各个字母出现的个数，
c++笔记-内存管理对象移动
I'm here
03-03 427
新标准最主要的特性是可以移动而非拷贝对象的能力。避免了由于移动对象较大而拷贝代价过大的缺点。标准库容器、string和shared_ptr类既支持移动也支持拷贝。IO类和unique_ptr类可以移动但不能拷贝。 右值引用。为了支持移动操作而引入的新的引用类型。通过&amp;&amp;来获得右值引用，而不是(&amp;)取址符。一般而言，一个左值表达式是一个对象身份，而一个右值表达式是对象的值。...
c++ primer 第十二章习题
无所知的博客
09-03 1282
练习12.1 都是4个 练习12.2 #ifndef MYSTRBLOB_H #define MYSTRBLOB_H #include &lt;initializer_list&gt; #include &lt;memory&gt; #include &lt;stdexcept&gt; #include &lt;string&gt; #include &lt;vector&gt; cla...
C++ primer(第五版）第12章习题答案
INFINITE POSSIBILITIES
03-31 1002
第十二章　动态内存 12.1 b2被销毁了，但b2中的元素不能被销毁。b1和b2中都有４个元素。 12.2 ex12_02.h #include <vector> #include <string> #include <initializer_list> #include <memory> #include <excep...
C++ Primer 答案 第十二章
fly
11-21 1224
12.1 都是4个，但是b2已经没了，如果接着使用b2会出错 b1 = b2; b2.push_back("about"); 它们共用了内存，所以对b2操作，b1的size也变了 12.2 我把头文件和实现写在一起了 解释下为啥要重构front和back： 如果我们定义的是const的StrBlob,调用front()，它的返回值是string&amp;, return data-&gt;fro...
[萌新c++] LeetCode 1两数之和
piqu1619的博客
02-23 763
题解中cv过来的代码（鸣谢no5题解owner:程序员小吴），就想打印一下结果。。 无法用 “int [4]” 类型的值初始化 “std::vector<int, std::allocator> &” 类型的引用（非常量限定） nums定义改为：vector nums[] = { 2, 7, 11, 15 }; 报如下错误： E0415 不存在从 “int” 转换到 “std...
SGI-STL 迭代器实现
蔡曜镫专栏
03-02 833
SGI-STL 迭代器实现 迭代器模式：该模式能够提供一种方法，使之能够依序寻访某个聚合物（容器）所含的每个元素，而又无需暴露该聚合物的内部表达方式。 ———————————————————————————————————————— 《STL源码剖析》 它是什么？它其实就是算法与容器的一种粘胶剂。它像什么？迭代器的行为非常类似智能指针（SmartPointer），所以对他来说最重
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值