Borland C++ از سه آرگومان برای main() پشتیبانی می کند. دو مورد اول argc و argv سنتی هستند. اینها تنها استدلال هستند توابع اصلی()، توسط استاندارد ANSI C تعریف شده است. آنها اجازه می دهند آرگومان های خط فرمان به برنامه منتقل شوند. آرگومان های خط فرمان اطلاعاتی هستند که پس از نام برنامه در آن قرار دارند خط فرمان سیستم عامل. به عنوان مثال، هنگامی که یک برنامه با استفاده از کامپایلر خط Borland کامپایل می شود، معمولاً bcc تایپ می شود نام برنامه

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

پارامتر argc شامل تعدادی آرگومان خط فرمان است و یک عدد صحیح است. همیشه حداقل برابر با 1 است، زیرا نام برنامه به عنوان اولین آرگومان واجد شرایط است. پارامتر argv یک اشاره گر به آرایه ای از نشانگرهای کاراکتر است. هر عنصر از این آرایه به یک آرگومان خط فرمان اشاره می کند. همه آرگومان های خط فرمان رشته ای هستند. همه اعداد توسط برنامه به فرمت داخلی تبدیل می شوند. برنامه زیر وقتی مستقیماً بعد از نام برنامه تایپ می‌شود، «Hello» را به‌دنبال آن نام کاربری چاپ می‌کند:

#عبارتند از

{
if(argc!=2)
{
printf("یادتان رفت نام خود را تایپ کنید\n");
بازگشت 1;
}
printf("سلام %s"، argv);
بازگشت 0;
}

اگر تماس بگیرید این برنامهنام، و نام کاربری Sergey است، سپس برای شروع برنامه باید تایپ کنید:
نام سرگئی
در نتیجه برنامه موارد زیر ظاهر می شود:
"سلام سرگئی."

آرگومان های خط فرمان باید با فاصله یا برگه ها از هم جدا شوند. کاما، نقطه ویرگول و کاراکترهای مشابه جداکننده در نظر گرفته نمی شوند. مثلا:

متشکل از سه خط، در حالی که

هرب، ریک، فرد

این یک خط است - کاما جداکننده نیستند.

اگر می خواهید رشته ای حاوی فاصله ها یا برگه ها را به عنوان یک آرگومان واحد ارسال کنید، باید آن را در آن قرار دهید نقل قول های دوگانه. به عنوان مثال، این یک استدلال است:

"این یک امتحان است"

مهم است که argv را به درستی اعلام کنید. معمولی ترین روش این است:

پرانتزهای خالی نشان می دهد که آرایه طول ثابتی ندارد. با استفاده از نمایه سازی argv می توانید به عناصر جداگانه دسترسی پیدا کنید. به عنوان مثال، argv به خط اول اشاره می کند که همیشه نام برنامه را در خود دارد. argv به خط بعدی و غیره اشاره می کند.

در زیر یک مثال کوچک از استفاده از آرگومان های خط فرمان آورده شده است. از مقدار مشخص شده در خط فرمان شمارش معکوس می کند و وقتی به صفر رسید سیگنالی را منتشر می کند. توجه داشته باشید که آرگومان اول حاوی عددی است که با استفاده از تابع استاندارد atoi() به یک عدد صحیح تبدیل شده است. اگر رشته "نمایش" به عنوان آرگومان دوم وجود داشته باشد، خود شمارنده روی صفحه نمایش داده می شود.

/* برنامه شمارش */

