第十二章课后习题

//12.1
b2有4个元素，但是最终被销毁
b1有4个元素
//12.3
不需要，因为常量对象不允许修改自己的内容
//12.4
check函数是私有函数，只能被成员函数调用
而成员函数能保证i肯定大于等于0
//12.5
可以比较方便的进行拷贝形式的初始化

//12.6
vector<int>* new_vector()
{
	return new vector<int>;
}
void read(vector<int> *pv)
{
	int num;
	while (cin >> num)
		pv->push_back(num);
}
void print(vector<int> *pv)
{
	for (const auto &v : *pv)
		cout << v << endl;
}
int main()
{
	vector<int> *pv = new_vector();
	read(pv);
	print(pv);
	delete pv;
	return 0;
}
//12.7
shared_ptr<vector<int>> new_vector()
{
	return make_shared<vector<int>>();
}
void read(shared_ptr<vector<int>> pv)
{
	int num;
	while (cin >> num)
		pv->push_back(num);
}
void print(shared_ptr<vector<int>> pv)
{
	for (const auto &v : *pv)
		cout << v << endl;
}
int main()
{
	shared_ptr<vector<int>> pv = new_vector();
	read(pv);
	print(pv);
	delete pv;
	return 0;
}
//12.8
new分配失败会抛出bad_alloc异常，而不是返回nullptr，所以程序达不到预想的效果
可以改为int* p = new (nothrow) int
但这也不是个好办法，最好通过捕获异常或者判断返回指针来返回true或false
//12.9
(a)r = q执行后，r原来的指针得不到释放，导致内存泄漏
且两个指针指向同一片动态内存，可能会出现释放其中一个后使用另一个的情况
(b)r2 = q2执行后，r2z引用计数归0，自动释放，q2引用计数加1

//12.10
正确的
//12.11
错误！p.get()获得普通指针后赋给一个临时的shared_ptr，然后调用process，调用结束后引用计数
归0会自动释放动态内存，此时p就变成了空悬指针
//12.12
(a)合法，调用process会拷贝sp
(b)不合法，不能将int*转换为shared_pre<int>
(c)同上
(d)合法，但是做法错误，这里process执行完后p会变成空悬指针，原因见12.11
//12.13
sp会变成引用计数为1，但是指向的内容已经被释放的指针

//12.17
(a)错误，ix是个int值
(b)合法，但是错误。这里使用普通int变量的地址初始化unique_ptr，p1释放时会引起未定义行为
(c)合法
(d)合法，但是错误。问题同b
(e)合法
(f)合法，但是不妥。这样会造成p2、p5指向同一片动态内存
//12.18
unique_ptr独占对象的所有权，所以用release用来转移对象的所有权
多个shared_ptr可以共享一个对象，不需要转移所有权

//12.19
class StrBlob
{
	friend class StrBlobPtr;
public:
	//...
	StrBlobPtr begin() { return StrBlobPtr(*this); }
	StrBlobPtr end() { return StrBlobPtr(*this, data->size()); }
	//...
};
//12.21
该写法不易读且不易修改
//12.22
class ConstStrBlobPtr
{
public:
	ConstStrBlobPtr() : curr(0) {}
	ConstStrBlobPtr(const StrBlob &a, size_t sz = 0) : wptr(a.data), curr(sz) {}
	string& deref() const;
	ConstStrBlobPtr& incr();
private:
	shared_ptr<vector<string>> check(size_t, const string&) const;
	weak_ptr<vector<string>> wptr;
	size_t curr;
};
shared_ptr<vector<string>> ConstStrBlobPtr::check(size_t i, const string &msg) const
{
	auto ret = wptr.lock();
	if (!ret)
		throw runtime_error("unbound StrBlobPtr");
	if (i >= ret->size())
		throw out_of_range(msg);
	return ret;
}

string& ConstStrBlobPtr::deref() const
{
	auto p = check(curr, "dereference past end");
	return (*p)[curr];
}

ConstStrBlobPtr& ConstStrBlobPtr::incr()
{
	check(curr, "increment past end of StrBlobPtr");
	++curr;
	return *this;
}

//12.23
int main()
{
	const char c1 = "abc";
	const char c2 = "def";
	char *r = new char[strlen(c1) + strlen(c2) + 1];
	strcpy(r, c1);
	strcat(r, c2);
	cout << r << endl;
	delete [] r;
	string s1 = "abc";
	string s2 = "def";
	string s3 = s1 + s2;
	cout << s3 << endl;
	return 0;
}
//12.24
int main()
{
	char *r = new char[20];
	char c;
	int index = 0;
	while (cin.get(c))
	{
		if (isspace(c))
			break;
		r[index++] = c;
		if (index == 20)
			break;
	}
	r[index] = 0;
	cout << r << endl;
	delete [] r;
	return 0;
}
//12.25
delete [] pa;

//12.26
allocator<string> alloc;
string *const p = alloc.allocate(100);
string s;
string *q = p;
while (cin >> s && q != p + 100)
	alloc.construct(q++, s);
const size_t size = q - p;

for (size_t i = 0; i < size; i++)
	cout << p[i] << " " << endl;
while (q != p)
	alloc.destroy(--q);
alloc.deallocate(p, 100);