- argc, მთელი რიცხვი, არის მთავარ ფუნქციაზე გაგზავნილი ბრძანების ხაზის არგუმენტების რაოდენობა, - argv არის სტრიქონების მაჩვენებლების მასივი (char *).

მე ყოველთვის ვეპყრობი C ფუნქციებს, თითქოს ისინი აფიქსირებენ არგუმენტების რაოდენობას კონტექსტის მიუხედავად, თუ ისინი არ იყენებენ va_args. ანუ, მე მჯერა, რომ მათ ყოველთვის აქვთ პროტოტიპი:

Int main(int argc, char **argv).

მაშინაც კი, თუ არგუმენტები არ არის გადაცემული, ფუნქციას აქვს ეს არგუმენტები სტეკზე, რადგან მთავარ ფუნქციას არ აქვს ფუნქციის გადატვირთვა.

C-ს აქვს უნარი, ჰქონდეს პრიმიტიული გადატვირთვა, უბრალოდ, თითქოს არგუმენტი აკლია. ამ შემთხვევაში, არგუმენტი მაინც გადის და არის დასტაზე, მაგრამ თქვენ არასოდეს შეხვალთ მასზე, ამიტომ ის უბრალოდ ამცირებს საწყისი კოდის ზომას.

int main()-ის თქმა უბრალოდ ნიშნავს, რომ ვიცი, რომ ფუნქციას შეიძლება ჰქონდეს პარამეტრები, მაგრამ მე მათ არ ვიყენებ, ამიტომ ვწერ int main().

განცხადება int main (void) ამბობს, რომ მთავარ SCENELY-ს არ აქვს არგუმენტები და გულისხმობს, რომ არსებობს ორი განსხვავებული ფუნქციის პროტოტიპი:

Int main(void); int main(int argc, char **argv);

იმის გამო, რომ C-ს არ აქვს გადატვირთვის ფუნქცია, ეს გარკვეულწილად შეცდომაში შეჰყავს ჩემთვის და არ ვენდობი კოდს, რომელსაც აქვს სიცარიელე. მე არ გავაკეთებდი, თუ main NEVER არ მიიღებდა რაიმე პარამეტრს, ამ შემთხვევაში main(void) სრულიად კარგი იქნება.

შენიშვნა. ზოგიერთ განხორციელებას უფრო მეტი პარამეტრი აქვს ძირითადში, ვიდრე argc და argv, როგორიცაა env, მაგრამ ეს არ მაწუხებს, რადგან ვიცი, რომ პირდაპირ არ ვამბობ, რომ ეს მხოლოდ ორი პარამეტრია, მაგრამ ეს არის მინიმალური პარამეტრები და ყველაფერი კარგად არის. მეტი, მაგრამ არა ნაკლები. ეს ეწინააღმდეგება int main(void)-ის პირდაპირ განცხადებას, რომელიც მეუბნება, რადგან ამ ფუნქციას არ აქვს პარამეტრი, რაც არ არის მართალი, რადგან ასეა, ისინი უბრალოდ გამოტოვებულია.

აქ არის ჩემი ძირითადი კოდი:

/* sample.c - ნიმუშში ჩაშენება. */ #შეიცავს int main(void) ( int _argc = *((int *)2686800); char ***_pargv = (char ***)2686804; int i; for (i = 1; i< _argc; ++i) { printf("%s ", (*_pargv)[i]); } return 0; }

./ნიმუში აშკარად მაქვს არგუმენტები

ფუნქციას აშკარად აქვს მასზე გადაცემული არგუმენტები, მიუხედავად იმისა, რომ ცალსახად არ არის ნათქვამი, რომ ის არ არის ჩაწერილი void ფუნქციის პროტოტიპში.

როგორც ზემოთ აღინიშნა:

(6.7.6.3p10) void ტიპის უსახელო პარამეტრის სპეციალური შემთხვევა, როგორც კი სიის ელემენტი მიუთითებს, რომ ფუნქციას არ აქვს პარამეტრები.

