آموزش کامل اشاره گرها و ارجاعها در c++
آموزش کامل اشاره گرها و ارجاعها
علامتهای & و * :
علامت &:این علامت ادرس یک متغیر در حافظه RAM را بر می گرداند که همواره یک عدد شانزده دهیست.
کد:
int main()
{
int n=12;
cout<<&n<<endl;
}
علامت *:این علامت بر ضد علامت & عمل می کند یعنی اگر ادرس حافظه را به ان بدهیم خود مقدار موجود در ان نقطه از حافظه را بر می گرداند.
کد:
int main()
{
int n=12;
cout<<*&n<<endl;
}
ارجاع و ادرس متغیر:
ارجاع:ارجاع در واقع یک نام مستعار برای یک متغیر است و خود یک متغیر جداگانه نیست به عبارت دیگر با تغییر متغیر اصلی ارجاع نیز تغییر می کند و همچنین با تغییر ارجاع متغیر اصلی هم تغییر می کند.
برای تعریف ارجاع بصورت زیر عمل می کنیم :
int n=44;
int &pn=n;
که در ان pn یک ارجاع است
تذکر مهم:علامت & که برای نشان دادن ادرس متغیر استفاده می شود با علامت & که در تعریف متغیراز نوع ارجاع استفاده می شود هیچ رابطه ای ندارد.
ذخیره ادرس متغیر:
بعضی مواقع لازم می شود که ادرس متغیر را در جایی ذخیره کنیم ولی ادرس متغیر یک عدد معمولی نیست و بصورت اعداد شانزده دهی نوشته می شود برای تعریف این نوع متغیر که ادرس را در خود نگه دارد بصورت زیر عمل می کنیم
int n=44;
int *pn=&n;
تذکر مهم: علامت * که برای نشان دادن محتویات ادرسهاو همچنین قرار دادن مقدار در ان ادرسها (بعدا توضیح داده می شود) استفاده می شود با علامت * که در تعریف بالا استفاده شد هیچ رابطه ای ندارد.
اشاره به اشارگر دیگر:
برای اشاره از یک اشاره گر به اشاره گر دیگر در هر مرحله یک * اضافه می کنیم مثلا اگر داشته باشیم :
int n=44;
int* pn=&n;
انگاه برای اشاره به &pn یک * زیاد می کنیم مثلا:
int **ppn=&pn;
یعنی نمی توانیم بنویسیم :
int *ppn=&pn;
بازگشت از نوع ارجاع:
برای فهمیدن این موضوع ابتدا باید در مورد راست مقدارها و چپ مقدارها کمی توضیح بدم
n=5;
در این کد مقدار 5 به n تخصیص داده شده پس با این حساب n می شود چپ مقدار و 5 می شود راست مقدار کلا به هر چیزی که بتواند در طرف چپ معادله قرار بگیرد و مقدارش قابل تغییر باشد را چپ مقدار نامیده و بعقیه را راست مقدار می نامیم مثلا ما نمی توانیم بنویسیم 5=n چون مقدار پنج قابل تغییر نیست و راست مقدار است.
تذکر:متغیرها و بطور کلی اشیاء چپ مقدار هستند و و لیترالها مثل (15,”abc”) ثابتها و ارایه ها راست مقدارند البته به ارایه ها و ثابتها چپ مقدارهای تغییرناپذیر نیز گفته می شود.
حالا میرسیم به اصل مطلب یعنی اینکه ایا توابع چپ مقدار هستند یا راست مقدار به عبارت ساده تر ایا می شود مقدار برگشتی از یک تابع را به یک عدد تخصیص داد مثل max(m,n) = 50 ؟
در واقع توابع معمولی راست مقدارند ولی اگر ما یک علامت ارجاع یعنی & به اول تابع بصورت زیر اضافه کنیم این تابع چپ مقدار خواهد شد!
کد:
int& max(int& m,int& n)
مثال زیر موضوع را روشن می کند:
کد:
#include<iostream>
using namespace std;
int& max(int& m,int& n)
{
if(m>n)
{
cout<<"max=m \n";
return m;
}
else
{
cout<<"max=n \n";
return n;
}
}
int main()
{
int m=6,n=4;
max(m,n)=3;
max (m,n);
return 0;
}
خروجی برنامه بالا بصورت زیر است
max=m
max=n
در برنامه بالا ابتدا در تابع max دو مقدار m,n با هم مقایسه می شوند و چون مقدار m بزرگتر از n است عبارت max=m
چاپ شده و سپس مقدار m برگردانده می شود در کد اصلی برنامه تابع max که از نوع ارجاع است برابر عبارت 3 قرار می گیرد پس m که اکنون مقدار برگشتی تابع است برابر 3 شده و دوباره تابع max فراخوانده می شود اما اینبار m به 3 تغییر کرده است و در نتیجه عبارت دوم چاپ می شود.
تذکر:توجه داشته باشید که m,n نیز بصورت ارجاع تعریف شده اند زیرا متغیرهای محلی تابع با نابود شدن تابع نابود می شوند و ممکن است برنامه دچار مشکل شود(که 100% این اتفاق خواهد افتاد) به همین دلیل m,n بصورت ارجاع تعریف شده اند به عبارت ساده تر چون وقتی ما متغیری را بصورت ارجاع به تابعی می فرستیم در واقع متغیر جدیدی تولید نشده و تنها ارجاعیست به متغیر برنامه اصلی پس با از بین رفتن تابع متغیر اصلی که درون کد اصلی برنامه است باقی مانده و برنامه دچار مشکل نمی شود .
خواندن ارایه ها با استفاده از اشاره گرها:
همان طور که می دانیم اشاره گرها شامل اسمهای خانه های حافظه هستند و بصورت شانزده دهی نوشته می شوند پس نمی توان اعمال حسابی مثل جمع یا تفریق را بصورت معمول روی انها انجام داد (مجسم کنید 0012FF7C+3 چه عددی می شود!!!) پس چگونه می شود با استفاده از اشاره گر ارایه را خواند و بعنوان مثال در حلقه for بکار برد؟
در واقع اعداد را می توانیم با اشاره گرها جمع کنیم ولی c++ این نوع جمع و تفریق را با جمع و تفریق معمولی متمایز کرده است.به این صورت که هرگاه عددی با یک اشاره گر جمع شود ان اشاره گر حافظه RAM را پیمایش می کند یعنی به همان اندازه تعداد بایت به جلو میرود به مثال زیر دقت کنید:
کد:
#include<iostream>
using namespace std;
int main()
{
const int SIZE=3;
short a[SIZE]={22,33,44};
short* end=a+SIZE;
short sum=0;
for(short* p=a;p<end;p++)
sum +=*p;
cout <<sum<<endl;
return 0;
}
در خط 7 مشاهده می کنیم که یک متغیر از نوع اشاره گر و نوع short تعریف شده می دانیم که در اشاره گرها فقط ادرسهای حافظه را می توان قرار داد .مقدار a در واقع افست ارایه a[SIZE] است. افست همواره ادرس اولین عنصر اول ارایه را بر می گرداند پس a ادرس اولین عنصر ارایه یعنی 22 را برمی گرداند و در end قرار می دهد.سپس مقدار اشاره گر به اندازه size یعنی 3 واحد افزایش میابد .
همان طور که قبلا هم اشاره شد اشاره گرها بصورت واحدهای چند بایتی بسته به نوعشان افزایش یا کاهش میابند نه اینکه 3 به اضافه ادرس اشاره گر شود و سپس در end قرار بگیرد .یعنی اکنون که متغیر end از نوع short است پس end دو واحد دو واحد افزایش میابد.و اگر باضافه 3 شود در واقع 6 بایت به جلو میرود و اگر از نوع int بود 12 بایت به جلو میرفت و ......
توجه داشته باشید که مقدار SIZE در ابتدا از نوع integer بوده است که با جمع شدن با نوع short کامپایلر عمل تبدیل نوع را خود به خود انجام خواهد داد
پس در مثال بالا می توان end را در پایان محاسبات برابر 4 واحد قلمداد کرد . باز هم تاکید می شود که منظور از 4 واحد یعنی 8 بایت به جلو رفتن متغیر end نه 4 عددی
با مثال زیر مسئله را روشن تر می کنم
کد:
#include<iostream>
using namespace std;
int main()
{
const int SIZE=3;
short a[SIZE]={22,33,44};
short* end1=a;
cout<<end1<<endl;
short* end2=a+SIZE;
cout<<end2<<endl;
}
الان در کامپیوتر من end1 روی حافظه ای به اسم 0012FF74 قرار دارد که با سه واحد جلو رفتن می شه مقدار end2 برابر 0012FF7A پس در حافظه RAM من 0012FF7A سه واحد جلوتر از 0012FF74 قرار دارد.
توجه داشته باشید که متغیر p که خودش هم از اشاره گر هستش از همین قانون پیروی کرد یعنی با هر بار تکرار حلقه دو بایت میرود جلو که 1 واحد محسوب می شود.
قرار دادن مقدارهای واقعی (و نه ادرس) در اشاره گرها:
ما می توانیم به دو صورت یک متغیر را مقدار دهی کنیم بصورت عادی مثل X=5 و با استفاده از اشاره گرها.
برای دادن یک مقدار و( نه یک ادرس) به اشاره گر باید بصورت زیر عمل کنیم در نظر داشته باشید که این مقدار در ادرسی که قبلا در اشاره گر ذخیره شده بود قرار می گیرد.
int n=44;
int *pn;
pn=&n;
*pn=50;
یا
int n=44;
int *pn=&n
*pn=50;
پس در مثال بالا در اخر برنامه مقدار n از 44 به 50 تغییر می کند.
ممکن است کمی جا خورده باشد که چگونه در خط دوم *pn یک ادرس را پذیرفته و در خط سوم *pn یک عدد را این مسئله بر می گردد به نکته ای که قبلا هم اشاره کردم یعنی علامت * در هنگام تعریف یک اشاره گر با علامت * که در خط سوم نوشته شد فرق دارد علامت * در خط دوم یک متغیر ایجاد میکند که فقط ادرس می پذیرد اما علامت * در خط سوم یک اشاره گر به یک ادرس است که مقدار می پذیرد .
مثال زیر را در کامپیوتر خود اجرا کنید و نتیجه را ببینید :
کد:
#include <iostream>
using namespace std;
int main ()
{
int n=44;
int* pn=&n;
cout<<"pn="<<pn<<endl;
cout<<"*pn="<<*pn<<endl;
return 0;
}
ما هرگز نمی توانیم اشاره گری را که ادرسی در ان ذخیر نشده است را مقدار دهی کنیم پس کد زیر اشتباه است.
int *pn;
*pn=50;
نکته:به اشاره گری که هیچ ادرسی در ان ذخیره نشده (مثل اشاره گر بالا) اشاره گر سرگردان می گویند.
عملگر new :
برای مقدار دهی اشاره گرهای سرگردان از عملگر new استفاده می کنیم .
به این صورت که این عملگر یک مقدار فضا برای اشاره گر در حافظه ایجاد می نماید که می توانید مقدار مورد نظر(و نه ادرس) را در ان ذخیره کنید.
int* p;
p=new int;
*p=2;
و همچنین می توان سه خط فوق را با هم ترکیب کرد:
int* p=new int(2);
توجه:حتما متوجه شدید که اگه بخواهیم p را بدون علامت * چاپ کنیم ادرس حافظه ای که new ایجاد کرده را چاپ می کند.
عمل گر delete:
کار این عملگر ازاد کردن حافظه ایست که با استفاده از new درست شده است و بصورت زیر عمل می کند
int* p;
p=new int;
*p=2;
delete p;
کاربرد عملگرهای new و delete :
یکی از مهم ترین دلایلی که شما باید این کار را انجام بدهید این است که می توان متغییرها را در زمان اجرای برنامه و نه هنگام کامپایل ان تولید نمود این کار انعطاف پذیری زیادی به شما می دهد. با این دو عملگر حتی می توان پا رو فراتر گذاشت بعنی بعد از اینکه کار با متغیر تمام شد می توانیم باعملگر delete حافظه را ازاد کنیم و ان مقدار فضا رو برای کارهای دیگر بکار ببریم.
آرایه های پویا:
ممکن است شما بخواهید برنامه ای بنویسید که کاربر یک عدد وارد کرده و شما به اندازه همان عدد ارایه درست کنید و چون نمیدانید کاربر چه عددی را وارد می کند باید یک ارایه با مقدار مشخص درست کنید که معمولا بیشتر از حدی هستش که کاربر می خواهد و حافظه هدر میرود یا اینکه کمتر از ان چیزیست که کاربر می خواهد که در اینصورت برنامه دچار مشکل می شود و به احتمال زیاد کل سیستم از کار می افتد این مشکل با اشاره گرها حل شده.
در ابتدا لازم می دانم یاداوری کنم که در هنگام ایجاد یک ارایه حتما باید مقدار ارایه ذکر شود پس کدهای زیر اشتباه است.
کد:
#include<iostream>
using namespace std;
int main()
{
int n=3;
cout<<"enter number:";
cin>>n;
int a[n];
return 0;
}
با اشاره گرها نیز می توان ارایه ایجاد کرد به کد زیر دقت کنید این دو کد معادل یکدیگرند:
float a [20];
float * const a=new float[20];
برای ایجاد ارایه پویا تنها کاری که باید انجام دهیم برداشتن عبارت constدر مثال بالاست است
کد زیر یک ارایه پویا را نشان می دهد :
کد:
#include<iostream>
using namespace std;
int main()
{
int n;
cout<<"enter number:";
cin>>n;
int* a=new int[n];
delete [] a;
return 0;
}
به نحوه نوشتن عملگر delete دقت کنید در هنگام استفاده از این عمگلر دقیقا باید مثل بالا عمل کرد یعنی دو براکت باز و بسته[] بین متغیر و delete قرار داد.
