天空在线网站建设,内蒙古建设厅网站删除,网络建设规划方案怎么写,嘉兴市城市建设门户网站《C Primer》 第十二章 动态内存
动态内存与智能指针
shared_ptr允许多个指针指向同一个对象#xff1b;unique_ptr则“独占”所指向的对象#xff0c;weak_ptr指向shared_ptr所管理的对象。这三种类型都定义在memory头文件中。
shared_ptr类#xff1a;默认初始化的智能…《C Primer》 第十二章 动态内存
动态内存与智能指针
shared_ptr允许多个指针指向同一个对象unique_ptr则“独占”所指向的对象weak_ptr指向shared_ptr所管理的对象。这三种类型都定义在memory头文件中。
shared_ptr类默认初始化的智能指针中保存着一个空指针。
shared_ptrstring p1; //shared_ptr,可以指向string
shared_ptrlistint p2; //shared_ptr, 可以指向int的list//如果p1不为空检测它是否指向一个空string
if(p1 p1-empty())*p1 hi;//如果p1指向一个空string解引用p1,将一个新值赋予stringmake_shared函数在动态内存中分配一个对象并初始化它返回指向此对象的shared_ptr。定义在memory中。
//指向一个值为42的int的shared_ptr
shared_ptrint p3 make_sharedint (42);
//p4指向一个值为999999999的string
shared_ptrstring p4 make_sharedstring (10,9);
//p5指向一个值初始化的int即值为0
shared_ptrint p5 make_sharedint();
//通常使用auto定义一个对象来保存make_shared的结果
//p6指向一个动态分配的空vectorstring
auto p6 make_sharedvectorstring();shared_ptr的拷贝和构造
auto p make_sharedint(42);//p指向的对象只有一个引用者
auto q(p);//p和q指向相同对象此对象有两个引用者定义StrBlob类
class StrBlob{
public:typedef std::vectorstd::string::size_type size_type;StrBlob();StrBlob(std::initializer_liststd::string i1);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_ptrstd::vectorstd::string data;//如果data[i]不合法抛出一个异常void check(size_type i, const std::string msg) const;
};元素访问成员函数
void StrBlob::check(size_type i, const string msg) const
{if(idata-size())throw out_of_range(msg);
}string StrBlob::front()
{//如果vector为空check会抛出一个异常check(0, front on empty StrBlob);
}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();
}直接管理内存运算符new分配内存delete释放new分配的内存。
使用new动态分配和初始化对象new返回一个指向该对象的指针
int *pi new int; //pi指向一个动态分配、并返回该对象的指针string *ps new string;//初始化为空string
int *pi new int;//pi指向一个未初始化的intint *pi new int(1024);//pi指向的对象的值是1024
string *ps new string(10,9); //*ps为“999999999”//vector有10个元素值依次从0~9
vectorint *pv new vectorint {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为0auto 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;内存耗尽
//如果分配失败new返回一个空指针
int *p1 new int;//如果分配失败new抛出std::bad_alloc
int *p2 new (nothrow) int;//如果分配失败new返回一个空指针释放动态内存销毁给定的指针指向的对象释放对应的内存。
delete p;//p必须指向一个动态分配的对象或是一个空指针指针值和delete传递给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 int *pci new const int(1024);
delete pci;//正确释放一个const对象动态对象的生存期直到被释放时为止
//factory返回一个指针指向一个动态分配的对象
Foo* factory(T arg)
{//视情况处理argreturn new Foo(arg);//调用者负责释放此内存
}void use_factory(T arg)
{Foo *p factory(arg);//使用p但不delete它
}//p离开了它的作用域但它所指向的内存没有被释放void use_factory(T arg)
{Foo *p factory(arg);//使用pdelete p;//现在记得释放内存我们已经不需要它了
}Foo* use_factory(T arg)
{Foo *p factory(arg);//使用preturn p;//调用者必须释放内存
}提供优先的保护动态内存的一个基本问题是可能有多个指针指向相同的内存。
int *p (new int(42));//p指向动态内存
auto q p; //p和q指向相同的内存
delete p; //p和q均变为无效
p nullptr; //指出p不再绑定到任何对象shared_ptr和new结合使用
shared_ptrdouble p1;//shared_ptr可以指向一个double
shared_ptrint p2(new int(42));//p2指向一个值为42的int//不能将一个内置指针隐式转换为一个智能指针
shared_ptrint p1 new int(1024);//错误必须使用直接初始化形式
shared_ptrint p2(new int(1024));//正确使用了直接初始化形不能进行内置指针到智能指针间的隐式转换。一个返回shared_ptr的函数不能在其返回语句中隐式转换为一个普通指针
shared_ptrint clone(int p){return new int(p);//错误隐式转换为shared_ptrint
}//必须将shared_ptr显式绑定到一个想要返回的指针上
shared_ptrint clone(int p){//正确显示地用int*创建shared_ptrintreturn shared_ptrint(new int(p));
}不要混合使用普通指针和智能指针也不要使用get初始化另一个智能指针或为智能指针赋值。
shared_ptrint p(new int(42));//引用计数为1
int *q p.get();//正确但使用q时要注意不要让它管理的指针被释放
{//新程序块
//未定义两个独立的shared_prt指向相同的内存shared_ptrint(q);
}//程序块结束q被销毁它指向的内存本释放
int foo *p; //未定义p指向的内存已经被释放了其它shared_ptr操作
p new int(1024); //错误不能将一个指针赋予shared_ptr
p.reset(new int(1024)); //正确p指向一个新对象if(!p.unique())p.reset(new string(*p));//我们不是唯一用户分配新的拷贝
*p newVal;智能指针和异常
void f()
{shared_ptrint sp(new int(42));//分配一个新对象//这段代码抛出一个异常且在f中未被捕获
}//在函数结束时shared_ptr自动释放内存void f()
{int *p new int(42);//动态分配一个新对象//这段代码抛出一个异常且在f中未被捕获delete ip;//退出之前释放内存
}智能指针和哑类“
struct destination;//表示我们正在连接什么
struct connection;//使用连接所需的信息
connection connect(destination*);//打开连接
void disconnect(connection);//关闭给定的连接
void f(destination d)
{//获得一个连接记住使用玩后要关闭它connection c connect(d);//使用连接//如果我们在f退出之前忘记调用disconnect,就无法关闭c了
}//在创建shared_ptr时可以传递一个可选的指向删除器函数的参数
void f(destination d)
{//获得一个连接记住使用玩后要关闭它connection c connect(d);shared_ptrconnection p(c, end_connection);//使用连接//如果我们在f退出之前忘记调用disconnect,就无法关闭c了
}unique_ptr与shared_ptr不同某个时刻只能有一个unique_ptr指向一个给定对侠女。当unique_ptr被销毁时它所指向的对象也被销毁。
unique_ptrdouble p1;//可以指向一个douvbble的unique_ptr
unique_ptrint p2(new int(42));//p2指向一个值为42的int
//由于一个unique_ptr拥有它指向的对象因此unique_ptr不支持普通的拷贝或赋值操作
unique_ptrstring p1(new string(Stegosaurus));
unique_ptrstring p2(p1);//错误unique_ptr不支持拷贝
unique_ptrstring p3;
p3 p1;//错误unique_ptr不支持赋值使用unique_ptr参数和返回unique_ptr
unique_ptrint clone(int p){//正确从int*创建一个unique_ptrintreturn unique_ptrint (new int(p));
}
//还可以返回一个局部对象的拷贝
unique_ptrint clone(int p){unique_ptrint ret(new int(p));//...return ret;
}weak_ptr是一种不控制所指向对象生存期的智能指针它指向一个shared_ptr管理的对象。 创建一个weak_ptr时要用一个shared_ptr来初始化它
auto p make_sharedint(42);
weak_ptrint wp(p);//wp弱共享p;p的引用计数未改变if(shared_ptrint np wp.lock()){//如果np不为空则条件成立//在if中np与p共享对象
}核查指针类
//对于访问一个不存在元素的尝试StrBlobPtr抛出一个尝试
class StrBlobPtr{
public:StrBlobPtr(): curr(0){ }StrBlobPtr(StrBlob a, size_t sz 0):wptr(a.data), curr(sz){ }std::string deref() const;StrBlobPtr incr();//前缀递增
private://若检查成功check返回一个指向vector的shared_ptrstd::shared_ptrstd::vectorstd::stringcheck(std::size_t, const std::string) const;//保存一个weak_ptr,意味着底层vector可能被销毁std::weak_ptrstd::vectorstd::string wptr;std::size_t curr;//在数组中的当前位置
}//StrBlobPtr的check成员与StrBlob中的同名成员不同它还要检查指针指向的vector是否还存在
std::shared_ptrstd::vectorstd::string
StrBlobPtr::check(std::size_t i, const std::string msg) const
{auto ret wptr.lock();//vector还存在吗if(!ret)throw std::runtime_error(unbound StrBlobPtr);if(iret-size())throw std::out_of_range(msg);return ret;//否则返回指向vector的shared_ptr
}指针操作
//deref成员调用check检查使用vector是否安全以及curr是否在合法范围内
std::string StrBlobPtr::deref() const
{auto p check(curr, dereference past end);return (*p)[curr]; //*p)是对象所指向的vector
}//incr成员也调用check
//前缀地递增返回递增后的对象的引用
StrBlobPtr StrBlobPtr::incr()
{//如果curr已经指向容器的尾后位置就不能递增它check(curr, increment past end of StrBlobPtr);cur;//推进当前位置return *this;
}//对于StrBlob中的友元声明来说此前置声明是必要的
class StrBlobPtr;
class StrBlob{friend class StrBlobPtr;//返回指向首元素和尾后元素的StrBlobPtrStrBlobPtr begin() { return StrBlobPtr(*this); }StrBlobPtr end(){auto ret StrBlobPtr(*this, data-size());return ret;}
}动态数组
new和数组让new分配一个动态数组需要在类型名之后跟一对方括号在其中指明要分配的对象的数目。
//调用get_size确定分配多少个int
int *pia new int[get_size()];//pia指向第一个inttypedef int arrT[42];//arrT表示42个int的数组类型
int *p new arrT;//分配一个42个int的数组p指向第一个int初始化动态分配对象的数组默认情况下new分配的对象都是默认初始化的。
int *pia new int[10];//10个未初始化的int
int *pia2 new int[10];//10个值初始化为0的int
string *psa new string[10];//10个空string
string *psa2 new string[10]();//10个空string//10个int分别用列表中对应的初始化器初始化
int *pia3 new int[10]{0,1,2,3,4,5,6,7,8,9};
//10个string,前4个用给定的初始化器初始化剩余的进行值初始化
string *psa3 new string[10]{a, an, the, string(3,x)};动态分配一个空数组是合法的
size_t n get_size();//get_size返回需要的元素的数目
int* p new int[n]; //分配数组保存元素
for(int* q p; q ! pn; q)/*处理数组*/;char arr[0];//错误不能定义长度为0的数组
char *cp new char[0];//正确但cp不能解引用释放动态数组
delete p;//p必须指向一个动态分配的对象或为空
delete [] pa;//pa必须指向一个动态分配的数组或为空typedef int arrT[42];//arrT是42个int的数组的类型别名
int *p new arrT;//分配一个42个int的数组p指向第一个元素
delete []p;//方括号是必须的因为我们当初分配的是一个数组智能指针与动态数组标准库提供了一个可以管理new分配的数组的unique_ptr版本。为了用一个unique_ptr管理动态数组我们必须在对象类型后面跟一对空方括号。
//up指向一个包含10个未初始化int的数组
unique_ptrint[] up(new int[10]);
up.release();//自动用delete[]销毁其指针for(size_t i 0; i!10; i)up[i] i;//为每个元素赋予一个新值//为了使用shared_ptr,必须提供一个删除器
shared_ptrint sp(new int[10], [](int *p) { delete[] p; });
sp.reset();//使用我们提供的lambda释放数组它使用delete[]//shared_ptr未定义下标运算符并且不支持指针的算术运算
for(size_t i0; i!10; i)*(sp.get() i) i;//使用get获取一个内置指针[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GUiCOZIp-1677828130213)(C:\Users\21147\AppData\Roaming\Typora\typora-user-images\1675233306285.png)]
allocator类定义在头文件memory中将内存分配和对象构造分离开来。当一个allocator对象分配内存时它会根据给定的对象类型来确定恰当的内存大小和对齐位置
allocatorstring alloc;//可以分配string的allocator对象
auto const p alloc.allocate(n);//分配n个未初始化的stringallocator分配未构造的内存
auto q p;//q指向最后构造的元素之后的位置
alloc.construct(q);//*q为空字符串
alloc.construct(q, 10, c);//*q为cccccccccc
alloc.construct(q, hi); //*q为hicout*pendl;//正确使用string的输出运算符
cout*qendl;//灾难q指向未构造的内存拷贝和填充未初始化内存的算法 //分配比vi中元素所占用空间大一倍的动态内存
auto p alloc.allocate(vi.size()*2);
//通过拷贝vi中的元素来构造从p开始的元素
auto q uninitialized_copy(vi.begin(), vi.end(), p);
//将剩余元素初始化为42
uninitialized_fill_n(q,vi.size(),42);概念总结
为了更安全地使用动态对象标准库定义了两个智能指针俩管理动态分配的对象。当一个对象应该被释放时指向它的智能指针可以确保自动地释放它。
静态内存保存局部static对象、类static数据成员以及定义在任何函数之外的变量。
栈内存保存定义在函数内的非static对象。分配在静态或栈内存的对象由编译器自动创建和销毁。
对于栈对象仅在其定义的程序运行时才存在static对象在使用之前分配在程序结束时销毁。 shared_ptr为什么没有release成员