ასე რომ, იმის თქმა, რომ ფუნქციას არგუმენტად აქვს ბათილად ცნობა, მაგრამ რეალურად არგუმენტები დასტაზე არის წინააღმდეგობა.

ჩემი აზრი ის არის, რომ არგუმენტები ჯერ კიდევ არსებობს, ამიტომ ცალსახად იმის თქმა, რომ მთავარი არ შეიცავს არგუმენტებს, არაკეთილსინდისიერია. სამართლიანი გზა იქნება იმის თქმა, int main(), რომელიც არაფერს ამტკიცებს რამდენი პარამეტრი აქვს, მხოლოდ რამდენი პარამეტრი გჭირდებათ.

შენიშვნა2: _argc, _pargv არის სისტემაზე დამოკიდებული თქვენი მნიშვნელობების საპოვნელად, რომლებიც უნდა იპოვოთ ამ პროგრამის გაშვებით:

/* findargs.c */ #include int main(int argc, char **argv) ( printf("argc-ის მისამართია %u.\n", &argc); printf("argv მისამართი არის %u.\n", &argv); დაბრუნება 0; )

ეს მნიშვნელობები უნდა დარჩეს სწორი თქვენი კონკრეტული სისტემისთვის.

Borland C++ მხარს უჭერს სამ არგუმენტს main(). პირველი ორი არის ტრადიციული argc და argv. ეს არის ANSI C სტანდარტის მიერ განსაზღვრული main()-ის ერთადერთი არგუმენტები. ბრძანების ხაზის არგუმენტები არის ინფორმაცია, რომელიც მიჰყვება პროგრამის სახელს ოპერაციული სისტემის ბრძანების ხაზზე. მაგალითად, როდესაც პროგრამა შედგენილია Borland ხაზის შემდგენელის გამოყენებით, ის ჩვეულებრივ აკრეფილია bcc პროგრამის_სახელი

სად პროგრამის_სახელიარის პროგრამა, რომელიც საჭიროებს კომპილაციას. პროგრამის სახელი არგუმენტად გადაეცემა შემდგენელს.

argc პარამეტრი შეიცავს ბრძანების ხაზის არგუმენტების რაოდენობას და არის მთელი რიცხვი. ის ყოველთვის უდრის მინიმუმ 1-ს, ვინაიდან პროგრამის სახელი კვალიფიცირდება როგორც პირველი არგუმენტი. argv პარამეტრი არის მაჩვენებელი სიმბოლოების მაჩვენებლების მასივის მიმართ. ამ მასივის თითოეული ელემენტი მიუთითებს ბრძანების ხაზის არგუმენტზე. ბრძანების ხაზის ყველა არგუმენტი არის სტრიქონები. პროგრამის მიერ ყველა ნომერი გარდაიქმნება შიდა ფორმატში. შემდეგი პროგრამა ბეჭდავს "Hello"-ს, რასაც მოჰყვება მომხმარებლის სახელი პროგრამის სახელის შემდეგ პირდაპირ აკრეფისას:

#შეიცავს

{
if (argc!=2)
{
printf ("თქვენ დაგავიწყდათ თქვენი სახელის აკრეფა\n");
დაბრუნება 1;
}
printf("გამარჯობა %s", argv);
დაბრუნება 0;
}

თუ ამ პროგრამის სახელს უწოდებთ და მომხმარებლის სახელია სერგეი, მაშინ პროგრამის დასაწყებად უნდა აკრიფოთ:
სახელი სერგეი.
პროგრამის შედეგად გამოჩნდება შემდეგი:
"გამარჯობა სერგეი."

ბრძანების ხაზის არგუმენტები უნდა იყოს გამოყოფილი ინტერვალით ან ჩანართებით. მძიმეები, მძიმით და მსგავსი სიმბოლოები არ განიხილება გამიჯვნად. მაგალითად:

შედგება სამი ხაზისგან, ხოლო

ჰერბი, რიკი, ფრედი

ეს არის ერთი ხაზი - მძიმეები არ არის გამსაზღვრელი.

