پيش پردازنده ، نوعي مترجم است كه دستورات توسعه يافته اي از يك زبان برنامه
سازي را گرفته و به دستورات قابل فهم براي كامپايلر همان زبان تبديل مي كند .
بعبارت ديگر، ورودي پيش پردازنده ، برنامه اي با دستورات توسعه يافته است و خروجي
آن ، برنامه ديگري است كه توسط پردازشگر اصلي قابل ترجمه و اجرا است . دستورات
توسعه يافته اي كه در زبان C وجود دارند وتوسط پردازشگر اصلي قابل ترجمه و اجرا
نيستند ، فقط توسط پيش پردازنده قابل فهم هستند و به دستورات پيش پردازنده
معروفند . دستورات پيش پردازنده در زبان C از اهميت ويژه اي برخوردار بوده و اي تنوع خاصي است .

اولين تابع يك برنامه كه اجرا مي شود ، تابع ()main است . اين تابع همانند
توابع ديگر مي تواند داراي آرگومان باشد. آرگومان هاي تابع اصلي را آرگومان هاي
خط فرمان نيز مي گويند . اين نامگذاري بدين دليل است كه :
وقتي برنامه زبان C توسط كامپايلر زبان ترجمه شد ، اين برنامه در خارج از
محيط C و در سطح سيستم عامل قابل اجرا است و در حين اجراي اين برنامه اسامي
آرگومان ها نيز جهت انتقال به تابع اصلي ذكر مي شوند . بعنوان مثال ، فرض كنيد
برنامه اي بنام test.c نوشته ، توسط كامپايلر C آن را ترجمه كرده و برنامه اي به
نام test.exe از آن ساخته ايم . براي اجراي اين برنامه كافي است در سطح سيستم
عامل بصورت زير عمل كنيم (با فرض اين كه اين برنامه در درايو جاري وجود دارد): A>test

اگر فرض شود كه اين برنامه داراي دو پارامتر باشد ، براي اجراي آن در سطح
سيستم عامل ، بايد اسامي آرگومان ها را با يك فاصله بصورت زير تايپ كنيم : A>test par1 par2
par1
و par2و اسامي آرگومان هايي هستند كه به تابع اصلي منتقل مي شوند .
تابع اصلي داراي دو پارامتر بنام هاي argcو argvو است . پارامتر argc از نوع
صحيح بوده و مشخص كننده تعداد آرگومان هاي خط فرمان است . چون نام برنامه به
عنوان يك آرگومان محسوب مي شود لذا حداقل مقدارargc برابر با 1 است . بنابراين
اگر برنامه اي مانند test داراي دو آرگومان باشد، عددي كه در پارامتر argv قرار
مي گيرد برابر با 3 خواهد بود. پارامتر argv به آرايه اي رشته اي اشاره ميكند كه
عناصر آن ، به آرگومان هاي خط فرمان اشاره مي كند . لذا كليه آرگومان هاي تابع
اصلي بصورت رشته هاي فرض مي شوند . بنابراين اگر خواسته باشيم از اعدادي كه به
عنوان آرگومان به تابع اصلي منتقل مي شوند استفاده كنيم ، بايد به طريق مقتضي
( با استفاده از توابع كتابخانه اي و يا توابعي كه خودمان مي نويسيم ) آنها را
از رشته اي ، به عددي تبديل كنيم .

مثال 1: برنامه اي كه نامي را به عنوان آرگومان پذيرفته و عبارت hello را در
جلوي آن نام قرار مي دهد . main(argc/argv)
int argc ;
char *argv[] ;
{
if(argc!=2)
{
printf("\n number of parameter ");
printf("is wrong ." );
exit(0 );
}
printdf("\n\n hello %s"/argv[1] );
}

فرض كنيد نام برنامه مثال 1را name.cا انتخاب كرده ، سپس توسط كامپايلر زبان C
از آن ، برنامه name.exe را ساخته باشيم . براي اجراي اين برنامه كافيست به
صورت زير عمل شود : A>name Ali

پس از اجراي برنامه name ، نتيجه زير حاصل خواهد شد : hello Ali

در مورد ترتيب دسترسي به آرگومان هاي تابع اصلي بايد دقت داشت كه : argv[0]
بنام برنامه ، argv[1] به اولين آرگومان ، argv[2] به دومين آرگومان
و argv[n]به n امين آرگومان اشاره مي كنند .

