|
习题答案目录：https://www.cnblogs.com/Mered1th/p/10485695.html
第12章 动态内存
练习12.1
b1包含4个元素，b2被销毁
练习12.2
#include <string>
#include <initializer_list>
#include <memory>
#include <vector>
#include <stdexcept>
class StrBlob
{
public:
typedef std::vector<std::string>::size_type size_type;
StrBlob();
StrBlob(std::initializer_list<std::string> il);
size_type size() const { return data->size(); }
bool empty() const { return data->empty(); }
void push_back(const std::string &t) { data->push_back(t); }
void pop_back();
std::string& front();
std::string& back();
const std::string& front() const;
const std::string& back() const;
private:
std::shared_ptr<std::vector<std::string>> data;
void check(size_type i, const std::string &msg) const;
};
StrBlob::StrBlob() : data(std::make_shared<std::vector<std::string>>()) {}
StrBlob::StrBlob(std::initializer_list<std::string> il) : data(std::make_shared<std::vector<std::string>>(il)) {}
void StrBlob::check(size_type i, const std::string &msg) const
{
if (i >= data->size())
throw std::out_of_range(msg);
}
std::string& StrBlob::front()
{
check(0, "front on empty StrBlob");
return data->front();
}
std::string& StrBlob::back()
{
check(0, "back on empty StrBlob");
return data->back();
}
const std::string& StrBlob::front() const
{
check(0, "front on empty StrBlob");
return data->front();
}
const std::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();
}
练习12.6
#include<vector>
#include<iostream>
#include<string>
using namespace std;
vector<int> *create_vi() {
return new std::vector<int>;
}
void push_vi(vector<int> *p) {
int i;
while (cin >> i) {
p->push_back(i);
}
}
void print_vi(vector<int> *p) {
for (const auto i : (*p)) {
cout << i << " ";
}
cout << endl;
}
int main() {
auto p = create_vi();
push_vi(p);
print_vi(p);
delete(p);
system("pause");
return 0;
}
练习12.7
#include<vector>
#include<iostream>
#include<string>
#include<memory>
using namespace std;
shared_ptr<vector<int>> create_vi() {
return make_shared<vector<int>>();
}
void push_vi(shared_ptr<vector<int>> p) {
int i;
while (cin >> i) {
p->push_back(i);
}
}
void print_vi(shared_ptr<vector<int>> p) {
for (const auto i : (*p)) {
cout << i << " ";
}
cout << endl;
}
int main() {
auto p = create_vi();
push_vi(p);
print_vi(p);
system("pause");
return 0;
}
练习12.8
有，p的类型被强制转换为bool值，并且new的内存没有delete。
练习12.9
r=q后r所指的内存没有释放，再使用p指针会出错。
练习12.10
正确
练习12.11
离开process时，p指向的内存会被释放，再使用p指针会出现错误。
练习12.12
a.合法，将智能指针赋值给process
b.不合法，shared_ptr初始化内置指针时需要使用直接初始化的形式。
c.不合法，shared_ptr初始化内置指针时需要使用直接初始化的形式。
d.合法。
练习12.13
sp和p指向同一个内存，释放了p所指的内存后，再使用sp调用对象可能会出错。
练习12.14
#include<iostream>
#include<memory>
#include<string>
using namespace std;
struct destination {
string des;
destination(string des_) :des(des_) {}
};
struct connection{
string conn;
connection(string conn_) :conn(conn_) {}
};
connection connect(destination *des_) {
cout << "connect to: " << des_->des << endl;
return connection(des_->des);
}
void disconnect(connection conn_) {
cout << "disconnect " << conn_.conn << endl;
}
void end_connection(connection *p) { disconnect(*p); }
void f(destination &d) {
connection c = connect(&d);
shared_ptr<connection> p(&c, end_connection); //p接管了内置指针&c所指向的对象的所有权
cout << "connecting now(" << p.use_count() << ")" << endl;
}
int main() {
destination des("aa");
f(des);
system("pause");
return 0;
}
练习12.15
#include<iostream>
#include<memory>
#include<string>
using namespace std;
struct destination {
string des;
destination(string des_) :des(des_) {}
};
struct connection{
string conn;
connection(string conn_) :conn(conn_) {}
};
connection connect(destination *des_) {
cout << "connect to: " << des_->des << endl;
return connection(des_->des);
}
void disconnect(connection conn_) {
cout << "disconnect " << conn_.conn << endl;
}
void end_connection(connection *p) { disconnect(*p); }
void f(destination &d) {
connection c = connect(&d);
shared_ptr<connection> p(&c, [](connection *p) {disconnect(*p);}); //p接管了内置指针&c所指向的对象的所有权
cout << "connecting now(" << p.use_count() << ")" << endl;
}
int main() {
destination des("aa");
f(des);
system("pause");
return 0;
}
练习12.16
#include<iostream>
#include<memory>
using namespace std;
int main() {
unique_ptr<string> p1(new string("Stegosaurus"));
//unique_ptr<string> p2 = p1;
//unique_ptr<string> p3(p1);
system("pause");
return 0;
}
尝试引用已删除的函数
练习12.17
(a)不合法，ix不是new返回的指针
(b)不合法，pi不是new返回的指针
(c)合法
(d)不合法，&ix不是new返回的指针
(e)合法
(f)不合法，必须使用new返回的指针进行初始化，赋值和拷贝的操作也不包含get()方法
练习12.18
release()函数的作用就是放弃对指针指向对象的控制权，但shared_ptr是多对一的关系，其他的智能指针仍然可以删除这个对象，所以这个函数的话对shared_ptr 没意义
练习12.19
class StrBlob
{
public:
friend class StrBlobPtr;//声明friend
StrBlobPtr begin();
StrBlobPtr end();
StrBlob();//默认构造函数
StrBlob(initializer_list<string> il):data(make_shared<vector<string>>(il)){}
StrBlob(string il):data(make_shared<vector<string>> (il)){}
typedef vector<string>::size_type size_type;//定义类型别名，方便使用
//定义函数，返回大小
size_type size() const
{
return data->size();
}
//判断vector<string>是否为空
bool empty()
{
return data->empty();
}
//向vector<string>中加入元素
void pushback(const string &s)
{
data->push_back(s);
}
//访问函数，应首先调用check()
string& front()
{
check(0,"front on empty StrBlob");
return data->front();
}
string& back()
{
check(0,"back on empty StrBlob");
return data->back();
}
void popback()
{
check(0,"pop_back on empty StrBlob");
data->pop_back();
}
private:
shared_ptr<vector<string>> data;//指向vector<string>的智能指针
void check(size_type i,const string &msg) const//若访问元素的大小大于data的size,输出错误信息
{
if (i > data->size())
{
throw out_of_range(msg);//抛出该out_of_range异常，表示不在范围之内
}
}
};
class StrBlobPtr
{
public:
StrBlobPtr():curr(0){}//构造函数，将curr设定为0
StrBlobPtr(StrBlob &a, size_t sz = 0):wptr(a.data),curr(sz){}//构造函数，将StrBlob的智能指针与此类中的weak_ptr绑定
string& deref() const
{
auto p =check(curr,"deference past end");
return (*p)[curr];
}
StrBlobPtr& incr()
{
auto p =check(curr,"deference past end");
++curr;
return *this;
}
private:
shared_ptr<vector<string>> check(size_t i,const string& msg) const//检查函数，返回一个vector<string>的智能指针
{
auto ret = wptr.lock();//检查对象是否还存在
if(!ret)
{
throw runtime_error("未绑定");
}
if (i >= ret->size())
{
throw out_of_range(msg);
}
return ret;
}
weak_ptr<vector<string>> wptr;//定义弱智能指针
size_t curr;//设立游标，表示下标
};
StrBlobPtr StrBlob::begin()
{
return StrBlobPtr(*this);
}
StrBlobPtr StrBlob::end()
{
return StrBlobPtr(*this, data->size());
}
练习12.23
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
int main() {
const char a[] = "aaa";
const char b[] = "bbb";
char *ans = new char[strlen(a) + strlen(b) + 1];
strcpy(ans, a);
strcat(ans, b);
cout << string(ans) << endl;
delete[] ans;
system("pause");
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main() {
const string a = "aaa";
const string b = "bbb";
cout << a + b << endl;
system("pause");
return 0;
}
练习12.24
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
int main() {
string s;
cin >> s;
char *t = new char[s.size() + 1];
strcpy(t, s.c_str());
cout << t << endl;
delete[] t;
system("pause");
return 0;
}
练习12.25
delete[] pa;
练习12.26
#include<iostream>
#include<memory>
#include<string>
using namespace std;
int main() {
allocator<string> alloc;
auto const p = alloc.allocate(10);
string s;
auto q = p;
while (cin >> s && q != p + 10) {
alloc.construct(q++, s);
}
while (q!=p)
{
alloc.destroy(--q);
}
alloc.deallocate(p, 100);
system("pause");
return 0;
}
|
客服电话
APP下载
官方微信
请发表评论