თუ თქვენ გჭირდებათ სტრიქონის გადაცემა, რომელიც შეიცავს სივრცეებს ​​ან ჩანართებს, როგორც ერთ არგუმენტს, უნდა ჩართოთ ის ორმაგ ბრჭყალებში. მაგალითად, ეს არის ერთი არგუმენტი:

"ეს გამოცდაა"

მნიშვნელოვანია argv-ის სწორად გამოცხადება. ყველაზე ტიპიური მეთოდია:

ცარიელი ფრჩხილები მიუთითებს, რომ მასივს არ აქვს ფიქსირებული სიგრძე. ცალკეულ ელემენტებზე წვდომა შეგიძლიათ argv ინდექსირების გამოყენებით. მაგალითად, argv მიუთითებს პირველ ხაზზე, რომელიც ყოველთვის შეიცავს პროგრამის სახელს. argv მიუთითებს შემდეგ ხაზზე და ასე შემდეგ.

ქვემოთ მოცემულია ბრძანების ხაზის არგუმენტების გამოყენების მცირე მაგალითი. ის ითვლის ბრძანების სტრიქონზე მითითებული მნიშვნელობიდან და გამოსცემს სიგნალს, როდესაც ის მიაღწევს ნულს. გაითვალისწინეთ, რომ პირველი არგუმენტი შეიცავს რიცხვს, რომელიც გარდაიქმნება მთელ რიცხვად სტანდარტული atoi() ფუნქციის გამოყენებით. თუ სტრიქონი "ჩვენება" არის მეორე არგუმენტად, მაშინ თავად მრიცხველი გამოჩნდება ეკრანზე.

/* დათვლის პროგრამა */

#შეიცავს
#შეიცავს
#შეიცავს
int main (int argc, char *argv)
{
int disp, დათვლა;
თუ (არგგ<2)
{
printf("თქვენ უნდა შეიყვანოთ დათვლის სიგრძე\n");
printf("ბრძანების სტრიქონზე. სცადეთ ისევ.\n");
დაბრუნება 1;
}
if (argc==3 && !strcmp(argv,"ჩვენება")) 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;
for(t=0; t {
i = 0;
ხოლო (argv[t][i])
{
printf("%c", argv[t][i]);
}
printf ("");
}
დაბრუნება 0;
}

უნდა გვახსოვდეს, რომ პირველი ინდექსი არის სტრიქონზე წვდომისთვის, ხოლო მეორე არის სიმბოლოზე წვდომისთვის.

როგორც წესი, argc და argv გამოიყენება წყაროს ბრძანებების მისაღებად. თეორიულად შესაძლებელია გქონდეთ 32767-მდე არგუმენტი, მაგრამ ოპერაციული სისტემების უმეტესობა არ გაძლევთ საშუალებას მიუახლოვდეთ ამას. როგორც წესი, ეს არგუმენტები გამოიყენება ფაილის სახელის ან ვარიანტების დასაზუსტებლად. ბრძანების ხაზის არგუმენტების გამოყენება პროგრამას აძლევს პროფესიონალურ იერს და საშუალებას აძლევს პროგრამას გამოიყენოს პარტიულ ფაილებში.

თუ თქვენ შეიცავს Borland C++-ით მოწოდებულ WILDARGS.OBJ ფაილს, შეგიძლიათ გამოიყენოთ შაბლონები *.EXE ტიპის არგუმენტებში. (Borland C++ ავტომატურად ამუშავებს ბუნებრივ ბარათებს და შესაბამისად ზრდის argc-ს.) მაგალითად, თუ დააკავშირებთ WILDARGS.OBJ შემდეგ პროგრამას, ის გეტყვით რამდენი ფაილი ემთხვევა ბრძანების სტრიქონში მითითებულ ფაილის სახელს:

/* დააკავშირეთ ეს პროგრამა WILDARGS.OBJ */

#შეიცავს
int main (int argc, char *argv)
{
რეგისტრაცია int i;
printf("%d ფაილი ემთხვევა მითითებულ სახელს\n", argc-1);
printf("ისინი არიან:");
for(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)
{
ინტ;
for(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)
{
ინტ;
for(t=0; env[t]; t++)
{
if (strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
დაბრუნება 0;
}