ما هو المؤشر الذكي ومتى يجب أن أستخدمه؟

Question

ما هو المؤشر الذكي ومتى يجب أن أستخدمه؟

Answer 1

تحديث

هذه الإجابة قديمة إلى حد ما، وبالتالي تصف ما كان "جيدًا" في ذلك الوقت، والذي كان عبارة عن مؤشرات ذكية مقدمة من مكتبة Boost.منذ C++ 11، قدمت المكتبة القياسية أنواعًا كافية من المؤشرات الذكية، لذا يجب عليك تفضيل استخدام std::unique_ptr, std::shared_ptr و std::weak_ptr.

يوجد ايضا std::auto_ptr.إنه يشبه إلى حد كبير مؤشر النطاق، باستثناء أنه يتمتع أيضًا بقدرة خطيرة "خاصة" على النسخ - والتي تنقل الملكية أيضًا بشكل غير متوقع! لقد تم إهماله وفقًا لأحدث المعايير، لذا لا يجب استخدامه.استخدم ال std::unique_ptr بدلاً من.

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.

---

إجابة قديمة

المؤشر الذكي هو فئة تحتوي على مؤشر C++ "خام" (أو "عاري")، لإدارة عمر الكائن الذي تتم الإشارة إليه.لا يوجد نوع واحد من المؤشرات الذكية، لكن جميعها تحاول تجريد المؤشر الخام بطريقة عملية.

يجب تفضيل المؤشرات الذكية على المؤشرات الأولية.إذا كنت تشعر أنك بحاجة إلى استخدام المؤشرات (فكر أولاً في ما إذا كنت حقًا افعل)، قد ترغب عادةً في استخدام مؤشر ذكي لأن ذلك يمكن أن يخفف العديد من المشكلات المتعلقة بالمؤشرات الأولية، وخاصةً نسيان حذف الكائن وتسريب الذاكرة.

باستخدام المؤشرات الأولية، يتعين على المبرمج تدمير الكائن بشكل صريح عندما لا يعود مفيدًا.

// 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!

للتغلب على هذه المشكلة، قام كل من Boost وC++11 بتحديد ملف weak_ptr لتحديد مرجع ضعيف (غير محسوب) إلى أ shared_ptr.

Answer 2

إليك إجابة بسيطة لهذه الأيام من لغة C++ الحديثة:

• ما هو المؤشر الذكي؟
  إنه نوع يمكن استخدام قيمه مثل المؤشرات، ولكنه يوفر الميزة الإضافية لإدارة الذاكرة التلقائية:عندما لا يعد المؤشر الذكي قيد الاستخدام، يتم إلغاء تخصيص الذاكرة التي يشير إليها (انظر أيضًا التعريف الأكثر تفصيلاً على ويكيبيديا).
• متى يجب أن أستخدم واحدة؟
  في التعليمات البرمجية التي تتضمن تتبع ملكية جزء من الذاكرة، أو تخصيصها أو إلغاء تخصيصها؛غالبًا ما يوفر عليك المؤشر الذكي الحاجة إلى القيام بهذه الأشياء بشكل صريح.
• ولكن ما هو المؤشر الذكي الذي يجب أن أستخدمه في أي من هذه الحالات؟
  • يستخدم std::unique_ptr عندما لا تنوي الاحتفاظ بمراجع متعددة لنفس الكائن.على سبيل المثال، استخدمه كمؤشر إلى الذاكرة التي يتم تخصيصها عند إدخال بعض النطاقات وإلغاء تخصيصها عند الخروج من النطاق.
  • يستخدم std::shared_ptr عندما تريد الإشارة إلى الكائن الخاص بك من أماكن متعددة - ولا تريد إلغاء تخصيص الكائن الخاص بك حتى تختفي كل هذه المراجع نفسها.
  • يستخدم std::weak_ptr عندما تريد الإشارة إلى الكائن الخاص بك من أماكن متعددة - لتلك المراجع التي من المقبول تجاهلها وإلغاء تخصيصها (لذا سيلاحظون فقط أن الكائن قد اختفى عندما تحاول إلغاء الإشارة إليه).
  • لا تستخدم boost:: المؤشرات الذكية أو std::auto_ptr إلا في الحالات الخاصة التي يمكنك قراءتها إذا لزم الأمر.
• مهلا، أنا لم أسأل أي واحد للاستخدام!
  آه، لكنك أردت حقًا أن تعترف بذلك.
