යාවත්කාලීන කරන්න
මෙම පිළිතුර තරමක් පැරණි වන අතර, ඒ අවස්ථාවේ දී 'හොඳ' දේ විස්තර කරයි, එය බූස්ට් පුස්තකාලය විසින් සපයන ලද ස්මාර්ට් පොයින්ටර් ය. C ++ 11 සිට, පුස්තකාලයක් ප්රමාණවත් ස්මාර්ට් සූචක වර්ග ලබා දී ඇත, ඔබ භාවිතය අනුග්රහය යුතු නිසා std::unique_ptr, std::shared_ptrසහ std::weak_ptr.
එසේම විය std::auto_ptr. එය පිටපත් කිරීමේ “විශේෂ” භයානක හැකියාවක් ද ඇති බව හැරෙන්නට, එය බොහෝ දුරට විෂය පථයට සමාන විය - එය අනපේක්ෂිත ලෙස හිමිකාරිත්වය මාරු කරයි.
එය C ++ 11 හි ඉවත් කර C ++ 17 හි ඉවත් කරන ලදි , එබැවින් ඔබ එය භාවිතා නොකළ යුතුය.
std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership.
// p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
පැරණි පිළිතුර
ස්මාර්ට් පොයින්ටරය යනු පෙන්වා ඇති වස්තුවෙහි ආයු කාලය කළමනාකරණය කිරීම සඳහා 'අමු' (හෝ 'හිස්') සී ++ දර්ශකයක් ඔතා ඇති පන්තියකි. තනි ස්මාර්ට් පොයින්ටර් වර්ගයක් නොමැත, නමුත් ඒ සියල්ලම ප්‍රායෝගික ආකාරයකින් අමු දර්ශකයක් වියුක්ත කිරීමට උත්සාහ කරයි.
අමු දර්ශකයන්ට වඩා ස්මාර්ට් පොයින්ටර්ස් වඩාත් කැමති විය යුතුය. ඔබට දර්ශකයන් භාවිතා කළ යුතු යැයි ඔබට හැඟේ නම් (මුලින්ම ඔබ සැබවින්ම එසේ කරන්නේ නම් සලකා බලන්න ), සාමාන්‍යයෙන් ඔබට ස්මාර්ට් පොයින්ටරයක් භාවිතා කිරීමට අවශ්‍ය වනුයේ අමු දර්ශකයන් සමඟ ඇති බොහෝ ගැටලු සමනය කළ හැකි නිසාය.
අමු දර්ශකයන් සමඟ, ක්‍රමලේඛකයාට වස්තුව තවදුරටත් ප්‍රයෝජනවත් නොවන විට එය පැහැදිලිවම විනාශ කළ යුතුය.
// Need to create the object to achieve some goal
MyObject* ptr = new MyObject();
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?
සංසන්දනය කිරීමෙන් ස්මාර්ට් පොයින්ටරයක් මඟින් වස්තුව විනාශ වන්නේ කවදාද යන්න පිළිබඳ ප්‍රතිපත්තියක් අර්ථ දක්වයි. ඔබ තවමත් වස්තුව නිර්මාණය කළ යුතුව ඇත, නමුත් එය විනාශ කිරීම ගැන ඔබට තවදුරටත් කරදර විය යුතු නැත.
SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.
// Destruction of the object happens, depending
// on the policy the smart pointer class uses.
// Destruction would happen even if DoSomething()
// raises an exception
භාවිතා වන සරල ප්රතිපත්ති එවැනි විසින් ක්රියාත්මක ලෙස ස්මාර්ට් පහිටුම් දක්වනය දවටනය වස්තුව, විෂය පථය සම්බන්ධ boost::scoped_ptrහෝ std::unique_ptr.
void f()
{
{
std::unique_ptr<MyObject> ptr(new MyObject());
ptr->DoSomethingUseful();
} // ptr goes out of scope --
// the MyObject is automatically destroyed.
// ptr->Oops(); // Compile error: "ptr" not defined
// since it is no longer in scope.
}
බව කරුණාවෙන් std::unique_ptrඅවස්ථා පිටපත් කල නොහැක. මෙය දර්ශකය කිහිප වතාවක් මකා දැමීම වළක්වයි (වැරදියට). කෙසේ වෙතත්, ඔබට එය ඇමතීමේ වෙනත් කාර්යයන් වෙත යොමු කළ හැකිය.
std::unique_ptrඔබට යම් වස්තුවක ආයු කාලය නිශ්චිත කේත කොටසකට සම්බන්ධ කිරීමට අවශ්‍ය වූ විට s ප්‍රයෝජනවත් වේ, නැතහොත් ඔබ එය වෙනත් වස්තුවක් තුළ සාමාජික දත්ත ලෙස කාවැද්දුවහොත් එම වස්තුවේ ආයු කාලය. කේතයේ අඩංගු කොටස පිටවන තුරු හෝ අඩංගු වස්තුව විනාශ වන තුරු වස්තුව පවතී.
වඩාත් සංකීර්ණ ස්මාර්ට් පොයින්ටර් ප්‍රතිපත්තියක් මඟින් යොමු දර්ශකය ගණනය කිරීම ඇතුළත් වේ. මෙය දර්ශකය පිටපත් කිරීමට ඉඩ දෙයි. වස්තුව පිළිබඳ අවසාන "යොමුව" විනාශ වූ විට, වස්තුව මකා දමනු ලැබේ. මෙම ප්‍රතිපත්තිය ක්රියාත්මක වන්නේ boost::shared_ptrසහ std::shared_ptr.
void f()
{
typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
MyObjectPtr p1; // Empty
{
MyObjectPtr p2(new MyObject());
// There is now one "reference" to the created object
p1 = p2; // Copy the pointer.
// There are now two references to the object.
} // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero.
// The object is deleted.
ඔබේ වස්තුවේ ආයු කාලය වඩාත් සංකීර්ණ වන විට යොමු ගණනය කළ දර්ශක ඉතා ප්‍රයෝජනවත් වන අතර එය කේතයේ යම් කොටසකට හෝ වෙනත් වස්තුවකට කෙලින්ම සම්බන්ධ නොවේ.
යොමු කරන ලද දර්ශකයන්ට යොමු දැක්වීමේ එක් අඩුපාඩුවක් තිබේ - භයානක යොමු කිරීමක් නිර්මාණය කිරීමේ හැකියාව:
// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!
තවත් හැකියාවක් වන්නේ චක්‍රලේඛ යොමු කිරීම:
struct Owner {
std::shared_ptr<Owner> other;
};
std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1
// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!
මෙම ගැටළුව විසඳීම සඳහා, බූස්ට් සහ සී ++ 11 යන දෙකම weak_ptra සඳහා දුර්වල (ගණනය නොකළ) යොමු කිරීමක් අර්ථ දැක්වීමට a අර්ථ දක්වා ඇත shared_ptr.