12.1 动态内存与智能指针
12.1.1 shared_ptr类
-
shared_ptr<string>p1;
//可以指向string
-
shared_ptr<list<
int>>p2
//可以指向int的list
-
//如果p1不为空，检查它是否指向一个空string
-
if(p1&&pq->
empty())
-
*p1 =
"hi";
//如果p1指向一个空string，解引用p1,将一个新至赋予string
shared_ptr和unique_ptr都支持的操作见表12.1
make_shared函数
-
-
//指向一个值为42的int的shared_ptr
-
shared_ptr<
int> p3 =
make_shared<
int>(
42);
-
-
//指向一个值为9999999999的string
-
shared_ptr<string> p4 =
make_shared<string>(
10,
'9');
-
-
//指向一个值初始化的int，即，值为0
-
shared_ptr<
int> p5 =
make_shared<
int>();
-
-
//指向一个动态分配的空vector<string>
-
auto p6 = make_shared<vector<string>>();
shared_ptr的拷贝和赋值
-
auto r =
make_shared<
int>(
42);
//r指向的int只有一个引用者
-
r = q;
//给r赋值，令它指向另一个地址
-
//递增q指向的对象的引用计数
-
//递减r原来指向的对象的引用计数
-
//r原来指向的对象已没有引用者，会自动释放
shared_ptr自动销毁所管理的对象
略（析构函数）
......shared_ptr还会自动释放相关联的内存
-
//factory返回一个shared_ptr，指向一个动态分配的对象
-
shared_ptr<Foo> factory(T arg)
-
{
-
//恰当处理arg
-
//shared_ptr负责释放内存
-
return
make_shared<Foo>(arg);
-
}
-
-
//下面函数将factory返回的shared_ptr保存在局部变量中
-
void use_factory(T arg)
-
{
-
shared_ptr<Foo> p =
factory(arg);
-
//使用o
-
}
//p离开了作用域，它指向的内存会被自动释放
-
-
//但如果有如果有其他shared_ptr也指向这块内存，它就不会被释放掉
-
shared_ptr<Foo> use_factory(T arg)
-
{
-
shared_ptr<Foo> p =
factory(arg);
-
//使用p
-
return p;
//当我们返回P时，引用计数进行了递增操作
-
}
//p离开了作用域，但它指向的内存不会被释放掉
使用了动态生存期的资源的类
-
//当我们拷贝一个vector时，原vector和副本vector中的元素是相互分离的
-
vector<string>v1;
//空vector
-
{
-
vector<string>v2 = {
"a",
"an",
"the"};
-
v1 = v2;
//从v2拷贝元素到v1中
-
}
//v2被销毁，其中的元素也被销毁，v1有三个元素，是原来v2中元素的拷贝
-
-
//一般而言，如果两个对象共享底层的数据，某个对象被销毁时，我们不能单方面地销毁底层数据
-
Blob<string> b1;
//空Blob
-
{
-
//新作用域
-
Blob<string> b2 = {
"a",
"an",
"the"};
-
b1 = b2;
//b1和b2共享相同地元素
-
}
//b2被销毁了，但b2中的元素不能销毁
-
//b1指向最初由b2创建的元素
定义StrBlob类
-
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();
-
private:
-
std::shared_ptr<std::vector<std::string>>data;
-
//如果data[i]不合法，抛出一个异常
-
void check(size_type i,const std::string &msg) const;
-
};
-
//该类中有一个默认构造函数和一个构造函数，接受单一的initializer_list<string>类型参数
-
//此构造函数可以接受一个初始化器的花括号列表
StrBlob构造函数
-
-
StrBlob::
StrBlob():
data(make_shared<vector<string>>()){ }
-
StrBlob::
StrBlob(initializer_list<string>il):
-
data(make_shared<vector<srting>>(il)){ }
元素访问成员函数
-
//check函数检查一个给定索引是否在合法范围内
-
//check函数还会接受一个string参数，它会将此参数传递给异常处理程序，该string描述了错误内容
-
void StrBlob::check(size_type i,const string &msg)const
-
{
-
if(i>=data->
size())
-
throw
out_of_range(msg);
-
}
-
-
//pop_back和元素访问函数首先调用check，如果check成功，这些成员函数继续利用底层vector的操作来完成自己的工作
-
string& StrBlob::front()
-
{
-
//如果vector为空，check会抛出一个异常
-
check(
0,
" front on empty StrBlob");
-
return data->
front();
-
}
-
string& StrBlob::back()
-
{
-
check(
0,
"back on empty StrBlob");
-
return data->
back();
-
}
-
void StrBlob::pop_back()
-
{
-
check(
0,
"pop_back on empty StrBlob");
-
data->
pop_back();
-
}
StrBlob的拷贝，赋值和销毁
略（详见书本）
12.1.2直接内存管理
使用new动态分配和初始化对象
-
int *pi =
new
int;
//pi指向一个动态分配的、未初始化的无名对象
-
-
string *ps =
new string;
//初始化为空string
-
int *pi =
new
int;
// pi指向一个未初始化的int
-
-
int *pi =
new
int(
1024);
//pi指向的对象的值为1024
-
string *ps =
new
string(
10,
'9');
//ps为9999999999
-
//vector有10个元素，值依次从0到9
-
vector<
int> *pv =
new vector<
int>{
0,
1,
2,
3,
4,
5,
6,
7,
8,
9};
-
-
string *ps1 =
new string;
//默认初始化为空string
-
string *ps =
new
string();
//值初始化啊为空string
-
int *pi1 =
new
int;
//默认初始化:*pi1的值未定义
-
int *pi2 =
new
int();
//值初始化为0；*pi2为0
-
-
//若提供一个括号包围的初始化器，就可以使用auto。从此初始化器来推断我们想要分配的对象的类型。
-
//但是，由于编译器要用初始化器的类型来推断要分配的类型，只有当括号中仅有单一初始化器时才可使用auto
-
auto p1 =
new
auto(obj);
//p指向一个与obj类型相同的对象
-
//该对象用obj进行初始化
-
auto p2 =
new
auto{a,b,c};
//错误:括号中只能有蛋哥初始化器
动态分配的const对象
-
//用new分配const对象是合法的
-
//分配并初始化一个const int
-
const
int *pci =
new
const
int(
1024);
-
//分配并默认初始化一个const的空string
-
const string *pcs =
new
const string;
-
//对于一个定义了默认构造函数的类类型，其const动态对象可以隐式初始化，而其他类型的对象就必须显示初始化
内存耗尽（定位new的使用)
-
-
//如果分配失败，new返沪一个空指针
-
int *p1 =
new
int;
//如果分配失败，new抛出std::bad_alloc
-
int *p2 =
new (nothrow)
int;
//如果分配失败，new返回一个空指针
释放动态内存
-
-
delete p;
//p必须指向一个动态内存分配的对象或是一个空指针
指针值和delete
-
int i,*pi1 = &i,*pi2 =
nullptr;
-
double *pd =
new
double(
33),*pd2 = pd;
-
delete i;
//错误，i不是一个指针
-
delete pi1;
//未定义：pi1指向一个局部变量
-
delete pd;
//正确
-
delete pd2;
//未定义：pd2指向的内存已经被释放了
-
delete pi2;
//正确：释放一个空指针总是没有错误的
-
-
//虽然一个const对象的值不能被改变，但其本身是可以被销毁的。如同其他动态对象一样，想要释放一个const
-
//动态内存对象，只要delete指向它的指针即可
-
const itn *pci =
new
const
int(
1024);
-
delete pci;
//正确：释放一个const对象
动态对象的生存期直到被释放时为止
-
//factory返回一个指针，指向一个动态分配的对象
-
Foo* factory(T arg)
-
{
-
//看情况处理arg
-
return
new
Foo(arg);
//调用者负责释放此内存
-
}
-
-
//下面函数调用factoty，后者分配一个类型为Foo的新对象。当use_factory返回时，局部变量p被销毁
-
//此变量是一个内置指针，而而不是一个智能指针
-
void use_factory(T arg)
-
{
-
Foo *p =
factory(arg);
-
//使用p但不delete它
-
}
//p离开了它的作用域，但它所指向的内存没有被释放
-
-
-
//下面函数中p时指向factory分配的内存的唯一指针，一旦use_factory返回，程序就没有办法释放这块内存了。
-
//根据整个程序的逻辑，修正这个错误的正确方式是在use_factory中记得释放内存
-
void use_factory(T arg)
-
{
-
Foo *p =
factory(arg);
-
//使用p
-
delete p;
//现在记得释放内存，我们已经不需要它了
-
}
-
-
//还有有一种可能，我们的系统中的其他代码要使用use_factory所分配的对象，我们就应该修改此函数
-
//让其返回以一个指针，指向它分配的内存
-
Foo* use_factory(T arg)
-
{
-
Foo *p =
factory(arg);
-
//使用p
-
return p;
//调用者必须释放内存
-
}
使用new和delete管理动态内存存在三个常见问题
1.忘记delete内存
2.使用已经释放掉的对象
3.同一个块内存释放两次
delete之后重置指针值......
空悬指针的概念及避免空悬指针的方式：在指针即将要离开其作用域之前释放掉它所关联的内存
......这只是提供了有限的保护
-
int *p(new int(42));
//p指向动态内存
-
auto q = p;
//p和q指向相同的内存
-
delete p;
//p和q均变为无效
-
p =
nullptr
//指出p不再绑定到任何对象
12.1.3 shared_ptr和new结合使用
-
//new返回的指针来初始化智能指针
-
shared_ptr<
double>p1;
//shared_ptr可以指向一个double
-
shared_ptr<
int>
p2(
new
int(
42));
//p2指向一个值为42的int
-
-
//接受指针参数的智能指针构造函数时explicit的，因此不能将一个内置指针隐式转化为一个
-
//智能指针，必须使用直接初始化形式来初始化一个智能指针
-
shared_ptr<
int>p1 =
new
int(
1024);
//错误：必须使用直接初始化形式
-
shared_ptr<
int>
p2(
new
int(
1024));
//正确：使用了直接初始化形式
-
-
//由于不能进行内置指针到智能指针之间的隐式转换，一个返回shared_ptr的函数不能在
-
//其返回语句中隐式转换一个普通指针
-
shared_ptr<int> clone(int p)
-
{
-
return
new
int(p);
//错误：隐式转换为shared_ptr<int>
-
}
-
-
//我们必须将shared_ptr显示绑定到一个想要返回的指针上
-
shared_ptr<
int>
clone(
int p)
-
{
-
//正确：显示地用int*创建shared_ptr<int>
-
return
shared_ptr<
int>(
new
int(p));
-
}
不要混合使用普通指针和智能指针
-
//考虑下面对shared_ptr进行操作地函数
-
//在函数被调用时ptr被创建并初始化
-
void process(shared_ptr<int>ptr)
-
{
-
//使用ptr
-
}
//ptr离开作用域，被销毁
-
-
//此函数的正确方法是传递给它一个shared_ptr
-
shared_ptr<
int>
p(
new
int(
42));
//引用计数为1
-
process(p);
//拷贝p会递增它的引用计数；在process中引用计数值为2
-
int i = *p;
//正确：引用计数为1
-
-
int *x(new int(1024));
//危险：x是一个普通指针，不是一个智能指针
-
process(x);
//错误：不能将int*转换为一个shared_ptr<int>
-
process(
shared_ptr<
int>(x));
//合法的，但内存会被释放
-
int j = *x;
//未定义的：x是一个空悬指针
使用一个内置指针来访问一个智能指针所负责的对象是很危险的，因为我们无法知道对象何时会被销毁
......也不要使用get初始化另一个智能指针或为智能指针赋值
-
shared_ptr<
int>
p(
new
int(
42));
//引用计数为1
-
int *q = p.
get();
//正确：但使用q时要注意,不要让它管理的指针被释放
-
{
-
//新程序块
-
//未定义：两个独立的shared_ptr指向相同的内存
-
shared_ptr<
int>(q);
-
}
//程序块结束，q被销毁，它指向的内存被释放
-
int foo = *p;
//未定义；p指向的内存已经被释放了
其他shared_ptr操作
-
//可以用reset来将一个新的指针赋予一个shared_ptr
-
p =
new
int(
1024);
//错误：不能将一个指针赋予shared_ptr
-
p.
reset(
new
int(
1024));
//正确：p指向一个新对象
-
-
if(!p.
unique())
-
p.
reset(
new
string(*p));
//我们不是唯一用户；分配新的拷贝
-
*p += newVal;
//现在我们知道自己是唯一的用户，可以改变对象的值
12.1.4 智能指针和异常
-
-
//如果使用智能指针。即使程序过早结束，智能指针类也能确保在内存不再需要是将其释放
-
void f()
-
{
-
shared_ptr<int> sp(new int(42));
// 分配一个新对象
-
//这段代码抛出一个异常，且在f中为未被捕获
-
}
//这段函数结束时shared_ptr自动释放内存
-
-
//如果使用内置指针管理内存，且在new之后对应的delete之前发生了异常，则内存不会被释放
-
void f()
-
{
-
int *ip =
new
int(
42);
//动态分配一个新对象
-
//这段代码抛出一个异常，且在f中未被捕获
-
delete ip;
//在退出 之前释放内存
-
}
智能指针和哑类
-
-
//假定我们正在使用一个C和C++都使用的网络库，使用这个库的代码可能是这样的
-
struct
destination;
//表示我们正在链接什么
-
struct
connection;
//使用链接所需的信息
-
connection connect(destination*);
//打开链接
-
void disconnect(connection);
//关闭给定的链接
-
void f(destination &d/*其他参数*/)
-
{
-
//获得一个链接；记住使用完后要关闭它
-
connection c =
connect(&d);
-
//使用链接
-
//如果我们在f退出前忘记调用disconnect，就无法关闭c了
-
}
使用我们自己的释放操作
-
//为了用shared_ptr来管理一个connection 我们必须首先定义一个函数来代替delete
-
//这个删除器函数必须能够完成对shared_ptr中保存的指针进行释放的操作
-
//在本例中，我们的删除器必须接受单个类型为connection*的参数
-
void end_connection(connection *p){
disconnect(*p);}
-
-
//当我们创建一个shared_ptr时，可以传递一个(可选的)指向删除器函数的参数
-
void f(destination &d/*其他参数*/)
-
{
-
connection c =
connect(&d);
-
shared_ptr<connection>
p(&c,end_connection);
-
//使用链接
-
//当f退出时(即使是由于异常而退出)，connection会被正确关闭
-
}
12.1.5unique_ptr
12.2 动态数组
12.3 使用标准库：文本查询程序
小结
转载：https://blog.csdn.net/m0_61548909/article/details/125610578
查看评论