• إذن متى يجب علي استخدام المؤشرات العادية؟
  في الغالب في التعليمات البرمجية التي تكون غافلة عن ملكية الذاكرة.سيكون هذا عادةً في الوظائف التي تحصل على مؤشر من مكان آخر ولا تقوم بتخصيصها أو إلغاء تخصيصها، ولا تخزن نسخة من المؤشر التي تدوم بعد تنفيذها.

Answer 3

المؤشر الذكي هو نوع يشبه المؤشر مع بعض الوظائف الإضافية، على سبيل المثال.تخصيص الذاكرة تلقائيًا، والعد المرجعي، وما إلى ذلك.

مقدمة صغيرة متاحة على الصفحة المؤشرات الذكية - ماذا، لماذا، أي؟.

أحد أنواع المؤشرات الذكية البسيطة هو std::auto_ptr (الفصل 20.4.5 من معيار C++)، والذي يسمح بإلغاء تخصيص الذاكرة تلقائيًا عندما تكون خارج النطاق وهو أكثر قوة من استخدام المؤشر البسيط عند طرح الاستثناءات، على الرغم من أنه أقل مرونة.

نوع آخر مناسب هو boost::shared_ptr الذي ينفذ العد المرجعي ويقوم بإلغاء تخصيص الذاكرة تلقائيًا عند عدم وجود أي مراجع للكائن.يساعد هذا في تجنب تسرب الذاكرة كما أنه سهل الاستخدام في التنفيذ رايي.

تمت تغطية الموضوع بعمق في الكتاب "قوالب C++:الدليل الكامل" بقلم ديفيد فانديفورد، نيكولاي م.جوسوتيس, ، الفصل الفصل 20.المؤشرات الذكية.بعض المواضيع التي تم تناولها:

• الحماية من الاستثناءات
• أصحاب، (ملاحظة، الأمراض المنقولة جنسيا::auto_ptr هو تنفيذ هذا النوع من المؤشر الذكي)
• الحصول على الموارد هو التهيئة (يستخدم هذا بشكل متكرر لإدارة الموارد الآمنة للاستثناءات في C++)
• قيود الحامل
• العد المرجعي
• الوصول المضاد المتزامن
• التدمير وإلغاء التخصيص

Answer 4

التعاريف المقدمة من كريس وسيرغديف وليود صحيحة.أفضّل تعريفًا أبسط، فقط لإبقاء حياتي بسيطة:المؤشر الذكي هو ببساطة فئة تعمل على زيادة التحميل على -> و * العاملين.مما يعني أن الكائن الخاص بك يبدو كمؤشر دلاليًا ولكن يمكنك جعله يقوم بأشياء أكثر روعة، بما في ذلك حساب المراجع والتدمير التلقائي وما إلى ذلك.shared_ptr و auto_ptr تكون كافية في معظم الحالات، ولكنها تأتي مع مجموعة خاصة بها من الخصوصيات الصغيرة.

Answer 5

يشبه المؤشر الذكي المؤشر العادي (المكتوب)، مثل "char*"، إلا أنه عندما يخرج المؤشر نفسه عن النطاق، يتم حذف ما يشير إليه أيضًا.يمكنك استخدامه كما تفعل مع المؤشر العادي، باستخدام "->"، ولكن ليس إذا كنت بحاجة إلى مؤشر فعلي للبيانات.لذلك، يمكنك استخدام "&*ptr".

وهو مفيد ل:

• الكائنات التي يجب تخصيصها بكائنات جديدة، ولكنك ترغب في أن يكون لها نفس عمر أي شيء موجود في تلك المكدس.إذا تم تعيين الكائن لمؤشر ذكي، فسيتم حذفه عندما يخرج البرنامج من تلك الوظيفة/الكتلة.

• بيانات أعضاء الفئات، بحيث يتم حذف جميع البيانات المملوكة أيضًا عند حذف الكائن، دون أي رمز خاص في أداة التدمير (ستحتاج إلى التأكد من أن أداة التدمير افتراضية، وهو أمر جيد دائمًا تقريبًا) .

يمكنك لا تريد استخدام مؤشر ذكي عندما:

• ...لا ينبغي أن يمتلك المؤشر البيانات فعليًا ...على سبيل المثال، عندما تستخدم البيانات فقط، ولكنك تريدها أن تستمر في الوظيفة التي تشير إليها فيها.
• ...لن يتم تدمير المؤشر الذكي في مرحلة ما.أنت لا تريد أن تبقى في الذاكرة التي لا يتم تدميرها أبدًا (كما هو الحال في كائن تم تخصيصه ديناميكيًا ولكن لن يتم حذفه بشكل صريح).
• ...قد يشير مؤشران ذكيان إلى نفس البيانات.(ومع ذلك، هناك مؤشرات أكثر ذكاءً يمكنها التعامل مع ذلك...هذا يسمى العد المرجعي.)