مثال 2: برنامه اي كه يك عدد را بعنوان آرگومان پذيرفته ، عمل شمارش معكوس از
آن عدد به صفر را انجام مي دهد . اين برنامه مي تواند آرگومان دوم نيز داشته
باشد . اگر آرگومان دوم برابر با "display" باشد ، نتيجه شمارش معكوس در صفحه
نمايش چاپ خواهد شد . main(argc/argv)
int argc ;
char *argv[] ;
{
int disp/count ;
if(argc<=2)
{
printf("\n number of parameter ");
printf("is wrong ." );
exit(0 );
}
if(argc==3 && !strcmp[argv[2]/
"display"))
disp=1 ;
else
disp=0 ;
for(count=atoi(argv[1]);count
;-- count)
if(disp)
printf("\n %d "/count );
printf("%c"/7 );
}

نمونه اي از خروجي برنامه مثال 2 : C:\TC>6-23 5 display
5
4
3
2
1

در خروجي فوق ، 5 عددي است كه بايد بطور معكوس شمارش شود و 6-23 نام برنامه
است .
در مورد مثال 2 بايد دو مطلب زير را بخاطر داشت : 1
تابع ()atoi يكي از توابع كتابخانه اي است كه مقدار عددي رشته اي را به
مقدار عددي صحيح تبديل مي كند. بكار گرفتن اين تابع بدين دليل بود كه عدد وارد
شده بعنوان آرگومان تابع كه شمارش معكوس آن بايد انجام شود ، بصورت رشته اي به
تابع اصلي منتقل خواهد شد كه براي استفاده از آن ، بايد بصورت عددي تبديل شود. 2
آخرين دستور ()printf پس از عمل شمارش معكوس جهت بصدا درآوردن زنگ سيستم
بكار گرفته شده است .
اگر آرايه argv با دو انديس به كار گرفته شود ، موجب دسترسي به هر يك از
از كاراكترهاي آرگومان تابع ( بطور جداگانه ) مي گردد . ( مثال 3 ) .

مثال 3: برنامه اي كه چگونگي دسترسي به هر يك از كاراكترهاي آرگومان تابع
اصلي را نشان مي دهد . main(int argc/char *argv[])
{
int t / i ;
if(argc<2)
{
printf("number of parameters");
printf("is wrong." );
exit(0 );
}
for(t=0 ; t {
i=0 ;
while(argv[t][i])
{
printf("\n %c "/argv[t][i] );
i++ ;
}
}
}

نمونه اي از خروجي برنامه مثال 3 : C:\TC>6-24 allah
a

l
l
a
h

در مثال 3 بايد دقت داشت كه اولين انديس آرايه argv[] يعني t به آرگومان
تابع اصلي ( مشخص كننده شماره آرگومان ) كه يك رشته است اشاره مي كند، و دومين
انديس اين آرايه به كاراكتري از اين آرگومان اشاره مي كند كه شماره آن كاراكتر
با اين انديس مشخص مي شود . بعنوان مثال ، منظور از argv[2][3] كاراكتر سوم از
آرگومان دوم مي باشد .
از نظر تئوري مي توان حداكثر از 32767 عدد آرگومان استفاده نمود كه معمولا" تعداد را اجازه مي دهد .

عليرغم قدرت زيادي كه استفاده از اشاره گرها در زبان به برنامه نويس مي دهد
اشكالاتي را نيز مي تواند بوجود آورد كه برنامه نويس بايد آنها را در نظر داشته
باشد .
اشكال اول ) استفاده از اشاره گرهايي كه قبلا" مقدار نگرفته اند .

