2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Rudis incommoda indicibus;
deleteDimitte facultates, ultrices resource causingdeletePropositum exivit ante Northmanni (exempli gratia, siifmediumreturn) vel enormis exire antequam sera estdeleteDucens ad resource ultricesIn tempor, dolor eget fringilla volutpat. Verbum intelligentiae argutorum callidorum maxime reflectitur in eo quod users attendere non debet ad emissionem facultatum, quia argumentatores callidi te adiuvabunt ut emissionem facultatum perfecte curet facient ordinarie vel exceptiones generales.Cum facultates exspirabunt (munus scopum vel programma finem) liberabuntur.
Faciendum sit nobis monstratorem simplicem callidum
template<typename T>
class CSmartPtr
{
public:
CSmartPtr(T* ptr = nullptr) : mptr(ptr) {}
~CSmartPtr() { delete mptr; }
private:
T* mptr;
};
int main()
{
CSmartPtr<int> ptr(new int());
/*其它的代码...*/
/*
由于ptr是栈上的智能指针对象，不管是函数正常执行完，
还是运行过程中出现异常，栈上的对象都会自动调用析构函数，
在析构函数中进行了delete操作，保证释放资源
*/
return 0;
}
Ideo ex praedictis notis, argumentis callidi in ACERVUS generaliter definiuntur. simul,A dolor regula est genus object monstrator in constructor huius ordinis transmittitur, et regula in destructor dimittitur.Cum hoc genus obiecti in ACERVUM partita ac dimittatur, ipso facto solvetur cum munus nostrum (vel programmatis) finietur.
Ergone definiri potest acervus indicibusque callidior?exempli gratiaCSmartPtr* p = new CSmartPtr(new int);confectio transire potest, definitiopEtsi callidum genus monstratorem est, essentialiter rudis estpAdhuc opus est ut faciam illud manuallydelete, hoc est ad problema quod in principio apertis indicibus optulimus, sic eo non utimur.
Sane callidi indicibus similes esse debent rudibus indicibus, et etiam communes notiones rudium indicibus praebere debent.*et->Munera cumulata duorum operatorium vere eadem sunt ac rudes indicibus adhibitis.
template<typename T>
class CSmartPtr
{
public:
CSmartPtr(T* ptr = nullptr) : mptr(ptr) {}
~CSmartPtr() { delete mptr; }
T& operator*() { return *mptr; }
T* operator->() { return mptr; }
private:
T* mptr;
};
int main()
{
CSmartPtr<int> ptr(new int());
*ptr = 20; // operator*()一定要返回引用，这样才可以赋值
cout << *ptr << endl; // 20
class Test
{
public:
void test() { cout << "call Test::test()" << endl; }
};
CSmartPtr<Test> ptr2 = new Test();
(*ptr2).test(); // (*ptr2)取出Test对象，用对象调用方法
// operator->()返回的是一个指针，实现了用指针调用函数
// 即(ptr2.operator->()) -> test()
ptr2->test();
return 0;
}
Punctum callidum in sectione praecedente perficiendum simillimum est rudiori ordinario in usu, sed adhuc magnas difficultates habet.
CSmartPtr<int> p1(new int());
CSmartPtr<int> p2(p1); // 拷贝构造
Codex currentis directe inruerit, quia exemplar defaltum conditoris breve exemplar facit.p1etp2idemnew intresource;p2Perditio primum remittit opes, deindep1Cum destruitur, fitdeleteFera monstra, programmatis fragores
Quomodo ergo problemata solvenda per exemplum levitatis causatur?RESCRIBOCSmartPtrVide exemplum constructor
CSmartPtr(const CSmartPtr<T>& src) { mptr = new T(*src.mptr); }
Nunc autem in hoc puncto codice regulariter decurritp1etp2Duae variae facultates administrantur. Si utentes eas non intellegunt, mendose existimabuntp1etp2Curo eadem resource
Ideo nefas est nobis ut auctor huius exemplaris scribere
Ita, quomodo solvere problema gravem indicibusque exemplaribus vadum? Duo modi:Indicium callidi sine numeratione referente, argumentatores callidi cum referente numeratione
Inspice hanc sectionem primumDolor indicium non referat numerum
auto_ptr(C ++ 98, nunc deprecatur)scoped_ptr(Bibliotheca boost)unique_ptr(C ++ 11, commendatus)Includit lima cum usura header:#include <memory>
Primum hunc codicem videamus
auto_ptr<int> ptr1(new int());
auto_ptr<int> ptr2(ptr1);
*ptr2 = 20;
cout << *ptr1 << endl;
Cur ingruat.auto_ptrsource code
Potes videre quod exemplar constructionis objectum advenientis appellabitreleasemethodus, haec methodus ponendi_RightSubsidium demonstratum redditur ad novumauto_ptrobjectum simul_Right(vetusauto_ptr)of*_Myptrset adnullptr
In summa, vetus est ponereauto_ptrSubsidium demonstrandum datum est novoauto_ptrTenuit, vetus proponiturnullptr .Unde in codice supra usus est*ptr1Justum nefas.（auto_ptrSemper ultimum dolor monstratorem administrare resource)
Ita,auto_ptrNum in vase adhiberi potest?
int main()
{
vector<auto_ptr<int>> vec;
vec.push_back(auto_ptr<int>(new int(10)));
vec.push_back(auto_ptr<int>(new int(20)));
vec.push_back(auto_ptr<int>(new int(30)));
cout << *vec[0] << endl; // 10
vector<auto_ptr<int>> vec2 = vec;
/* 这里由于上面做了vector容器的拷贝，
相当于容器中的每一个元素都进行了拷贝构造，
原来vec中的智能指针全部为nullptr了，
再次访问就成访问空指针了，程序崩溃
*/
cout << *vec[0] << endl; // 程序崩溃
return 0;
}
Ergo deprecatur in Cauto_ptr nisi applicatio missionis valde simplex est.etauto_ptrDeprecatus est in C ++ XI et abstulit totum in C ++ 17
Summatim:auto_ptrIndicis callidi computationem non referunt, ita tractant problema de brevitate exemplarium proxime priorum describendoauto_ptrsunt profectus estnullptr, nedum ultimumauto_ptrtenere opes
Vos postulo ut bibliothecam Boost installare, quae caput imaginum includit.#include <boost/scoped_ptr.hpp>Promptus ad usus
spectarescoped_ptrSource codice:
template<class T> class scoped_ptr
{
private:
scoped_ptr(scoped_ptr const&);
scoped_ptr& operator=(scoped_ptr const&);
...
};
videri potestscoped_ptrExemplar fabricator et assignationis munus tam privatis sunt, ut res duas has operationes non sustineat nec vocari possit, quod fundamentaliter impediat quominus exemplarium tenuium occurrat.
sicscoped_ptrIn vasis adhiberi non potestscoped_ptrObject exemplum conditor et munus, compilationem error
scoped_ptretauto_ptrdifferentia: dominium explicari potest;auto_ptrOccupatio opum ad nutum transferri potest, dumscoped_ptrOccupatio non transfertur (quia exemplum constructores et assignationis munera debilitata sunt)
scoped_ptrFere non est usus
Vide priusunique_ptrPars codicis fons est:
template<class _Ty, class _Dx>
class unique_ptr
{
public:
/*提供了右值引用的拷贝构造函数*/
unique_ptr(unique_ptr&& _Right) { ... }
/*提供了右值引用的operator=赋值重载函数*/
unique_ptr& operator=(unique_ptr&& _Right) { ... }
/*
删除了unique_ptr的拷贝构造和赋值函数，
因此不能做unique_ptr智能指针对象的拷贝构造和赋值，
防止浅拷贝的发生
*/
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
Visum est desuper;unique_ptrmodicumscoped_ptrIdem fit, hoc est, exemplum constructionis et assignationis cumulatis functionibus debilibus, et utentibus uti prohibenturunique_ptrFacere expressum exemplum constructionis et assignationis ne eventum captiosus monstratorem leves difficultates effingo.
Cum nullum sit exemplum constructor;unique_ptr<int> p1(new int()); unique_ptr<int> p2(p1);Naturaliter malum est
sedunique_ptrPraebet exemplar constructores et functiones assignationis cum parametris referentibus, id est;unique_ptrIndicium dolor praestare potest exemplum constructionis et assignationis operationes per rvalue references, seu generareunique_ptrRes temporales, e.gunique_ptrUt reditus valor functionis, exemplar codicis hoc modo est:
// 示例1
unique_ptr<int> p1(new int());
unique_ptr<int> p2(move(p1)); // 使用了右值引用的拷贝构造
p2 = move(p1); // 使用了右值引用的operator=赋值重载函数
// 示例2
unique_ptr<int> test_uniqueptr()
{
unique_ptr<int> ptr(new int());
return ptr;
}
int main()
{
/*
此处调用test_uniqueptr函数，在return ptr代码处，
调用右值引用的拷贝构造和赋值函数
*/
unique_ptr<int> p = test_uniqueptr(); // 调用带右值引用的拷贝构造函数
p = test_uniqueptr(); // 调用带右值引用的operator=赋值重载函数
return 0;
}
tum utiunique_ptrBeneficium est quod users uti potest aliquid simileunique_ptr<int> p2(move(p1));dicitur, perspici potest quodp1Translatum opibus top2，p1Nullae plures facultates tenenturauto_ptrHoc non erit expressemoveExscripta, intentio manifesta non est. Si stratum subiectam non intellegis, ea non recte uteris.
Simul, fromunique_ptrUt ex nomine videri potest, non potest esse nisi una monstratorem callidum, quod ad extremum auxilium refertur.unique_ptr
Captiosus indicibusque cum numero maxime includitshared_ptretweak_ptrCum secundum numerumbeneficiumHoc est, multiplex indicibus captiosus potest eandem resource tractare.
Secundum numerum: Compositus referat comitem pro singulis resource est.
Cum multiplex indicibus callidiorum ad idem auxilium demonstrare permittitur, quisque monstratorem callidum addet 1 referenti comiti subsidii Ultimus index captiosus erit Cum referat comitem subsidii ab 1 ad 0 decrescet, significat resource dimitti posse.
Accipe quod antea erat implementedCSmartPtrModificationes fac et codicem directe imposuisti:
// 对资源进行引用计数的类
template<typename T>
class RefCnt
{
public:
RefCnt(T* ptr = nullptr) : mptr(ptr)
{
if (mptr != nullptr)
mcount = 1;
}
void addRef() { mcount++; } // 增加资源的引用计数
int delRef() { return --mcount; }
private:
T* mptr;
int mcount;
};
template<typename T>
class CSmartPtr
{
public:
CSmartPtr(T* ptr = nullptr) : mptr(ptr)
{
// 智能指针构造的时候给资源建立引用计数对象
mpRefCnt = new RefCnt<T>(mptr);
}
~CSmartPtr()
{
if (0 == mpRefCnt->delRef())
{
delete mptr;
mptr = nullptr;
}
}
// 实现拷贝构造
CSmartPtr(const CSmartPtr<T>& src)
:mptr(src.mptr), mpRefCnt(src.mpRefCnt)
{
if (mptr != nullptr)
mpRefCnt->addRef();
}
CSmartPtr<T>& operator=(const CSmartPtr<T>& src)
{
// 防止自赋值
if (this == &src)
return *this;
// 本身指向的资源减1
// 如果减1为0释放资源；如果减1不为0直接走
if (0 == mpRefCnt->delRef()) { delete mptr; }
mptr = src.mptr;
mpRefCnt = src.mpRefCnt;
mpRefCnt->addRef();
return *this;
}
T& operator*() { return *mptr; }
T* operator->() { return mptr; }
private:
T* mptr; // 指向资源的指针
RefCnt<T>* mpRefCnt; // 指向该资源引用计数对象的指针
};
// 那么现在就不会报错了，不会对同一个资源释放多次
CSmartPtr<int> ptr1(new int());
CSmartPtr<int> ptr2(ptr1);
CSmartPtr<int> ptr3;
ptr3 = ptr2;
*ptr1 = 20;
cout << *ptr2 << " " << *ptr3 << endl; // 20 20
Hoc dat multiplex indicibus callidiorum ad eandem resource administrandam.
Nihilominus, acutis indicibus, quae nunc efficiunt, non tuta sunt nec in missionibus multi-filatis adhiberi possunt.Effectum a Curryshared_ptretweak_ptrSecum est filum!
shared_ptr：potensDolor indicibus (comit ex opibus possit mutare referat)weak_ptr：debilisDolor indicium (nolite mutare comitem de resource referat)Quod in praecedenti articulo effectum habemusCSmartPtrEtiam fortis dolor indicatorum (comitem de resource mutare potest)
Sic intelligi potest: Infirma dolor monstratorem observe Fortis dolor indicium fortis dolor indiciumobserve Resources (memoria)
Ita,Fortis dolor indicatorum crucis-referat (respectatio circularis) problema quid est ergo?Veni et vide
class B; // 前置声明类B
class A
{
public:
A() { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
shared_ptr<B> _ptrb; // 指向B对象的智能指针
};
class B
{
public:
B() { cout << "B()" << endl; }
~B() { cout << "~B()" << endl; }
shared_ptr<A> _ptra; // 指向A对象的智能指针
};
int main()
{
shared_ptr<A> pa(new A()); // pa指向A对象，A的引用计数为1
shared_ptr<B> pb(new B()); // pb指向B对象，B的引用计数为1
pa->_ptrb = pb; // A对象的成员变量_ptrb也指向B对象，B的引用计数为2
pb->_ptra = pa; // B对象的成员变量_ptra也指向A对象，A的引用计数为2
cout << pa.use_count() << endl;
cout << pb.use_count() << endl;
return 0;
}
operatio effectus;
A()
B()
2
2
Ut videre potes, A et B non destruuntur, quod significat crucem-indicationem facientemnewFacultates, quae exeunt, eximi non possunt, unde in lacus resource!
resolvere;
outmainmunus laxius ;paetpbDuo objecta localia destruuntur, et comites obiecti A et objecti B ab 2 ad 1 respective reducuntur. Conditiones solvendi A et B occurrere non possunt (conditio remissionis est ut referentiae comites A et B reducuntur ad 0), ita duonewObiecta A et B quae exierunt dimitti non possunt, causando memoriae effluoFortis dolor indicatorum crucis-referat (respectatio circularis) problema
Solutio: Utere validis indicibus callidi cum definiendis obiectis, et debilibus acutis acutis cum obiectis indicis.
class B; // 前置声明类B
class A
{
public:
A() { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
weak_ptr<B> _ptrb; // 指向B对象的弱智能指针（引用对象时，用弱智能指针）
};
class B
{
public:
B() { cout << "B()" << endl; }
~B() { cout << "~B()" << endl; }
weak_ptr<A> _ptra; // 指向A对象的弱智能指针（引用对象时，用弱智能指针）
};
int main()
{
// 定义对象时，用强智能指针
shared_ptr<A> pa(new A()); // pa指向A对象，A的引用计数为1
shared_ptr<B> pb(new B()); // pb指向B对象，B的引用计数为1
// A对象的成员变量_ptrb也指向B对象，B的引用计数为1，因为是弱智能指针，引用计数没有改变
pa->_ptrb = pb;
// B对象的成员变量_ptra也指向A对象，A的引用计数为1，因为是弱智能指针，引用计数没有改变
pb->_ptra = pa;
cout << pa.use_count() << endl; // 1
cout << pb.use_count() << endl; // 1
return 0;
}
operatio effectus;
A()
B()
1
1
~B()
~A()
videri potest, emainmunus laxius ;paetpbDestructa sunt duo objecta localia, et referuntur comites obiecti A et objecti B respective ab 1 ad 0, ad conditiones solvendas A, B. Ergo.newObiectum et B objectum destructum est, quod problema solvitur.Fortis dolor indicatorum crucis-referat (respectatio circularis) problema
videri potest;weak_ptrInfirmis acutis indicibus non mutare narrationem comitem subsidii, id significat quod monstratorem callidum debilem solum observat an obiectum sit vivere (num 0 relatio est) et facultate uti non potest.
Si hoc tempore, adde in classe Avoid testA() { cout << "非常好用的方法！！" << endl; }Talem methodum addit B .void func() { _ptra->testA(); }Estne bene ad hunc modum vocare?
*et->Munera operariorum cumulata functionibus uti non possunt indicibus rudibus similesSolutio:
class B; // 前置声明类B
class A
{
public:
A() { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
void testA() { cout << "非常好用的方法！！" << endl; }
weak_ptr<B> _ptrb; // 指向B对象的弱智能指针（引用对象时，用弱智能指针）
};
class B
{
public:
B() { cout << "B()" << endl; }
~B() { cout << "~B()" << endl; }
void func()
{
shared_ptr<A> sp = _ptra.lock(); // 提升方法，出函数作用域就自动析构了
if (sp != nullptr)
sp->testA();
}
weak_ptr<A> _ptra; // 指向A对象的弱智能指针（引用对象时，用弱智能指针）
};
int main()
{
shared_ptr<A> pa(new A());
shared_ptr<B> pb(new B());
pa->_ptrb = pb;
pb->_ptra = pa;
cout << pa.use_count() << endl; // 1
cout << pb.use_count() << endl; // 1
pb->func();
return 0;
}
Etsi
weak_ptrobiectum non habet, sed transire potestlock()methodum obtinere conatur regula obiectishared_ptrsi res adhuc vivit (i.e. sunt aliaeshared_ptrmonstrare)lock()monstratorem reddet objectishared_ptrAlioquin valorem inane reddeturshared_ptr
usus
lock()A typicam sem pro modi est, cum tempus accessum non requiriturweak_ptrobjectum ostendit, et simul augere nolunt vivo comiti objecti
operatio effectus;
A()
B()
1
1
非常好用的方法！！
~B()
~A()
Hic recte appellatum videre potes!
Videamus unumSecta salus exitibus cum accessu communium objectorum ex pluribus stamina: sequela A et filum B accessum rei communi. Si filum A destruit obiectum, filum B vocare debet modum obiecti communis membrum Si ad rem accedere coneris, inopinatus error erit.
Primum vide in codice sequenti:
class A
{
public:
A() { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
void testA() { cout << "非常好用的方法！！" << endl; }
};
// 子线程
void handler01(A* q)
{
// 睡眠两秒，此时main主线程已经把A对象给delete析构掉了
std::this_thread::sleep_for(std::chrono::seconds(2));
q->testA();
}
// main线程
int main()
{
A* p = new A();
thread t1(handler01, p);
delete p;
//阻塞当前线程，直到调用join()的线程结束
t1.join();
return 0;
}
in executioneq->testA();Cum hoc dictum sit,mainCommunis obiectum filo destructum est, quod irrationabile est.
Si vis fieriqSi monstrator ad Obiectum accedere vult, determinare debet utrum Res viva sittestAQuaestio non est per modum;testA dubium habet!Id est, narranturqCum accessu obiecti A, deprehendere debes utrum obiectum A sit vivum. Quomodo hanc quaestionem solvere debes?
Inspice hunc codicem:
// 子线程
void handler01(weak_ptr<A> wp)
{
// 睡眠两秒
std::this_thread::sleep_for(std::chrono::seconds(2));
shared_ptr<A> sp = wp.lock();
if (sp != nullptr)
sp->testA();
else
cout << "A对象已经析构，不能再访问！" << endl;
}
// main线程
int main()
{
shared_ptr<A> p(new A());
thread t1(handler01, weak_ptr<A>(p));
t1.join();
return 0;
}
operatio effectus;
A()
非常好用的方法！！
~A()
Potes videre quod curritsp->testA();,quodmainNomen sequelat1.join()Modus expectat puerum stamina ad finemwppasslockFeliciter promotus estsp
Mutare codicem supra:
// 子线程
void handler01(weak_ptr<A> wp)
{
// 睡眠两秒
std::this_thread::sleep_for(std::chrono::seconds(2));
shared_ptr<A> sp = wp.lock();
if (sp != nullptr)
sp->testA();
else
cout << "A对象已经析构，不能再访问！" << endl;
}
// main线程
int main()
{
{
shared_ptr<A> p(new A());
thread t1(handler01, weak_ptr<A>(p));
t1.detach();
}
std::this_thread::sleep_for(std::chrono::seconds(3));
return 0;
}
operatio effectus;
A()
~A()
A对象已经析构，不能再访问！
Ut videre potes, scopos posuimus et etiam posuit1Fila separare, indicibusque callidipCum A extra ambitum destruatur, hoc tempore impressum eritA对象已经析构，不能再访问！, ille estwppasslockNon feliciter upgrade utsp
Superius est sequela salus exitus cum multi- stamina objectorum communium accessusshared_ptretweak_ptrTypicam applicationem.
Articulus relatio:Alta intelligentia indicia dolor C++
technologiae technologiae plus quam 30 annos operam dedit et in variis linguis proficit ut java, linux, javascript, php, css, etc. Multas contributiones in aperto fonte campo fecit elit documentorum statione ad communicandas quaestiones in technologia progressus ad futuram referentiam