أنظر أيضا:

• جمع القمامة.
• هذا السؤال تجاوز سعة المكدس فيما يتعلق بملكية البيانات

Answer 6

تتعامل معظم أنواع المؤشرات الذكية مع التخلص من كائن المؤشر نيابةً عنك.إنه مفيد جدًا لأنه لن يتعين عليك التفكير في التخلص من الأشياء يدويًا بعد الآن.

المؤشرات الذكية الأكثر استخدامًا هي std::tr1::shared_ptr (أو boost::shared_ptr)، وبشكل أقل شيوعًا، std::auto_ptr.أوصي بالاستخدام المنتظم ل shared_ptr.

shared_ptr متعدد الاستخدامات للغاية ويتعامل مع مجموعة كبيرة ومتنوعة من سيناريوهات التخلص، بما في ذلك الحالات التي يلزم فيها "تمرير الكائنات عبر حدود DLL" (حالة الكابوس الشائعة إذا كانت مختلفة libcيتم استخدام s بين التعليمات البرمجية الخاصة بك وملفات DLL).

Answer 7

المؤشر الذكي هو كائن يعمل كمؤشر، ولكنه يوفر أيضًا التحكم في البناء والتدمير والنسخ والنقل وإلغاء الإشارة.

يمكن للمرء تنفيذ المؤشر الذكي الخاص به، لكن العديد من المكتبات توفر أيضًا تطبيقات المؤشر الذكي لكل منها مزايا وعيوب مختلفة.

على سبيل المثال، يعزز يوفر تطبيقات المؤشر الذكي التالية:

• shared_ptr<T> هو مؤشر ل T باستخدام عدد مرجعي لتحديد متى لم تعد هناك حاجة للكائن.
• scoped_ptr<T> يتم حذف المؤشر تلقائيًا عندما يخرج عن النطاق.لا توجد مهمة ممكنة.
• intrusive_ptr<T> هو مؤشر عد مرجعي آخر.ويقدم أداء أفضل من shared_ptr, ، ولكن يتطلب النوع T لتوفير آلية العد المرجعية الخاصة بها.
• weak_ptr<T> هو مؤشر ضعيف، ويعمل جنبا إلى جنب مع shared_ptr لتجنب المراجع الدائرية.
• shared_array<T> يشبه shared_ptr, ، ولكن لمصفوفات T.
• scoped_array<T> يشبه scoped_ptr, ، ولكن لمصفوفات T.

هذه مجرد أوصاف خطية واحدة لكل منها ويمكن استخدامها حسب الحاجة، لمزيد من التفاصيل والأمثلة يمكن للمرء أن ينظر إلى وثائق Boost.

بالإضافة إلى ذلك، توفر مكتبة C++ القياسية ثلاثة مؤشرات ذكية؛ std::unique_ptr للملكية الفريدة std::shared_ptr للملكية المشتركة و std::weak_ptr. std::auto_ptr كان موجودًا في C++ 03 ولكنه مهمل الآن.

Answer 8

وهذا هو الرابط لإجابات مماثلة: http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

المؤشر الذكي هو كائن يعمل ويبدو وكأنه مؤشر عادي ولكنه يوفر المزيد من الوظائف.في لغة C++، يتم تطبيق المؤشرات الذكية كفئات قالبية تقوم بتغليف المؤشر وتجاوز عوامل تشغيل المؤشر القياسية.لديهم عدد من المزايا على المؤشرات العادية.يتم ضمان تهيئتها إما كمؤشرات فارغة أو مؤشرات لكائن كومة.يتم التحقق من عدم الاتجاه من خلال مؤشر فارغ.لا يوجد حذف ضروري على الإطلاق.يتم تحرير الكائنات تلقائيًا عند اختفاء المؤشر الأخير لها.إحدى المشكلات المهمة في هذه المؤشرات الذكية هي أنها، على عكس المؤشرات العادية، لا تحترم الميراث.المؤشرات الذكية غير جذابة للتعليمات البرمجية متعددة الأشكال.فيما يلي مثال لتنفيذ المؤشرات الذكية.

مثال:

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

