হালনাগাদ
এই উত্তরটি বরং পুরানো, এবং তাই সেই সময়ে 'ভাল' কী ছিল তা বর্ণনা করে যা বুস্ট গ্রন্থাগারের দ্বারা সরবরাহিত স্মার্ট পয়েন্টার ছিল। সি ++ 11 সাল থেকে, স্ট্যান্ডার্ড লাইব্রেরি পর্যাপ্ত স্মার্ট পয়েন্টার টাইপ সরবরাহ করেছে, এবং তাই আপনার ব্যবহারের পক্ষে উচিত std::unique_ptr, std::shared_ptrএবং std::weak_ptr।
এছাড়াও ছিল std::auto_ptr। এটি অনেকটা একটি স্কোপড পয়েন্টারের মতো ছিল, কেবল এটির অনুলিপি করার মতো "বিশেষ" বিপজ্জনক ক্ষমতাও ছিল - যা অপ্রত্যাশিতভাবে মালিকানাও স্থানান্তর করে।
এটি সি ++ 11 এ অবহেলা করা হয়েছিল এবং সি ++ 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.
পুরানো উত্তর
স্মার্ট পয়েন্টার হ'ল এমন একটি শ্রেণি যা "কাঁচা" (বা 'বেয়ার') সি ++ পয়েন্টারকে আবৃত করে, যাতে অবজেক্টটির দিকে নির্দেশ করা হচ্ছে তার জীবনকাল পরিচালনা করতে। কোনও একক স্মার্ট পয়েন্টার টাইপ নেই, তবে তারা সকলেই ব্যবহারিক উপায়ে কাঁচা পয়েন্টার বিমূর্ত করার চেষ্টা করে try
স্মার্ট পয়েন্টারগুলি কাঁচা পয়েন্টারগুলির চেয়ে বেশি পছন্দ করা উচিত। আপনি যদি মনে করেন যে আপনাকে পয়েন্টারগুলি ব্যবহার করতে হবে (প্রথমে যদি আপনি সত্যিই তা করেন তবে বিবেচনা করুন), আপনি সাধারণত একটি স্মার্ট পয়েন্টার ব্যবহার করতে চান কারণ এটি কাঁচা পয়েন্টারগুলির সাথে অনেকগুলি সমস্যা উপশম করতে পারে, মূলত অবজেক্টটি মুছতে এবং স্মৃতি ফাঁস করতে ভুলে যায়।
কাঁচা পয়েন্টার সহ, প্রোগ্রামারটিকে স্পষ্টভাবে বস্তুটি ধ্বংস করতে হয় যখন এটি আর কার্যকর হয় না।
// 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_ptrs কার্যকর হয় যখন আপনি কোনও নির্দিষ্ট কোডের অবজেক্টের জীবনকাল বেঁধে রাখতে চান বা আপনি যদি কোনও অন্য অবজেক্টের মধ্যে সদস্য ডেটা হিসাবে এম্বেড করে থাকেন তবে other অন্যান্য বস্তুর আজীবন। কোড সহ ধারণকৃত ব্লকটি না বের হওয়া অবধি বা উপস্থিত উপাদানটি নিজেই ধ্বংস না হওয়া অবধি অবজেক্টটি বিদ্যমান।
আরও জটিল স্মার্ট পয়েন্টার নীতিতে পয়েন্টার গণনা করে রেফারেন্স জড়িত। এটি পয়েন্টারটি অনুলিপি করার অনুমতি দেয়। যখন অবজেক্টের সর্বশেষ "রেফারেন্স" নষ্ট হয়ে যায়, বস্তুটি মুছে ফেলা হয়। এই নীতিটি বাস্তবায়ন করেছে 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_ptrএকটিতে দুর্বল (আনসক্টেড) রেফারেন্সটি সংজ্ঞায়িত করার জন্য একটিকে সংজ্ঞায়িত করেছে shared_ptr।