المؤشرات الذكية... نظرة أوسع

المؤشر التلقائي Auto Pointer:

كما ذكرت في المرة السابقة، هناك أنواع متعددة للمؤشرات الذكية، لكل منها وظيفة محددة نستعمله من أجلها، ولتكون بدايتنا مريحة، سنبدأ بأبسط أنواع المؤشرات الذكية، وهو المؤشر التلقائي auto_ptr. السؤال الأول الذي يتبادر إلى الذهن.... لماذا تلقائي؟ لأنه ببساطة، يقوم بشكل تلقائي، بتحرير الذاكرة عندما ينتهي عمله، وبالتالي لن تحتاج إلى القلق من مشاكل تسرب الذاكرة –في الحالات البسيطة- عند استعمال هذا المؤشر.

مثال بسيط على الأمر، لنفترض أن لدينا الدالة التالية:

void testing()
{
                int* p= new int;
               
                //Some code


                delete p;
}

يبدو هذا الكود آمناً، لكن ماذا يجري إذا خرجت الدالة testing قبل وصولها إلى السطر الأخير؟ ربما تم رمي استثناء أو صادفت جملة return على الطريق... وبالتالي فإن الذاكرة التي حجزها p لن تحرر مما سيؤدي إلى تسرب في الذاكرة.

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

#include <memory>
using namespace std;


void testing()
{
       auto_ptr<int> p(new int);


       //Some code
}

إذاً، فإن الـauto_ptr هو عبارة عن template class نحدد له في الـtemplate parameter نوع البيانات التي نريد الإشارة إليها بالمؤشر. وهو ككائن عادي، يستدعى الـdestructor الخاص به بشكل تلقائي عند الخروج من الدالة بأي طريقة، حيث يقوم هذا الـdestructor بتحرير الذاكرة بالشكل المناسب.

إذاً، فلم يعد هناك خوف من ألا نصل إلى جملة delete، لأن الـdestructor الخاص بالـauto_ptr هو من يستدعيها ولا مفر من الوصول إليه عند انتهاء الدالة.

الجميل أيضاً في هذا المؤشر الذكي، أنه من الممكن استعمال معاملات المؤشرات العادية عليه كمعامل الـ* ومعامل <-، مثلاً:

#include <iostream>
#include <memory>
using namespace std;


void testing();


class SomeClass
{
public:
       void SomeMethod()
       {
              cout<< "Wow!! It's working!!\n";
       }
};


int main()
{
       testing();
       return 0;
}


void testing()
{
       auto_ptr<int> p1(new int);
       *p1= 5;
       cout<< *p1<< endl;


       auto_ptr<SomeClass> p2(new SomeClass);
       p2->SomeMethod();
}

هناك خصائص عديدة أخرى يتميز بها المؤشر التلقائي، سنشرحها من خلال صنع مؤشر تلقائي خاص بنا، ولنسمه، AT_auto_ptr.

template <class T>
class AT_auto_ptr
{
private:
       T* raw_ptr;
public:
AT_auto_ptr(): raw_ptr(0) {}


       AT_auto_ptr(T* ptr): raw_ptr(ptr) {}


       ~AT_auto_ptr()
       {
              delete raw_ptr;
       }
};

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

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

تجدر الإشارة هنا إلى أن المؤشر التلقائي يجب ألّا يشير إلّا إلى ذاكرة في الـheap، أي تم حجزها بشكل ديناميكي باستخدام new وما شابهها. لأنه في حال حاول الإشارة إلى ذاكرة في الـstack فإنه لن يكون قادراً على تحريرها عند استدعاء الـdestructor. إلا إن كانت هناك طريقة لمعرفة إن كانت الذاكرة المشار إليها تابعة للـstack أو الـheap، فعندها ليجاوبنا من عنده علم بذلك  :) 

سنقوم الآن بتزويد الكلاس بمعاملات المؤشرات الأساسية:

template <class T>
class AT_auto_ptr
{
private:
       T* raw_ptr;
public:
       AT_auto_ptr(): raw_ptr(0) {}


