كائن نهج في C++لغة البرمجة

في هذا القسم سوف نقوم بتصميم وتنفيذ باستخراج مجموعة, باستخدام C++الفئات. النسخة الأولية فقط دعم مجموعة من العناصر من نوع int. ثم مع مساعدة من القوالب سوف تتوفر لدينا مجموعة دعم أي نوع من البيانات.

الخطوة الأولى, لتحديد, ماذا عمليات الدعم لدينا مجموعة. بالطبع, وقد يكون من المغري أن تنفذ كل ما يمكن تصوره من العملية, ولكن من المستحيل أن تفعل كل شيء في مرة واحدة. حتى تبدأ تعريف ما, ما هي المهارات التي يجب أن لدينا مجموعة:

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

يبدو, المدرجة لدينا ما يكفي من إمكانات القوة مستقبلنا مجموعة, لإشعال الرغبة في الشروع فورا في تنفيذ. كيف سيبدو في C++? في معظم الحالات العامة الفصل الإعلان يبدو مثل هذا:

class classname {
public:
   // набор открытых операций
private:
   // закрытые функции, обеспечивающие реализацию
};

class classname {

public:

// набор открытых операций

private:

// закрытые функции, обеспечивающие реализацию

};

الصف, العامة والخاصة هي الكلمات الرئيسية في C++, و classname هو اسم, مبرمج أعطى صفه. نطلق على تصميم الفئة IntArray: في المرحلة الأولى هذه المجموعة فقط تحتوي على أعداد صحيحة. عندما نعلمه كيفية التعامل مع البيانات من أي نوع, يمكنك إعادة تسمية مجموعة.
تحديد فئة, ونحن إنشاء نوع بيانات جديد. اسم الفئة يمكن الرجوع إليها فقط نفس, تماما مثل أي المدمج في نوع محدد. يمكنك إنشاء كائنات من هذا النوع الجديد مشابه, كيف يمكننا إنشاء كائنات من المدمج في أنواع:

// статический объект типа IntArray
IntArray myArray;
// указатель на динамический объект типа IntArray
IntArray *pArray = new IntArray;

// статический объект типа IntArray

IntArray myArray;

// указатель на динамический объект типа IntArray

IntArray *pArray = new IntArray;

تعريف الفئة يتكون من جزئين: العنوان (اسم, تسبق الكلمة الفصل) و الجسم, أيضا محاطة بأقواس. رأس بدون جثة يمكن أن تكون بمثابة فئة الإعلان.

// объявление класса IntArray
// без определения его
class IntArray;

// объявление класса IntArray

// без определения его

class IntArray;

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

class IntArray {
public:
   // операции сравнения: #2b
   bool operator== (const IntArray&) const;
   bool operator!= (const IntArray&) const;
   // операция присваивания: #2a
   IntArray& operator= (const IntArray&);
   int size() const; // #1
   void sort(); // #4
   int min() const; // #3a
   int max() const; // #3b
   // функция find возвращает индекс первого
   // найденного элемента массива
   // или -1, если элементов не найдено
   int find (int value) const; // #3c
private:
   // дальше идут закрытые члены,
   // обеспечивающие реализацию класса
   ...
}

class IntArray {

public:

// операции сравнения: #2b

bool operator== (const IntArray&) const;

bool operator!= (const IntArray&) const;

// операция присваивания: #2a

IntArray& operator= (const IntArray&);

int size() const; // #1

void sort(); // #4

int min() const; // #3a

int max() const; // #3b

// функция find возвращает индекс первого

// найденного элемента массива

// или -1, если элементов не найдено

int find (int value) const; // #3c

private:

// дальше идут закрытые члены,

// обеспечивающие реализацию класса

...

}

غرف, المذكورة في التعليقات في طريقة الإعلانات, الرجوع إلى مواصفات الفئة, كنا في بداية هذا القسم. الآن نحن لن اشرح معنى الكلمات الرئيسية const, غير أنه من المهم جدا لفهم, ما نريد أن نبرهن من خلال هذا المثال. نفترض, ما هذه الكلمة المطلوبة الصحيح تجميع البرنامج.
مسمى وظيفة الأعضاء (على سبيل المثال, مين()) يمكن أن يكون سببها واحد من اثنين من العمليات الوصول عضو من فئة. أول عملية الوصول إلى, يدل عليه نقطة (.), تطبيق كائنات الفئة, من جهة ثانية (->) – مؤشرات إلى الكائنات. لذا, لإيجاد الحد الأدنى من العناصر في الجسم, وقد نوع IntArray, يجب أن تكتب:

// инициализация переменной min_val
// минимальным элементом myArray
int min_val = myArray.min();

// инициализация переменной min_val

// минимальным элементом myArray

int min_val = myArray.min();

لإيجاد الحد الأدنى من العناصر التي تم إنشاؤها بشكل حيوي نوع الكائن IntArray, يجب أن تكتب:

int min_val = pArray->min();

1	int min_val = pArray->min();

(نعم, نحن لم أقل شيئا بعد عن, كيفية تهيئة هدفنا هو تحديد حجمها و ملء العناصر. هذه هي الأعضاء الخاصة الدالة, يسمى من قبل منشئ. سنتحدث عن ذلك أدناه.)
العمليات يتم تطبيقها على فئة الكائنات في بالضبط نفس, كما أن المدمج في أنواع البيانات. لنفترض أن لدينا اثنين من كائن من نوع IntArray:

IntArray myАrray0, myArray1;

1	IntArray myАrray0, myArray1;

إحالة البيانات والمقارنات مع هذه الكائنات تبدو تماما بالطريقة العادية:

// инструкция присваивания -
// вызывает функцию-член myArray0.operator=(myArray1)
myArray0 = myArray1;
// инструкция сравнения -
// вызывает функцию-член myArray0.operator==(myArray1)
if (myArray0 == myArray1)
   cout « «  "Ура! Оператор присваивания сработал!\n";

// инструкция присваивания -

// вызывает функцию-член myArray0.operator=(myArray1)

myArray0 = myArray1;

// инструкция сравнения -

// вызывает функцию-член myArray0.operator==(myArray1)

if (myArray0 == myArray1)

cout « « "Ура! Оператор присваивания сработал!\n";

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

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

ماذا الداخلية البيانات اللازمة لتنفيذ فئة IntArray? تحتاج في مكان ما للحفاظ على حجم الصفيف و عناصره. سوف تخزينها في مجموعة المدمج في نوع, الذاكرة التي هي المخصصة بشكل حيوي. لذا نحن بحاجة مؤشر إلى هذه المجموعة. هنا نظرة على تعاريف هذه البيانات الأعضاء:

class IntArray {
public:
   // ...
   int size() const { return _size; }
private:
   // внутренние данные-члены
   int _size;
   int *ia;
};

class IntArray {

public:

// ...

int size() const { return _size; }

private:

// внутренние данные-члены

int _size;

int *ia;

};

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

IntArray array;
int array_size = array.size();
array_size = array._size;

IntArray array;

int array_size = array.size();

array_size = array._size;

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

for (int index=0; index<array.size(); ++index)
// ...

1 2	for (int index=0; index<array.size(); ++index) // ...

وظيفة حجم() لا يدعى _size وقت أثناء تنفيذ. بدلا من استدعاء برنامج التحويل البرمجي سيكون بديلا النص, ونتيجة تجميع التعليمات البرمجية السابقة سوف يكون بالضبط نفس, كما لو كتبنا:

for (int index=0; index<array._size; ++index)
// ...

1 2	for (int index=0; index<array._size; ++index) // ...

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

// список перегруженных функций min()
// каждая функция отличается от других списком параметров
#include <string>
int min (const int *pia,int size);
int min (int, int);
int min (const char *str);
char min (string);
string min (string,string);

// список перегруженных функций min()

// каждая функция отличается от других списком параметров

#include <string>

int min (const int *pia,int size);

int min (int, int);

int min (const char *str);

char min (string);

string min (string,string);

سلوك طاقتها المهام في وقت التشغيل لا يختلف عن سلوك عادي. المترجم يحدد الوظيفة المطلوبة ووضعها في كائن الرمز هو دعوتها.
لذا, العودة إلى صفنا IntArray. دعونا نحدد ثلاثة منشئ:

class IntArray {
public:
   explicit IntArray (int sz = DefaultArraySize);
   IntArray (int *array, int array_size);
   IntArray (const IntArray &rhs);
   // ...
private:
   static const int DefaultArraySize = 12;
}

class IntArray {

public:

explicit IntArray (int sz = DefaultArraySize);

IntArray (int *array, int array_size);

IntArray (const IntArray &rhs);

// ...

private:

static const int DefaultArraySize = 12;

}