مثال 1: main)(
{
int x/*p ;
x=10 ;
*p=x ;
}

دربرنامه مثال 1 عدد 10 به متغير x نسبت داده ميشود و دستور *p=x; به ماشين
مي گويد " محتويات متغير x را در آدرسي كه اشاره گر p به آن اشاره مي كند قرار
بده " . چون اشاره گر p بجايي در حافظه اشاره نميكند ( قبلا" مقدار نگرفته است )
عمل مورد نظر انجام نخواهد شد. براي رفع اين مشكل كافي است در اشاره گر p مقدار
معتبري قرار گيرد .

اشكال دوم ) عدم استفاده صحيح از اشاره گرها

مثال 2: main)(
{
int x / *p ;
x=10 ;
p=x ;
printf("\n %d"/*p );
}

هدف برنامه مثال 2 اين بود كه مقدار متغيرx را كه برابر با 10 است در خروجي
چاپ نمايد ولي به دليل نادرست بودن دستور p=x; ( با توجه به اشاره گر بودن p )
نتيجه مطلوب حاصل نخواهد شد . اين دستور موجب مي شود تا عدد 10 ، نه بعنوان يك
مقدار بلكه بعنوان يك آدرس به اشاره گر p منتقل گردد . براي رفع اين مشكل كافي
است اين دستور را بصورت p=&x; نوشت تا آدرس متغير x به اشاره گر p منتقل شود .

اشكال سوم ) فرض هايي كه برنامه نويس در مورد محل قرار گرفتن متغيرها در حافظه
دارد .

وقتي كه متغيرها در حافظه قرار مي گيرند ، جاي آنها براي ما مشخص نيست و در
هر جايي كه فضايي كافي وجود داشته باشد اين متغيرها در آنجا ذخيره مي شوند .
به همين دليل مقايسه اشاره گرهايي كه به عناصري از يك نوع اشاره نمي كنند صحيح
نبوده و با مشكل مواجه مي گردد ( مثال هاي 3و 4و ) .

مثال 3: main)(
{
char s[80]/y[80] ;
char *p1 / *p2 ;
p1=s ;
p2=y ;
if(p1 printf("p1 points to lower addree.");
}

در مثال 3 مقايسه p1و p2و با يكديگر صحيح نيست ، زيرا محل قرار گرفتن
رشته هاي sو yو براي ما مشخص نيست .

مثال 4: main)(
{
int first[10]/second[10] ;
int *p / t ;
p=first ;
for(t=0 ; t<20 ; t++)
*p++=t ;
}

در مثال 4 سعي شده كه به عناصر آرايه هاي firstو secondو اعداد 0 تا 19 نسبت
داده شود. اگر چه ممكن است اين عمل در بعضي از كامپايلرها به درستي انجام گيرد
ولي در حالت كلي اين طور نيست ، زيرا ممكن است عناصر آرايه هاي firstو secondو
در محل هاي متوالي حافظه قرار نگيرند .
با اشكالاتي كه تاكنون درمورد اشاره گرها گفته شد برنامه نويس بايد در استفاده ا دقت كافي بخرج دهد تا با مشكل مواجه نگردد .

اگر متغيري آدرس متغير ديگر را در خود نگهداري كند ، متغير اول يك اشاره گر
است . اگر متغير دوم ، از نوع اشاره گر باشد در اينصورت متغير اول يك اشاره گر
به اشاره گر است ( شكل 1 ) . يادآوري مي شود كه آرايه اي از اشاره گرها ، نوعي
اشاره گر به اشاره گر است .
متغير اشاره گر
ؤؤؤؤؤؤؤؤؤ ؤؤؤؤؤؤؤؤؤ |
مقدار |ؤؤؤؤؤؤؤؤؤؤؤؤؤؤؤ آدرس >|
ؤؤؤؤؤؤؤؤؤ ؤؤؤؤؤؤؤؤؤ
ؤؤؤؤؤؤؤؤؤ ؤؤؤؤؤؤؤؤؤ ؤؤؤؤؤؤؤؤؤ |
مقدار |ؤؤؤؤؤؤؤؤؤؤؤؤؤؤ آدرس >|ؤؤؤؤؤؤؤؤؤؤؤؤؤؤؤ آدرس >|
ؤؤؤؤؤؤؤؤؤ ؤؤؤؤؤؤؤؤؤ ؤؤؤؤؤؤؤؤؤ
شكل (1) . اشاره گر به اشاره گر

براي تعريف متغيرهاي اشاره گر به اشاره گر ، از دو علامت * استفاده مي شود .

مثال : برنامه اي شامل اشاره گر به اشاره گر . main)(
{
int x / *p /**q ;
x=10 ;
p=&x ;
q=&p ;
printf("\n the points to value:");
printf("%d"/**q );
}

خروجي حاصل از اجراي برنامه مثال بالا : the points to value:1