       AT_auto_ptr(T* ptr): raw_ptr(ptr) {}


       ~AT_auto_ptr()
       {
              delete raw_ptr;
       }


       T& operator * () const
       {
              return *raw_ptr;
       }


       T* operator -> () const
       {
              return raw_ptr;
       }
};

لاحظ أن الـreturn type الخاص بالمعامل * هو من النوع T& وليس T وذلك لتجنب القيام بعملية نسخ زائدة ليس منها فائدة.

سؤال جوهري يجب طرحه الآن، ماذا يحدث عندما نحاول نسخ مؤشر تلقائي إلى مؤشر تلقائي آخر؟

هذا بالطبع يعتمد على تصميمنا، لكن التصميم المتفق عليه يجعل المؤشر التلقائي يقوم عند نسخه بعملية transfer-of-ownership أو نقل الملكية، حيث يتخلى المؤشر الأصلي عن ملكيته لموقع الذاكرة، ويعطيه للمؤشر الجديد، بينما يسند قيمة مؤشره الداخلي إلى NULL.... يا له من محب للإيثار!!

هذه العملية تحمينا من أن يكون هناك أكثر من مؤشر واحد يشير لنفس الموقع في الذاكرة، كما أنها مفيدة عند إرجاع مؤشر من دالة معينة، حيث يمكننا أن نقوم بـ:

auto_ptr<int> testing()
{
	auto_ptr<int> temp(new int);
	*temp= 5;

	return temp;
}

حيث قامت عملية نقل الملكية بنقل موقع الذاكرة الذي تم حجزه داخل الدالة إلى المؤشر الذي سيلتقط القيمة المرجعة، وأصبح هو المسؤول عن تحريرها في الـdestructor الخاص به.

لكن يجب الانتباه أن عملية نقل الملكية لا تقوم بعمل Deep Copy، لأن المؤشر الذكي المنسوخ منه يفقد ملكيته تماماً لموقع الذاكرة.. وبالتالي، فإن هناك أماكن يجب ألا يستخدم فيها المؤشر التلقائي، سنتحدث عنها لاحقاً. لكن أولاً، كيف نقوم بعملية نقل الملكية؟

قبل أن نكتب كود النسخ، سنكتب أولاً دالة release، ما تقوم به هذه الدالة هو إسناد قيمة NULL إلى المؤشر الخام الموجود داخل المؤشر التلقائي، ثم تقوم بإعادة موقع الذاكرة الذي كان يشار إليه في هذا المؤشر من قبل، إذاً فهذه الدالة تقوم بـ"التخلي" عن موقع الذاكرة الخاص بها لتعطيه لمن يقوم بالتقاط القيمة المرجعة من الدالة، كالتالي:

    T* release()
       {
              T* temp= raw_ptr;
              raw_ptr= 0;
              return temp;
       }

الآن يمكنني أن أستعمل هذه الدالة لأقوم بعملية نقل الملكية عند استدعاء copy constructor أو معامل النسخ العادي، فيصبح الكود:

template <class T>
class AT_auto_ptr
{
private:
       T* raw_ptr;
public:
       AT_auto_ptr(): raw_ptr(0) {}


       AT_auto_ptr(T* ptr): raw_ptr(ptr) {}


       AT_auto_ptr(AT_auto_ptr<T>& other): raw_ptr(other.release()) {}


       ~AT_auto_ptr()
       {
              delete raw_ptr;
       }


       T& operator * () const
       {
              return *raw_ptr;
       }


       T* operator -> () const
       {
              return raw_ptr;
       }
      
       AT_auto_ptr& operator = (AT_auto_ptr<T>& other)
       {
              if (this != &other)
              {
                     delete raw_ptr;
                     raw_ptr= other.release();
              }
              return (*this);
       }


       T* release()
       {
              T* temp= raw_ptr;
              raw_ptr= 0;
              return temp;
       }
};

لاحظ أننا في المعامل = قمنا أولاً بتحرير الذاكرة التي يقوم المؤشر بحجزها قبل إسناد القيمة الجديدة إليه، وذلك لتجنب حدوث تسرب في الذاكرة.