أول هذه المنشئات

IntArray (int sz = DefaultArraySize);

1	IntArray (int sz = DefaultArraySize);

دعا منشئ افتراضي, لأنه يمكن أن يسمى بدون أية معلمات. (بينما نحن سوف لا يفسر صريحة الكلمة.) إذا قمت بإنشاء كائن بتعيين المعلمة من نوع int, على سبيل المثال

IntArray array1(1024);

1	IntArray array1(1024);

قيمة 1024 سيتم تمريرها إلى منشئ. إذا كان حجم غير محدد, أعتقد:
IntArray array2;
ثم قيمة مفقودة المعلمة المنشئ يأخذ قيمة DefaultArraySize.
قد تبدو مثل تعريف لدينا منشئ افتراضي:

IntArray::IntArray (int sz)
{
   // инициализация членов данных
   _size = sz;
   ia = new int[_size];
   // инициализация элементов массива
   for (int ix=0; ix<_size; ++ix)
     ia[ix] = 0;
}

IntArray::IntArray (int sz)

{

// инициализация членов данных

_size = sz;

ia = new int[_size];

// инициализация элементов массива

for (int ix=0; ix<_size; ++ix)

ia[ix] = 0;

}

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

IntArray::IntArray(int sz);

1	IntArray::IntArray(int sz);

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

int ia[10] = {0,1,2,3,4,5,6,7,8,9};
IntArray iA3(ia,10);

1 2	int ia[10] = {0,1,2,3,4,5,6,7,8,9}; IntArray iA3(ia,10);

تنفيذ الثانية منشئ هي مشابهة جدا تنفيذ منشئ افتراضي. (كما في الحالة الأولى ، , نحن خفضنا معالجة الخطأ الظروف.)

IntArray::IntArray (const IntArray &rhs )
{
   // инициализация членов данных
   _size = rhs._size;
   ia = new int[_size];
   // инициализация элементов массива
  for (int ix=0; ix<_size; ++ix)
    ia[ix] = rhs.ia[ix];
// инициализация элементов массива
 for (int ix=0; ix<_size; ++ix)
 ia[ix] = array[ix];
 }

IntArray::IntArray (const IntArray &rhs )

{

// инициализация членов данных

_size = rhs._size;

ia = new int[_size];

// инициализация элементов массива

for (int ix=0; ix<_size; ++ix)

ia[ix] = rhs.ia[ix];

// инициализация элементов массива

for (int ix=0; ix<_size; ++ix)

ia[ix] = array[ix];

}

يتم استدعاء منشئ الثالثة نسخة منشئ. ذلك تهيئة كائن واحد نوع IntArray قيمة كائن آخر IntArray. هذه منشئ يسمى تلقائيا عند الإرشادات التالية:

IntArray array;
// следующие два объявления совершенно эквивалентны:
IntArray ia1 = array;
IntArray ia2 (array);

IntArray array;

// следующие два объявления совершенно эквивалентны:

IntArray ia1 = array;

IntArray ia2 (array);

هنا هو تنفيذ نسخة منشئ IntArray, مرة أخرى دون معالجة الخطأ:

في هذا المثال نرى آخر مركب نوع البيانات هو مرجع كائن, التي يرمز لها بالرمز &. الرابط يمكن اعتبار هذا النوع من المؤشر: كما أنه يتيح لك الوصول بشكل غير مباشر الكائن. بيد أن جملة من استخدامها يختلف: الوصول إلى كائن عضو, التي يجب الإشارة, استخدام نقطة, و لا السهم; ولذلك, نكتب rhs._size, و لا rhs>_size.
ملاحظة, تنفيذ كل ثلاثة المنشئات هي مشابهة جدا. إذا نفس التعليمات البرمجية المتكررة في أماكن مختلفة, فإنه من المستحسن لجعل وظيفة منفصلة. هذا يجعل من الاسهل للحصول على مزيد تعديل التعليمات البرمجية, و القراءة البرنامج. هنا كيف يمكنك ترقية المصممين, إذا قمت بتحديد المتكررة التعليمات البرمجية في وظيفة منفصلة init():

