در قسمت قبل با کلیات آرایه و مفهوم آن آشنا شدیم و البته که مبحث آرایه به یک یا دو پست ختم نمی شود. در این پست می خواهیم انواع دیگری از آرایه که استفاده از آن ها به صرفه تر است را مورد بررسی قرار دهیم. وقتی ارایه ای را به صورت معمولی مانند (int a[10];) تعریف می کنیم مانند متغیرهای دیگر، زبان برنامه نویسی برای آن مقدار لازم از حافظه را تخصیص می دهد. در برنامه های بزرگ اگر بخواهیم تمام متغیر ها و آرایه های خود را به صورت استاتیک تعریف کنیم و مقداری از حافظه را به صورت ثابت به آن اختصاص دهیم ممکن است با کمبود حافظه مواجه شویم. در حالی که شاید حجم بزرگی از حافظه را متغیر هایی که با آنها کاری نداریم اشغال کرده اند. پس بهتر است که متغیر های خود را به صورت دینامیک یا پویا تعریف کنیم تا بتوانیم حافظه ی تخصیص داده شده به آنها را در هنگامی که به انها نیاز نداریم، آزاد کنیم.
آرایه های پویا :

با استفاده از کلمه ی کلیدی یا عملگر "new" در زبان C++ می توانیم یک نمونه جدید از یک نوع حاضر را ایجاد کنیم. حافظه ی لازم برای متغیری که با این روش تعریف شده باشد در زمان اجرا تخصیص داده خواهد شد برخلاف تعریف ثابت که در آن حافظه ی یک متغیر در زمان کامپایل اختصاص داده می شود و ممکن است هیچ وقت هم از آن استفاده نشود. کد زیر یک آرایه ی به نام a با 10 خانه از نوع اعشاری تعریف میکند.


float* a = new float [10];

کار کردن با این آرایه مانند آرایه های معمولی است ولی باید در نظر داشته باشید که هنگامی که کارتان با آرایه تمام شد می توانید حافظه اختصاص داده شده به آرایه ی a را با استفاده از عملگر "delete" آزاد کنید. (که بهتر است حتما این کار را بکنید!)


delete[] a;

دقت کنید که برای علامت براکت ها قبل از نام آرایه اورده شده اند و این به زبان برنامه نویسی می گوید که a یک آرایه است. یکی دیگر از مزایای این روش این است که می توانید اندازه ی آرایه را در هنگام نیاز تغییر دهید. برای مثال کد زیر تعداد خانه های آرایه را به 20 افزایش می دهد.


a = new float [20];

ولی باید دقت کنید که با این کار تمام محتویات آرایه از دست خواهد رفت، پس باید قبل از این کار آنها را در جای دیگری ذخیره کرده باشید. معمولا در برنامه ها، نمی توان از ابتدا تعیین کرد که اندازه ی یک ارایه چقدر باشد. ممکن است که یک آرایه را خیلی کوچک تعریف کنیم و سپس فضای کافی برای ذخیره اطلاعات نداشته باشیم یا یک آرایه را خیلی بزرگ تعریف کنیم و فضای حافظه را بی جهت اشغال کنیم. با استفاده از آرایه های پویا می توان اندازه آرایه را در به اندازه ی نیاز تعیین کرد. یعنی به جای استفاده از یک عدد ثابت برای اندازه ی آرایه از یک متغیر در هنگام اعلان آن استفاده کرد.

خب این یکی از روش هایی بود که برای ایجاد آرایه ی پویا میتوان استفاده کرد. روش های دیگر را در پست های دیگر بررسی می کنیم ولی در ادامه نکاتی در مورد اشاره گر ها را یاداوری می کنیم.

اشاره گر ثابت و اشاره گر به یک ثابت :

اشاره گر به یک ثابت، اشاره گری است که به یک متغیر ثابت اشاره دارد. در خط زیر مثالی از آن را می بینید.

const int a = 100;

 const int* p = &a;

در خط اول یک متغیر ثابت به نام a تعریف کرده ایم و مقدار 100 را به به آن داده اسم. سپس در خط دوم یک اشاره گر به نام p را به آن نسبت داده ایم. در این صورت عدد 100 در صورت مقدار یابی p نمایش داده می شود ولی نمیتوان آن را تغییر داد یعنی خط زیر اشتباه است. چون p اشاره گر به ثابت است.

++(*p);


اشاره گر ثابت :

اشاره گر ثابت اشاره گری است که در تعریف آن از کلمه کلیدی const استفاده می شود و نمیتوان آن را تغییر داد. در زیر نمونه ای از یک اشاره گر ثابت را می بینید.


int a = 120;

int* const p = &a;

در خط اول یک متغیر به نام a تعریف کرده و مقدار 120 را به آن داده ایم. در خط بعد اشاره گر ثابتی را تعریف کرده ایم و آدرس a را در آن ذخیره کرده ایم. اگر بخواهیم مقدار این اشاره گر را تغییر دهیم (مثلا: ++p ) کامپایلر از ما خطا می گیرد. دقت کنید که برای اینکه کامپایلر متوجه شود یک اشاره گر به یک ثابت اشاره می کند کلمه ی const قبل از نوع آن امده است ولی برای مشخص کردن یک اشاره گر ثابت کلمه const بعد از نوع آمده است. اگر بخواهیم یک اشاره گر ثابت که به یک متغیر ثابت اشاره دارد را تعریف کنیم باید دو بار از کلمه ی const به صورت زیر استفاده کنیم.


const int a = 10;

const int* const p = &a;

در این صورت نه می توان اشاره گر را تغییر داد و نه مقدار آن را. در پست های بعدی نمونه های دیگری از آرایه و اشاره گر را بررسی می کنیم.