#عبارتند از
#عبارتند از
#عبارتند از
int main(int argc، char *argv)
{
int disp, count;
اگر (argc<2)
{
printf("شما باید طول تعداد\n را وارد کنید");
printf("در خط فرمان. دوباره امتحان کنید.\n");
بازگشت 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
else disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d ", count);
printf("%c"، "\a"); /* در اکثر کامپیوترها این یک تماس است */
بازگشت 0;
}

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

برای دسترسی به شخصیت های خط فرمان فردی، یک شاخص دوم به argv اضافه کنید. به عنوان مثال، برنامه زیر تمام آرگومان هایی را که با آنها فراخوانی شده است، یک کاراکتر چاپ می کند:

#عبارتند از
int main(int argc، char *argv)
{
int t, i;
برای (t=0; t {
i = 0;
while(argv[t][i])
{
printf("%c"، argv[t][i]);
}
printf("");
}
بازگشت 0;
}

باید به یاد داشته باشیم که شاخص اول برای دسترسی به یک رشته و دومی برای دسترسی به یک کاراکتر در یک رشته است.

به طور معمول از argc و argv برای به دست آوردن دستورات منبع استفاده می شود. از نظر تئوری امکان داشتن تا 32767 آرگومان وجود دارد، اما اکثر سیستم عامل ها حتی به شما اجازه نمی دهند به آن نزدیک شوید. معمولاً از این آرگومان ها برای تعیین نام یا گزینه های فایل استفاده می شود. استفاده از آرگومان های خط فرمان ظاهری حرفه ای به برنامه می دهد و به برنامه اجازه می دهد در فایل های دسته ای استفاده شود.

اگر فایل WILDARGS.OBJ ارائه شده با Borland C++ را اضافه کنید، می توانید از الگوها در آرگومان های نوع *.EXE استفاده کنید. (Borland C++ به طور خودکار حروف عام را مدیریت می کند و argc را بر اساس آن افزایش می دهد.) برای مثال، اگر WILDARGS.OBJ را به برنامه زیر متصل کنید، به شما می گوید که چند فایل با نام فایل مشخص شده در خط فرمان مطابقت دارند:

/* پیوند این برنامه با WILDARGS.OBJ */

#عبارتند از
int main(int argc، char *argv)
{
ثبت نام int i;
printf("%d فایل مطابق با نام مشخص شده\n"، argc-1);
printf("آنها عبارتند از:");
برای (i=1; i printf("%s", argv[i]);
بازگشت 0;
}

اگر این برنامه را WA صدا کنیم، سپس آن را به صورت زیر اجرا کنیم، تعداد فایل های با پسوند EXE و لیستی از نام این فایل ها به دست می آید:

علاوه بر argc و argv، Borland C++ یک آرگومان خط فرمان سوم -env را نیز ارائه می‌کند. پارامتر env به برنامه اجازه می دهد تا به اطلاعات مربوط به محیط سیستم عامل دسترسی پیدا کند. پارامتر env باید از argc و argv پیروی کند و به صورت زیر اعلام می شود:

همانطور که می بینید، env به همان شکل argv اعلام می شود. درست مانند argv، نشانگر آرایه ای از رشته ها است. هر خط یک رشته محیطی است که توسط سیستم عامل تعریف شده است. پارامتر env هیچ پارامتر argc معادلی ندارد که نشان دهد چند ردیف محیط وجود دارد. در عوض آخرین خط محیط تهی است. برنامه زیر تمام رشته های محیطی را که در حال حاضر در سیستم عامل تعریف شده است چاپ می کند:

/* این برنامه تمام خطوط محیط را نمایش می دهد */

#عبارتند از
int main(int argc، char *argv، char *env)
{
int t;
برای (t=0؛ env[t]/ t++)
printf("%s\n", env[t]);
بازگشت 0;
}

لطفاً توجه داشته باشید که اگرچه argc و argv توسط برنامه استفاده نمی شوند، اما باید در لیست پارامترها وجود داشته باشند. C نام پارامترها را نمی داند. در عوض، استفاده از آنها با ترتیبی که پارامترها اعلام می شوند تعیین می شود. در واقع شما می توانید پارامتر را هر چه دوست دارید فراخوانی کنید. از آنجایی که argc، argv و env نام‌های سنتی هستند، بهتر است به استفاده از آنها ادامه دهید تا هر کسی که برنامه را می‌خواند بتواند فوراً بفهمد که اینها آرگومان‌هایی برای تابع main() هستند.

یک کار معمولی برای برنامه ها جستجوی یک مقدار تعریف شده در یک رشته محیطی است. به عنوان مثال، محتویات خط PATH به برنامه ها اجازه می دهد تا از مسیرهای جستجو استفاده کنند. برنامه زیر نحوه یافتن رشته هایی را نشان می دهد که مسیرهای جستجوی استاندارد را اعلام می کنند. از تابع استاندارد کتابخانه strstr() استفاده می کند که نمونه اولیه زیر را دارد:

Char *strstr(const char *str1, const char *str2);

تابع strstr() رشته ای را که توسط str1 به آن اشاره شده است را در رشته ای که توسط str2 به آن اشاره شده است جستجو می کند. اگر چنین رشته ای یافت شود، یک اشاره گر به موقعیت اول برگردانده می شود. اگر هیچ منطبقی یافت نشد، تابع NULL را برمی‌گرداند.

/* برنامه در میان رشته های محیط برای یک خط حاوی PATH */ جستجو می کند.

#عبارتند از
#عبارتند از
int main (int argc، char *argv، char *env)
{
int t;
برای (t=0؛ env[t]؛ t++)
{
if(strstr(env[t]، "PATH"))
printf("%s\n", env[t]);
}
بازگشت 0;
}

هنگام ایجاد یک برنامه کنسول در زبان برنامه نویسی C++، یک خط بسیار شبیه به این به طور خودکار ایجاد می شود:

پارامترهای تابع Int main(int argc، char* argv) // main().

این خط سربرگ تابع اصلی main() است، پارامترهای argс و argv در براکت اعلام شده اند. بنابراین، اگر برنامه ای را از طریق خط فرمان اجرا کنید، امکان انتقال اطلاعات به این برنامه وجود دارد، برای این کار پارامترهای argc و argv وجود دارد. پارامتر argc یک نوع داده int دارد و شامل تعداد پارامترهایی است که به تابع اصلی ارسال شده است. علاوه بر این، argc همیشه حداقل 1 است، حتی زمانی که ما هیچ اطلاعاتی را ارسال نمی کنیم، زیرا اولین پارامتر نام تابع است. پارامتر argv آرایه ای از اشاره گرها به رشته ها است. فقط داده های رشته ای را می توان از طریق خط فرمان منتقل کرد. اشاره گرها و رشته ها دو موضوع بزرگ هستند که بخش های جداگانه ای برای آنها ایجاد شده است. بنابراین از طریق پارامتر argv است که هر اطلاعاتی منتقل می شود. بیایید برنامه ای ایجاد کنیم که از طریق خط فرمان ویندوز اجرا کنیم و اطلاعاتی را به آن منتقل کنیم.

// argc_argv.cpp: نقطه ورودی برنامه کنسول را تعریف می کند. #include "stdafx.h" #include با استفاده از namespace std. int main(int argc، char* argv) (اگر (argc ><< argv<

// کد کد::Blocks

// کد Dev-C++

// argc_argv.cpp: نقطه ورودی برنامه کنسول را تعریف می کند. #عبارتند از با استفاده از namespace std. int main(int argc, char* argv) (اگر (argc > 1) // اگر آرگومان ها را پاس کنیم، argc بزرگتر از 1 خواهد بود (بسته به تعداد آرگومان ها) (cout<< argv<

بعد از اینکه برنامه را دیباگ کردیم، خط فرمان ویندوز را باز کرده و فایل اجرایی برنامه خود را به پنجره خط فرمان بکشید، مسیر کامل برنامه در خط فرمان نمایش داده می شود (اما می توانید مسیر برنامه را به صورت دستی وارد کنید. ) پس از آن می توانید کلیک کنید واردو برنامه شروع خواهد شد (شکل 1 را ببینید).

شکل 1 - پارامترهای تابع اصلی

از آنجایی که ما به سادگی برنامه را اجرا کردیم و هیچ آرگومانی به آن ارسال نکردیم، پیام Not arguments ظاهر شد. شکل 2 راه اندازی همان برنامه را از طریق خط فرمان، اما با ارسال آرگومان Open به آن نشان می دهد.

شکل 2 - پارامترهای تابع اصلی

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

شکل 3 - پارامترهای تابع اصلی

و اگر نقل قول ها را حذف کنید. سپس ما فقط کلمه It را خواهیم دید. اگر قصد ندارید هنگام اجرای برنامه هیچ اطلاعاتی را ارسال کنید، می توانید آرگومان های تابع main() را حذف کنید و همچنین می توانید نام این آرگومان ها را تغییر دهید. گاهی اوقات تغییراتی در پارامترهای argc و argv رخ می دهد، اما همه اینها به نوع برنامه ایجاد شده یا محیط توسعه بستگی دارد.

هنگام ایجاد خودکار یک برنامه کنسول در زبان برنامه نویسی C++، یک تابع اصلی بسیار شبیه به این به طور خودکار ایجاد می شود:

int main(int argc، char * argv)
{…}

هدر تابع حاوی امضای تابع اصلی main() با آرگومان های argс و argv است.
اگر برنامه ای را از طریق خط فرمان اجرا کنید، امکان انتقال اطلاعات به این برنامه وجود دارد. آرگومان های خط فرمان argc و argv برای این کار وجود دارد.
پارامتر argc از نوع int است و شامل تعداد پارامترهای ارسال شده به تابع اصلی می باشد. علاوه بر این، argc همیشه حداقل 1 است، حتی زمانی که هیچ اطلاعاتی به تابع اصلی منتقل نمی شود، زیرا اولین پارامتر نام برنامه است.
پارامتر argv آرایه ای از اشاره گرها به رشته ها است. فقط داده های رشته ای را می توان از طریق خط فرمان منتقل کرد.

وقتی برنامه ای را از طریق خط فرمان ویندوز اجرا می کنید، می توانید اطلاعاتی را به آن منتقل کنید. در این حالت خط فرمان به شکل زیر خواهد بود:
Drive:\path\name.exe argument1 argument2 ...

آرگومان های خط فرمان با یک یا چند فاصله از هم جدا می شوند.

آرگومان argv شامل نام کامل برنامه است:

#عبارتند از
با استفاده از namespace std.

کوت<< argv << endl;

بازگشت 0؛
}

نتیجه اجرا

مثال: محاسبه حاصل ضرب دو عدد صحیح
این برنامه از تابع برای تبدیل رشته به عدد صحیح ()StrToInt از اینجا استفاده می کند.

#عبارتند از
با استفاده از namespace std.
int StrToInt(char *s) (…)
int main(int argc، char * argv) (

Int a = 0، b=0;

اگر (argc > 1)

a = StrToInt(argv)؛

اگر (argc > 2)

b = StrToInt(argv);

کوت<< a <<«*» << b << «= « << a*b << endl;

بازگشت 0؛
}

این برنامه به شرح زیر راه اندازی می شود:

نتیجه اجرا

اشکال زدایی یک برنامه با آرگومان های خط فرمان

برای ارسال آرگومان های خط فرمان هنگام اشکال زدایی یک برنامه، باید به منو دسترسی داشته باشید خواصپروژه


روی زبانه ویژگی های پیکربندی -> اشکال زداییانتخاب کنید آرگومان های فرمانو مقادیر آنها را تعیین کنید.

هنگام اجرای برنامه در حالت اشکال زدایی، آرگومان های وارد شده توسط برنامه به عنوان آرگومان های خط فرمان تلقی می شوند.

می توانید برخی از آرگومان ها را به برنامه های C ارسال کنید. وقتی main() در ابتدای محاسبه فراخوانی شود، سه پارامتر به آن ارسال می شود. اولین آنها تعداد آرگومان های فرمان را هنگام دسترسی به برنامه تعیین می کند. دومین آرایه ای از اشاره گرها به رشته های کاراکتر حاوی این آرگومان ها است (یک آرگومان در هر خط). سومین آرایه ای از اشاره گرها به رشته های کاراکتر است؛ برای دسترسی به پارامترهای سیستم عامل (متغیرهای محیطی) استفاده می شود.

هر خطی به صورت زیر نمایش داده می شود:

متغیر = مقدار\0

آخرین خط را می توان با دو صفر انتهایی پیدا کرد.

بیایید آرگومان های تابع main() را بر این اساس نام گذاری کنیم: argc، argv و env (هر نام دیگری ممکن است). سپس توضیحات زیر قابل قبول است:

اصلی (int argc، char *argv)

اصلی (int argc، char *argv، char *env)

بیایید فرض کنیم که در درایو A: یک برنامه prog.exe وجود دارد. بیایید آن را به صورت زیر مطرح کنیم:

A:\>prog.exe file1 file2 file3

سپس argv یک اشاره گر به خط A:\prog.exe است، argv یک اشاره گر به خط file1 و غیره است. اولین استدلال واقعی توسط argv و آخرین استدلال توسط argv اشاره شده است. اگر argc=1 باشد، پس از نام برنامه هیچ پارامتری در خط فرمان وجود ندارد. در مثال ما argc=4.

بازگشت

Recursion روشی برای فراخوانی است که در آن یک تابع به خودش اشاره دارد.

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

توابع کتابخانه

در سیستم های برنامه نویسی، روال هایی برای حل مسائلی که اغلب با آن مواجه می شوند در کتابخانه ها ترکیب می شوند. چنین وظایفی عبارتند از: محاسبه توابع ریاضی، ورودی/خروجی داده، پردازش رشته، تعامل با ابزارهای سیستم عامل و غیره. استفاده از روال های کتابخانه ای کاربر را از توسعه ابزارهای مناسب بی نیاز می کند و خدمات اضافی را در اختیار او قرار می دهد. توابع موجود در کتابخانه ها با سیستم برنامه نویسی عرضه می شوند. اعلان های آنها در فایل های *.h آورده شده است (اینها به اصطلاح فایل های include یا header هستند). بنابراین، همانطور که در بالا ذکر شد، در ابتدای برنامه با توابع کتابخانه باید خطوطی مانند:

#عبارتند از<включаемый_файл_типа_h>

مثلا:

#عبارتند از

همچنین امکاناتی برای گسترش و ایجاد کتابخانه های جدید با برنامه های کاربری وجود دارد.

متغیرهای سراسری یک مکان ثابت در حافظه برای کل مدت برنامه اختصاص داده می شوند. متغیرهای محلی در پشته ذخیره می شوند. بین آنها یک ناحیه حافظه برای تخصیص پویا وجود دارد.

توابع malloc() و free() برای تخصیص پویا حافظه آزاد استفاده می شوند. تابع malloc() حافظه را تخصیص می دهد، تابع free() آن را آزاد می کند. نمونه های اولیه این توابع در فایل هدر stdlib.h ذخیره می شوند و به شکل زیر هستند:

void *malloc(size_t size);

void *free(void *p);

تابع malloc() یک اشاره گر خالی را برمی گرداند. برای استفاده صحیح، مقدار تابع باید به یک اشاره گر به نوع مناسب تبدیل شود. در صورت موفقیت آمیز بودن، این تابع یک اشاره گر را به اولین بایت حافظه آزاد با اندازه اندازه برمی گرداند. اگر حافظه کافی وجود نداشته باشد، مقدار 0 برگردانده می شود. برای تعیین تعداد بایت های مورد نیاز برای یک متغیر، از عملیات sizeof() استفاده کنید.

نمونه ای از استفاده از این توابع:

#عبارتند از

#عبارتند از

p = (int *) malloc(100 * sizeof(int)); /* تخصیص حافظه برای 100

اعداد صحیح */

printf("حافظه کافی نیست\n");

برای (i = 0; i< 100; ++i) *(p+i) = i; /* Использование памяти */

برای (i = 0; i< 100; ++i) printf("%d", *(p++));

آزاد (p)؛ /* حافظه خالی */

قبل از استفاده از اشاره گر برگشتی توسط malloc()، باید مطمئن شوید که حافظه کافی وجود دارد (اشاره گر خالی نیست).

پیش پردازنده

پیش پردازنده C برنامه ای است که ورودی کامپایلر را پردازش می کند. پیش پردازنده به برنامه منبع نگاه می کند و اقدامات زیر را انجام می دهد: فایل های مشخص شده را به آن متصل می کند، تعویض ها را انجام می دهد و همچنین شرایط کامپایل را کنترل می کند. خطوط برنامه که با نماد # شروع می شوند برای پیش پردازنده در نظر گرفته شده اند. فقط یک دستور (دستورالعمل پیش پردازنده) مجاز است در یک خط نوشته شود.

بخشنامه

#define جایگزینی شناسه

باعث می شود شناسه نامگذاری شده در متن برنامه بعدی با متن جایگزین جایگزین شود (به عدم وجود نقطه ویرگول در انتهای این دستور توجه کنید). اساساً، این دستورالعمل یک تعریف کلان را معرفی می کند، که در آن "شناسه" نام تعریف کلان است، و "جایگزینی" دنباله ای از کاراکترها است که پیش پردازنده زمانی که نام مشخص شده را در متن برنامه پیدا می کند، جایگزین آن می شود. مرسوم است که نام یک تعریف کلان را با حروف بزرگ تایپ کنید.

بیایید به مثال ها نگاه کنیم:

خط اول باعث می شود که برنامه شناسه MAX را با ثابت 25 جایگزین کند. خط دوم به شما امکان می دهد از کلمه BEGIN در متن به جای پرانتز (() استفاده کنید.

توجه داشته باشید که از آنجایی که پیش پردازشگر سازگاری بین نام‌های نمادین تعاریف کلان و زمینه استفاده از آنها را بررسی نمی‌کند، توصیه می‌شود که این شناسه‌ها را نه با دستور #define، بلکه با استفاده از کلمه کلیدی const با اشاره صریح تعریف کنید. نوع (این به میزان بیشتری برای C++ صدق می کند):

const int MAX = 25;

(نوع int را می توان حذف کرد، زیرا پیش فرض است).

اگر دستور #define به نظر می رسد:

#define identifier(identifier, ..., identifier) ​​جایگزینی

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

#define READ(val) scanf("%d"، &val)

بیانیه READ(y); همانند scanf("%d"،&y);. در اینجا val یک آرگومان است و جایگزینی ماکرو با آرگومان انجام می شود.

اگر تعاریف طولانی در جایگزینی وجود داشته باشد که در خط بعدی ادامه یابد، کاراکتر \ در انتهای خط ادامه بعدی قرار می گیرد.

می توانید اشیایی که با ## از هم جدا شده اند را در یک تعریف ماکرو قرار دهید، به عنوان مثال:

#تعریف روابط عمومی (x، y) x##y

پس از این، PR(a, 3) جایگزینی a3 را فراخوانی می کند. یا مثلا تعریف کلان

#تعریف z(a، b، c، d) a(b##c##d)

منجر به جایگزینی z(sin, x, +, y) با sin(x+y) می شود.

نماد # که قبل از یک آرگومان ماکرو قرار می گیرد، نشان می دهد که به یک رشته تبدیل شده است. مثلا بعد از بخشنامه

#define PRIM(var) printf(#var"= %d، var)

قطعه زیر از متن برنامه

به این صورت تبدیل می شود:

printf("year""= %d، year);

بیایید سایر دستورالعمل های پیش پردازنده را شرح دهیم. بخشنامه #شامل قبلا دیده شده بود. به دو صورت قابل استفاده است:

#include "filename"

#عبارتند از<имя файла>

عمل هر دو دستور گنجاندن فایل هایی با نام مشخص شده در برنامه است. اولین آنها یک فایل را از دایرکتوری فعلی یا دایرکتوری مشخص شده به عنوان پیشوند بارگیری می کند. فرمان دوم فایل را در مکان های استاندارد تعریف شده در سیستم برنامه نویسی جستجو می کند. اگر فایلی که نام آن به صورت دو گیومه نوشته شده است در دایرکتوری مشخص شده یافت نشد، جستجو در زیر شاخه های مشخص شده برای دستور #include ادامه می یابد.<...>. دستورات #include را می توان درون یکدیگر قرار داد.

گروه بعدی دستورات به شما اجازه می دهد تا به طور انتخابی بخش هایی از برنامه را کامپایل کنید. به این فرآیند کامپایل شرطی می گویند. این گروه شامل بخشنامه های #if، #else، #elif، #endif، #ifdef، #ifndef است. شکل اصلی نوشتن دستور #if به شکل زیر است:

#اگر دنباله_اظهار_ثابت است

در اینجا مقدار یک عبارت ثابت بررسی می شود. اگر درست باشد، دنباله ای از عبارات مشخص شده اجرا می شود و اگر نادرست باشد، این دنباله از دستورات حذف می شود.

عملکرد دستور #else مشابه عملکرد دستور else در زبان C است، به عنوان مثال:

#اگر ثابت_بیان

بیانیه_دنباله_2

در اینجا، اگر عبارت ثابت درست باشد، operator_sequence_1 اجرا می شود و اگر false، operator_sequence_2 اجرا می شود.

دستور #elif به معنای اقدام «اگر دیگر» است. شکل اصلی استفاده از آن عبارت است از:

#اگر ثابت_بیان

بیانیه_توالی

#الف ثابت_بیان_1

بیانیه_توالی_1

#elif ثابت_بیان_n

دنباله_اظهارات_n

این فرم شبیه ساختار زبان C است: if...else if...else if...

بخشنامه

شناسه #ifdef

تعیین می کند که آیا شناسه مشخص شده در حال حاضر تعریف شده است یا خیر. آیا در بخشنامه هایی مانند #define گنجانده شده است. رشته فرم

شناسه #ifndef

بررسی می کند که آیا شناسه مشخص شده در حال حاضر تعریف نشده است یا خیر. هر یک از این دستورات را می توان با تعداد دلخواه از خطوط متن دنبال کرد که احتمالاً حاوی یک عبارت #else است (#elif قابل استفاده نیست) و با خط #endif ختم می شود. اگر شرط مورد بررسی درست باشد، تمام خطوط بین #else و #endif نادیده گرفته می‌شوند و اگر false باشد، خطوط بین check و #else نادیده گرفته می‌شوند (اگر کلمه #else وجود ندارد، #endif). دستورات #if و #ifndef را می توان درون یکدیگر قرار داد.

مشاهده بخشنامه

شناسه #undef

باعث می شود که شناسه مشخص شده تعریف نشده در نظر گرفته شود، یعنی. مشمول تعویض نیست

بیایید به نمونه هایی نگاه کنیم. سه بخشنامه زیر:

بررسی کنید که آیا شناسه WRITE تعریف شده است (یعنی آیا دستوری مانند #define WRITE وجود دارد یا خیر)، و اگر چنین است، نام WRITE شروع به تعریف نشده در نظر گرفته می شود، یعنی. مشمول تعویض نیست

بخشنامه ها

#define WRITE fprintf

بررسی می کند که آیا شناسه WRITE تعریف نشده است یا خیر، و اگر چنین است، شناسه WRITE به جای نام fprintf تعیین می شود.

دستور #error به شکل زیر نوشته شده است:

#پیام_خطا

اگر در متن برنامه رخ دهد، کامپایل متوقف می شود و یک پیام خطا روی صفحه نمایش نمایش داده می شود. این دستور عمدتاً در مرحله اشکال زدایی استفاده می شود. توجه داشته باشید که نیازی نیست که پیام خطا در دو گیومه قرار گیرد.

دستور #line برای تغییر مقادیر متغیرهای _LINE_ و _FILE_ تعریف شده در سیستم برنامه نویسی C در نظر گرفته شده است. متغیر _LINE_ شامل شماره خط برنامه در حال اجرا است. شناسه _FILE_ اشاره گر به رشته ای با نام برنامه در حال کامپایل است. دستور #line به صورت زیر نوشته شده است:

#خط "نام_پرونده"

در اینجا عدد هر عدد صحیح مثبتی است که به متغیر _LINE_ اختصاص داده می شود، file_name یک پارامتر اختیاری است که مقدار _FILE_ را لغو می کند.

دستورالعمل #pragma به شما این امکان را می دهد که دستورالعمل هایی را به کامپایلر منتقل کنید. مثلا خط

نشان می دهد که برنامه C شامل رشته های زبان اسمبلی است. مثلا:

بیایید به برخی از شناسه‌ها یا نام‌های کلان جهانی (نام‌های تعریف کلان) نگاهی بیندازیم. پنج نام از این قبیل تعریف شده است: _LINE_، _FILE_، _DATE_، _TIME_، _STDC_. دو مورد از آنها (_LINE_ و _FILE_) قبلاً در بالا توضیح داده شده است. شناسه _DATE_ رشته ای را مشخص می کند که تاریخ ترجمه فایل منبع به کد شی را ذخیره می کند. شناسه _TIME_ رشته ای را مشخص می کند که زمان ترجمه فایل منبع را به کد شی ذخیره می کند. اگر از نام‌های ماکرو تعریف شده استاندارد استفاده شود، ماکرو _STDC_ دارای مقدار 1 است. در غیر این صورت این متغیر تعریف نمی شود.

این اتفاق می افتد که هنگام فراخوانی، داده ها از خط فرمان به برنامه منتقل می شوند. چنین داده هایی آرگومان های خط فرمان نامیده می شوند. به نظر می رسد به عنوان مثال:

./a.out test.txt ls -lt /home/peter/

در اینجا برنامه های a.out (از دایرکتوری فعلی) و ls (از همان دایرکتوری مشخص شده در متغیر محیطی PATH) فراخوانی می شوند. برنامه اول از خط فرمان یک کلمه - test.txt، دوم - دو: -lt و /home/peter/ را دریافت می کند.

اگر برنامه به زبان C نوشته شده باشد، پس از راه اندازی، کنترل بلافاصله به تابع main() منتقل می شود، بنابراین، این تابعی است که آرگومان های خط فرمان را دریافت می کند که به متغیرهای پارامتر آن اختصاص داده می شود.

قبلاً تابع main() را طوری تعریف کردیم که گویی هیچ پارامتری را نمی گیرد و چیزی برمی گرداند. در واقع، در زبان C، هر تابعی به طور پیش فرض (اگر چیز دیگری تعریف نشده باشد) یک عدد صحیح برمی گرداند. می توانید از این موضوع مطمئن باشید. اگر کد را به این صورت بنویسید:

main() ( printf ("سلام \n") ؛ بازگشت 0 ; )

سپس هیچ هشدار یا خطایی در حین کامپایل رخ نخواهد داد. اگر int main() بنویسید همین اتفاق می افتد. این ثابت می کند که تابع به طور پیش فرض یک عدد صحیح و نه هیچ (void) را برمی گرداند. اگرچه آنچه که یک تابع برمی گرداند همیشه می تواند «بازگردانده شود»، برای مثال، voidmain() یا float main() .

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

1. عدد صحیح، نشان دهنده تعداد کلمات (عناصر جدا شده با فاصله) در خط فرمان هنگام فراخوانی،
2. اشاره گر به آرایه ای از رشته ها، که در آن هر خط یک کلمه جداگانه از خط فرمان است.

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

./a.out 12 موضوع 2

سپس اولین آرگومان برنامه دارای مقدار 4 است و آرایه رشته ها به صورت (./a.out، "12"، "theme"، "2") تعریف می شود.

به اصطلاحات توجه کنید، فقط دو آرگومان برنامه (یک عدد و یک آرایه) وجود دارد، اما به تعداد دلخواه آرگومان خط فرمان وجود دارد. آرگومان های خط فرمان به آرگومان های برنامه (به آرگومان های تابع main() تبدیل می شوند.
این داده (عدد و اشاره گر) به برنامه ارسال می شود حتی زمانی که به سادگی با نام فراخوانی شود بدون اینکه چیزی به آن ارسال شود: ./a.out. در این حالت، آرگومان اول دارای مقدار 1 است و آرگومان دوم به آرایه ای متشکل از فقط یک خط (."/a.out") اشاره می کند.

فقط به این دلیل که داده ها به برنامه منتقل می شوند به این معنی نیست که تابع main() باید آن را بپذیرد. اگر تابع main() بدون پارامتر تعریف شده باشد، دسترسی به آرگومان های خط فرمان ممکن نیست. اگرچه هیچ چیز شما را از انتقال آنها باز نمی دارد. هیچ خطایی وجود نخواهد داشت.

برای دسترسی به داده های ارسال شده به برنامه، باید به متغیرها اختصاص داده شود. از آنجایی که آرگومان ها بلافاصله به main() منتقل می شوند، هدر آن باید به شکل زیر باشد:
اصلی (int n، char *arr)

متغیر اول (n) شامل تعداد کلمات است و متغیر دوم حاوی اشاره گر به آرایه ای از رشته ها است. اغلب پارامتر دوم به صورت **arr نوشته می شود. با این حال، این همان چیزی است. به یاد بیاورید که آرایه رشته ها به عنوان عناصر خود، نشانگرهایی به رشته ها را شامل می شود. و یک اشاره گر به اولین عنصر آرایه به تابع ارسال می کنیم. معلوم می شود که ما یک اشاره گر را به یک اشاره گر منتقل می کنیم، i.e. **ارر

ورزش
برنامه ای مانند این بنویسید:

#عبارتند از int main(int argc, char ** argv) ( int i; printf ("%d \n"، argc)؛ برای (i= 0 ; i< argc; i++ ) puts (argv[ i] ) ; }

هنگام فراخوانی، تعداد کلمات روی خط فرمان و هر کلمه را در یک خط جدید نشان می دهد. آن را بدون آرگومان های خط فرمان و با آرگومان فراخوانی کنید.

در برنامه از متغیرهای پارامتر argc و argv استفاده کردیم. استفاده از این نام ها مرسوم است، اما در واقع می توانند هر چیزی باشند. بهتر است به این استاندارد پایبند باشید تا برنامه های شما نه تنها برای شما، بلکه برای سایر برنامه نویسان نیز قابل درک باشد.

اهمیت عملی انتقال داده ها به برنامه

اگر تجربه ای با خط فرمان گنو/لینوکس دارید، می دانید که اکثر دستورات دارای سوئیچ و آرگومان هستند. به عنوان مثال، هنگام مشاهده محتویات دایرکتوری ها، کپی کردن، جابجایی، اشیاء سیستم فایل که دستور بر روی آنها اجرا می شود به عنوان آرگومان مشخص می شوند. ویژگی های اجرای آن با استفاده از کلیدها تعیین می شود. مثلا در یک تیم

Cp -r ../les_1 ../les_101

cp نام فرمان، -r سوئیچ، و ../les_1 و ../les_101 آرگومان های فرمان هستند.

به طور کلی، اغلب، آدرس های فایل و "تغییر کننده ها" (اینها کلیدها) فرآیند اجرای برنامه هنگام راه اندازی به برنامه ها منتقل می شوند.

بیایید برنامه ای بنویسیم که فایل های مشخص شده توسط کاربر را در خط فرمان برای نوشتن یا اضافه کردن باز می کند و همان اطلاعاتی را که کاربر در هنگام اجرای برنامه از صفحه کلید وارد می کند، در آنجا می نویسد (اضافه می کند):

#عبارتند از #عبارتند از اصلی (int argc، char ** argv) (int i، ch؛ FILE * f[ 5 ] ؛ if (argc< 3 || argc >7) (قرار می دهد ( "تعداد پارامتر نامعتبر") ؛ بازگشت 1 ; ) if (strcmp (argv[ 1 ] , "-w" ) != 0 && strcmp (argv[ 1 ] , "-a" ) != 0 ) ( قرار می دهد ( "پارامتر اول می تواند -w یا -a باشد") ؛ بازگشت 2 ; ) برای (i= 0 ؛ i< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("فایل %s باز نمی شود\n", argv[ i+ 2 ] ) ; بازگشت 3 ; ) ) در حالی که ((ch = getchar () ) != EOF) برای (i= 0 ; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

توضیحات برای کد:

1. آرایه ای از پنج نشانگر فایل ایجاد می شود. بنابراین، شما نمی توانید بیش از پنج فایل را همزمان باز کنید. نشانگر فایل فایل اول در عنصر آرایه f، دومی - در f و غیره ذخیره می شود.
2. تعداد آرگومان های خط فرمان بررسی می شود. باید حداقل سه نفر از آنها وجود داشته باشد، زیرا ... اولی نام برنامه، دومی حالت باز کردن فایل، سومی اولین یا تنها فایلی است که باید روی آن نوشته شود. از آنجایی که این برنامه به شما اجازه می دهد فقط پنج فایل را باز کنید، تعداد کل آرگومان های خط فرمان نمی تواند بیش از هفت باشد. بنابراین، اگر تعداد آرگومان ها کمتر از 3 یا بیشتر از 7 باشد، برنامه به پایان می رسد، زیرا دستور return باعث خروج تابع می شود، حتی اگر کد بیشتری بعد از آن وجود داشته باشد. مقدار بازگردانده شده از تابعی که برابر با 0 نیست، می تواند توسط فرآیند والد به عنوان پیامی مبنی بر خاتمه برنامه با یک خطا تفسیر شود.
3. اعتبار آرگومان خط فرمان دوم را بررسی می کند. اگر نه "-w" و نه "-a" باشد، عبارت شرطی در if دوم 1 (true) را برمی گرداند. تابع strcmp() به شما امکان می دهد رشته ها را با هم مقایسه کنید و در صورت مساوی بودن 0 را برمی گرداند.
4. حلقه for فایل ها را در آدرس های مشخص شده باز می کند که با عنصر سوم آرایه argv شروع می شود. به همین دلیل 2 به i اضافه می شود تا عناصر آرایه argv از سوم شروع شود. عبارت argc-2 تعداد نام فایل های ارسال شده را نشان می دهد. زیرا argc تعداد کل آرگومان های خط فرمان را ذخیره می کند که دو مورد اول نام فایل نیستند.
5. عبارت argv+1 به شما این امکان را می دهد که زیر رشته "w" (یا "a") را از رشته "-w" (یا "-a") "برش دهید"، زیرا argv در اصل یک اشاره گر به اولین عنصر رشته است. با اضافه کردن یک به نشانگر، آن را به عنصر بعدی آرایه منتقل می کنیم.
6. اگر فایل باز نمی شود، تابع fopen() NULL را برمی گرداند. در این صورت برنامه به پایان می رسد.
7. هر کاراکتری که کاربر روی صفحه کلید وارد می کند در همه فایل های باز نوشته می شود.
8. در پایان پرونده ها بسته می شوند.