تطبق هذه الفئة مؤشرًا ذكيًا على كائن من النوع X.يقع الكائن نفسه على الكومة.هنا كيفية استخدامه:

smart_pointer <employee> p= employee("Harris",1333);

مثل العوامل الأخرى ذات التحميل الزائد، سوف يتصرف p كمؤشر عادي،

cout<<*p;
p->raise_salary(0.5);

Answer 9

http://en.wikipedia.org/wiki/Smart_pointer

في علوم الكمبيوتر ، يعد المؤشر الذكي نوعًا بيانات مجردة يحاكي مؤشرًا مع توفير ميزات إضافية ، مثل جمع القمامة التلقائي أو فحص الحدود.تهدف هذه الميزات الإضافية إلى تقليل الأخطاء الناجمة عن سوء استخدام المؤشرات مع الحفاظ على الكفاءة.عادةً ما تتبع المؤشرات الذكية الكائنات التي تشير إليها لغرض إدارة الذاكرة.سوء استخدام المؤشرات هو مصدر رئيسي للحشرات:إن التخصيص المستمر ، وتوصيل التخصيص والإحالة التي يجب تنفيذها بواسطة برنامج مكتوب باستخدام مؤشرات يجعل من المحتمل جدًا حدوث بعض تسرب الذاكرة.تحاول المؤشرات الذكية منع تسرب الذاكرة من خلال جعل توصيل الموارد تلقائيًا:عندما يتم تدمير المؤشر إلى كائن (أو الأخير في سلسلة من المؤشرات) ، على سبيل المثال لأنه يخرج من النطاق ، يتم تدمير الكائن المدبب أيضًا.

Answer 10

دعنا يكونون صفًا في هذا المؤشرات التعليمية في C ++ يمكن تقسيمه إلى 3 أنواع:

1) مؤشرات خام :

T a;  
T * _ptr = &a; 

لديهم عنوان ذاكرة إلى موقع في الذاكرة.استخدمه بحذر، حيث تصبح البرامج معقدة ويصعب تتبعها.

مؤشرات ذات بيانات ثابتة أو عنوان {قراءة معكوسة}

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

مؤشر إلى نوع البيانات T وهو ثابت.وهذا يعني أنه لا يمكنك تغيير نوع البيانات باستخدام المؤشر.أي *ptr1 = 19 ;لن يعمل.ولكن يمكنك تحريك المؤشر.أي ptr1++ , ptr1-- ;الخ سوف تعملقراءة إلى الوراء:مؤشر لكتابة T وهو ثابت

  T * const ptr2 ;

مؤشر ثابت لنوع البيانات T .بمعنى أنه لا يمكنك تحريك المؤشر ولكن يمكنك تغيير القيمة التي يشير إليها المؤشر.أي *ptr2 = 19 سوف تعمل ولكن ptr2++ ; ptr2-- الخ لن ينجحقراءة إلى الوراء:مؤشر ثابت إلى نوع T

const T * const ptr3 ; 

مؤشر const إلى نوع بيانات const T .وهذا يعني أنه لا يمكنك تحريك المؤشر ولا يمكنك تغيير مؤشر نوع البيانات ليكون المؤشر.أي . ptr3-- ; ptr3++ ; *ptr3 = 19; لن يعمل

3) المؤشرات الذكية : { #include <memory> }

المؤشر المشترك:

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

تم تنفيذه باستخدام العد المرجعي لتتبع عدد "الأشياء" التي تشير إلى الكائن الذي يشير إليه المؤشر.عندما يصل هذا العدد إلى 0، يتم حذف الكائن تلقائيًا، أي يتم حذف الكائن المعترض عندما يخرج كل Share_ptr الذي يشير إلى الكائن عن النطاق.يؤدي هذا إلى التخلص من مشكلة الاضطرار إلى حذف الكائنات التي قمت بتخصيصها باستخدام العناصر الجديدة.

المؤشر الضعيف: يساعد في التعامل مع المرجع الدوري الذي ينشأ عند استخدام مؤشر مشترك إذا كان لديك كائنين يشار إليهما من قبل اثنين من المؤشرات المشتركة ، وهناك مؤشر مشترك داخلي يشير إلى مؤشر مشترك لبعضهما البعض ، ثم سيكون هناك مرجع دوري ولن يتم حذف الكائن عندما المؤشرات المشتركة تخرج من النطاق.لحل هذه المشكلة، قم بتغيير العضو الداخلي من Shared_ptr إلى Weak_ptr.ملحوظة :للوصول إلى العنصر المشار إليه بمؤشر ضعيف، استخدم lock()، مما يؤدي إلى إرجاع ضعيف_ptr.

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

يرى : متى يكون std::weak_ptr مفيدًا؟

المؤشر الفريد: مؤشر ذكي خفيف الوزن بملكية حصرية.يُستخدم عندما يشير المؤشر إلى كائنات فريدة دون مشاركة الكائنات بين المؤشرات.

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr 

لتغيير الكائن المشار إليه بواسطة ptr الفريد، استخدم دلالات النقل

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null 

مراجع :يمكن اعتبارها بشكل أساسي بمثابة مؤشرات const، أي مؤشر يكون const ولا يمكن نقله باستخدام بناء جملة أفضل.

يرى : ما هي الاختلافات بين متغير المؤشر والمتغير المرجعي في C++؟

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified 

مرجع :https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ شكرًا لأندريه على الإشارة إلى هذا السؤال.

Answer 11

المؤشر الذكي عبارة عن فئة، عبارة عن غلاف للمؤشر العادي.على عكس المؤشرات العادية، تعتمد دائرة حياة النقطة الذكية على عدد مرجعي (عدد المرات التي يتم فيها تعيين كائن المؤشر الذكي).لذلك كلما تم تعيين مؤشر ذكي لمؤشر آخر، يتم حساب المرجع الداخلي زائد زائد.وكلما خرج الكائن عن النطاق، يكون عدد المرجع ناقصًا.

المؤشر التلقائي، على الرغم من تشابهه، يختلف تمامًا عن المؤشر الذكي.إنها فئة مناسبة تقوم بإلغاء تخصيص المورد عندما يخرج كائن المؤشر التلقائي عن نطاق المتغير.إلى حد ما، فإنه يجعل المؤشر (للذاكرة المخصصة ديناميكيًا) يعمل بشكل مشابه لمتغير المكدس (المخصص بشكل ثابت في وقت الترجمة).

Answer 12

المؤشرات الذكية هي تلك التي لا داعي للقلق بشأن إلغاء تخصيص الذاكرة ومشاركة الموارد ونقلها.

يمكنك استخدام هذا المؤشر جيدًا بنفس الطريقة التي يعمل بها أي تخصيص في Java.في Java Garbage Collector يقوم بالمهمة، بينما في Smart Pointers، يتم تنفيذ الخدعة بواسطة Destructors.

Answer 13

الإجابات الموجودة جيدة ولكنها لا تغطي ما يجب فعله عندما لا يكون المؤشر الذكي هو الإجابة (الكاملة) للمشكلة التي تحاول حلها.

من بين أشياء أخرى (تم شرحها جيدًا في الإجابات الأخرى) يعد استخدام المؤشر الذكي حلاً ممكنًا لـ كيف نستخدم فئة مجردة كنوع إرجاع دالة؟ والتي تم وضع علامة عليها كنسخة مكررة من هذا السؤال.ومع ذلك، فإن السؤال الأول الذي يجب طرحه إذا كان هناك إغراء لتحديد فئة أساسية مجردة (أو في الواقع أي فئة) كنوع إرجاع في C++ هو "ماذا تقصد حقًا؟".هناك مناقشة جيدة (مع مزيد من المراجع) للبرمجة الاصطلاحية الموجهة للكائنات في C++ (وكيف يختلف هذا عن اللغات الأخرى) في وثائق تعزيز مكتبة حاوية المؤشر.باختصار، في C++ عليك أن تفكر في الملكية.ما هي المؤشرات الذكية التي تساعدك، ولكنها ليست الحل الوحيد، أو دائمًا الحل الكامل (لا تمنحك نسخة متعددة الأشكال) وليست دائمًا الحل الذي تريد كشفه في واجهتك (وتبدو إرجاع الوظيفة فظيعة تشبه إلى حد كبير الواجهة).قد يكون كافيا لإرجاع مرجع، على سبيل المثال.ولكن في جميع هذه الحالات (المؤشر الذكي أو حاوية المؤشر أو مجرد إرجاع مرجع) قمت بتغيير الإرجاع من قيمة إلى شكل من أشكال مرجع.إذا كنت بحاجة حقًا إلى نسخة، فقد تحتاج إلى إضافة المزيد من "المصطلحات النمطية" أو تجاوز OOP الاصطلاحي (أو غير ذلك) في C++ إلى تعدد الأشكال الأكثر عمومية باستخدام مكتبات مثل أدوبي بولي أو Boost.TypeErasure.