دالة أخرى مفيدة، هي دالة reset، والتي تعطي للمؤشر مكاناً جديداً في الذاكرة، بعد أن تقوم بتحرير المكان القديم، فهي تستخدم كالتالي:

auto_ptr<int> p(new int);
      
       //Some code


       p.reset(new int);

ما تقوم به هذه الدالة، هو تحرير المكان القديم المحجوز في الذاكرة وإسناد المكان الجديد للمؤشر الداخلي، إذاً يمكن أن تكون كالتالي:

void reset (T* ptr)
       {
              if (ptr != raw_ptr)
              {
                     delete raw_ptr;
              }
             
              raw_ptr= ptr;
       }

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

من الجيد أيضاً أن يكون لدى مستخدم المؤشر التلقائي قدرة على الوصول المباشر إلى المؤشر الخام الموجود داخله، من أجل عمليات المقارنة وغيرها، لذلك نوفر دالة get التي ببساطة تعيد العنوان الذي يشير إليه المؤشر الداخلي:

T* get()       {              return raw_ptr;       }

بالطبع إذا استخدمت هذه الدالة لأغراض شريرة، كأن تقوم بعمل:

delete p.get();

فـ"ذنبك على جنبك"  :P 

يبدو درع المؤشر التلقائي درعاً ممتازاً، لكن كما قلنا من قبل، يجب أن يعرف المرء المهمة التي يريد القيام بها قبل ارتداء الدرع، لكي لا يصبح درعه سلاحاً ضده....

قد ترغب في استعمال المؤشر التلقائي كـmember داخل Class، وهذا أمر جميل حيث أن الذاكرة التي يقوم بحجزها المؤشر ستحرر عند انتهاء حياة الـobject، لكن يجب الانتباه من عمليات النسخ، لأن عملية نقل الملكية "ستقتل" المؤشر الذكي المنسوخ منه، لذلك، يجب أن نقوم بعمل نوع آخر من الـdeep copy...

class SomeClass
{
public:
       AT_auto_ptr<int> a;
       SomeClass(): a(new int) {}


       SomeClass& operator = (const SomeClass& other)
       {
              a.reset(new int);
              *a= *(other.a);
              return (*this);
       }
};




int main()
{
       SomeClass first;
       *(first.a)= 5;
       SomeClass second;
       second= first;


       cout<< first.a.get()<< endl;
       cout<< second.a.get()<< endl;


       cout<< *(first.a)<< endl;
       cout<< *(second.a)<< endl;


       return 0;
}

هذه المشكلة قد حلت إذاً باستخدام أسلوب مشابه للـDeep Copy، لكن مشكلة أساسية تحد من قدرات المؤشر التلقائي، ألا وهي أنه من غير الممكن استعماله داخل STL Containers، حيث أن هذه الحاويات تقوم بعمليات نسخ متعددة، دون الاهتمام بكون العناصر داخلها من نوع المؤشر التلقائي، وبالتالي فإن عملية نقل الملكية ستودي إلى جعل عدد كبير من المؤشرات فارغة تشير إلى NULL، ويمكن مشاهدة ذلك بوضوح في دالة sort الموجودة في STL والتي تعتمد على خوارزمية Quick Sort، هذه الخوارزمية تقوم بنسخ أحد العناصر ووضعه في محور في كل مرة وترتيب العناصر من حوله، وفي النهاية يتم حذف هذا المحور، مما سيؤدي إلى أن تصبح كل المؤشرات في الـContainer تشير إلى NULL.... بالمختصر المفيد، لا تستخدم المؤشر التلقائي في STL Containers...

بعد التفكير... جرب أن تستخدمه، لن تخسر شيئاً، لكنك لن تستطيع أصلاً أن تستخدمه لأنه تمت برمجته بطريقة تؤدي إلى صدور Compile Error عند استعماله مع دوال STL كـinsert وغيرها.... فلا مشكلة  :D 

كتلخيص....

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

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

سنتابع في الردود القادمة إن شاء الله مع أنواع أخرى من المؤشرات الذكية

atautoptr.h