class IntArray {
public:
   explicit IntArray (int sz = DefaultArraySize);
   IntArray (int *array, int array_size);
   IntArray (const IntArray &rhs);
   // ...
private:
   void init (int sz,int *array);
   // ...
};
// функция, используемая всеми конструкторами
void IntArray::init (int sz,int *array)
{
  _size = sz;
  ia = new int[_size];
  for (int ix=0; ix<_size; ++ix)
    if ( !array )
      ia[ix] = 0;
    else
      ix[ix] = array[ix];
}
// модифицированные конструкторы
IntArray::IntArray (int sz) { init(sz,0); }
IntArray::IntArray (int *array, int array_size)
      { init (array_size,array); }
IntArray::IntArray (const IntArray &rhs)
      { init (rhs._size,rhs.ia); }

class IntArray {

public:

explicit IntArray (int sz = DefaultArraySize);

IntArray (int *array, int array_size);

IntArray (const IntArray &rhs);

// ...

private:

void init (int sz,int *array);

// ...

};

// функция, используемая всеми конструкторами

void IntArray::init (int sz,int *array)

{

_size = sz;

ia = new int[_size];

for (int ix=0; ix<_size; ++ix)

if ( !array )

ia[ix] = 0;

else

ix[ix] = array[ix];

}

// модифицированные конструкторы

IntArray::IntArray (int sz) { init(sz,0); }

IntArray::IntArray (int *array, int array_size)

{ init (array_size,array); }

IntArray::IntArray (const IntArray &rhs)

{ init (rhs._size,rhs.ia); }

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

هنا هو destructor IntArray:

class IntArray {
public:
   // конструкторы
   explicit IntArray (int sz = DefaultArraySize);
   IntArray (int *array, int array_size);
   IntArray (const IntArray &rhs);
  // деструктор
  ~IntArray() { delete[] ia; }
  // ...
private:
  // ...
};

class IntArray {

public:

// конструкторы

explicit IntArray (int sz = DefaultArraySize);

IntArray (int *array, int array_size);

IntArray (const IntArray &rhs);

// деструктор

~IntArray() { delete[] ia; }

// ...

private:

// ...

};

الآن نحن بحاجة إلى تعريف عمليات الوصول إلى مجموعة عناصر IntArray. نريد, نداء إلى عناصر IntArray تبدو بالضبط نفس, كما أن عناصر المصفوفة المدمج في نوع, باستخدام مشغل الفهرس:

IntArray array;
int last_pos = array.size()-1;
int temp = array[0];
array[0] = array[last_pos];
array[last_pos] = temp;

IntArray array;

int last_pos = array.size()-1;

int temp = array[0];

array[0] = array[last_pos];

array[last_pos] = temp;

لتنفيذ الوصول نستخدم إمكانية الزائد العمليات. هنا هي وظيفة, بتنفيذ عملية اتخاذ الفهرس:

#include <cassert>
int& IntArray::operator[] (int index)
{
  assert (index >= 0 && index < _size);
  return ia[index];
}

#include <cassert>

int& IntArray::operator[] (int index)

{

assert (index >= 0 && index < _size);

return ia[index];

}

عادة مصممة لفئة الزائد المهمة العملية, عملية المقارنة من أجل المساواة, ممكن, مقارنة العمليات على قيمة عمليات I/o. كما هو الحال مع طاقتها وظائف, مثقلة المشغلين, أنواع مختلفة من المعاملات, قد يكون هناك عدة. على سبيل المثال, يمكنك إنشاء عدة عمليات الإحالة إلى كائن قيمة كائن آخر من نفس أو من نوع مختلف. بالطبع, هذه الكائنات يجب أن تكون أكثر أو أقل "مماثلة".
تعريف الفئة, المختلفة ذات الصلة الثوابت ، , ربما, أي متغيرات أخرى و وحدات الماكرو وفقا قبول الاتفاقات توضع في رأس الملف, نفس الاسم مثل اسم الفئة. على الصف IntArray نحن بحاجة إلى إنشاء ملف رأس IntArray.ح. أي برنامج, في الفئة التي سيتم استخدامها IntArray, وينبغي أن يشمل هذا الملف رأس ، preprocessor التوجيه #وتشمل.
من قبل نفس الاتفاق الأعضاء في وظائف الفئة, تعريف خارج الوصف, وضعها في ملف مع اسم الفئة و تمديد, دلالة النص الأصلي C++ . ونحن سوف تستخدم امتداد .مع (يذكر, ماذا أنظمة مختلفة يمكنك أن يجتمع مع ملحقات مختلفة التعليمات البرمجية المصدر C++ البرامج) و دعونا نسمي ملفنا IntArray.ج.

الوظائف ذات الصلة: