อาร์กิวเมนต์ของฟังก์ชัน main c visual studio Main() อาร์กิวเมนต์ของฟังก์ชัน

อาร์กิวเมนต์ทางเลือกและชื่อ

อาร์กิวเมนต์ทางเลือก

C# 4.0 แนะนำคุณสมบัติใหม่ที่ปรับปรุงความสะดวกในการระบุอาร์กิวเมนต์เมื่อเรียกใช้เมธอด เครื่องมือนี้เรียกว่า อาร์กิวเมนต์ทางเลือกและอนุญาตให้คุณกำหนดค่าเริ่มต้นสำหรับพารามิเตอร์เมธอด ค่านี้จะถูกใช้เป็นค่าเริ่มต้นหากไม่มีการระบุอาร์กิวเมนต์ที่เกี่ยวข้องสำหรับพารามิเตอร์เมื่อเรียกใช้เมธอด ดังนั้นจึงไม่จำเป็นต้องระบุอาร์กิวเมนต์สำหรับพารามิเตอร์ดังกล่าว อาร์กิวเมนต์ทางเลือกช่วยให้เรียกเมธอดได้ง่ายขึ้น โดยอาร์กิวเมนต์เริ่มต้นจะถูกนำไปใช้กับพารามิเตอร์บางตัว นอกจากนี้ยังสามารถใช้เป็นรูปแบบ "สั้น" ของวิธีการโอเวอร์โหลด

แรงผลักดันหลักสำหรับการเพิ่มอาร์กิวเมนต์ทางเลือกคือความจำเป็นในการทำให้การโต้ตอบกับวัตถุ COM ง่ายขึ้น ในรูปแบบวัตถุของ Microsoft หลายรุ่น (ตัวอย่างเช่น ไมโครซอฟต์ออฟฟิศ) มีฟังก์ชันการทำงานผ่านออบเจกต์ COM ซึ่งหลายรายการเขียนขึ้นเมื่อนานมาแล้วและได้รับการออกแบบให้ใช้พารามิเตอร์ทางเลือก

ตัวอย่างของการใช้อาร์กิวเมนต์ทางเลือกแสดงอยู่ด้านล่าง:

ใช้ระบบ; ใช้ System.Collections.Generic; ใช้ System.Linq; ใช้ System.Text; เนมสเปซ ConsoleApplication1 ( โปรแกรมคลาส ( // อาร์กิวเมนต์ b และ c เป็นทางเลือกเมื่อเรียกสแตติก int mySum(int a, int b = 5, int c = 10) ( คืนค่า a + b + c; ) โมฆะคงที่ Main() ( int sum1 = mySum(3); int sum2 = mySum(3,12); Console.WriteLine("Sum1 = "+sum1); Console.WriteLine("Sum2 = "+sum2); Console.ReadLine(); ) ) )

โปรดทราบว่าอาร์กิวเมนต์ทางเลือกทั้งหมดจำเป็นต้องระบุทางด้านขวาของอาร์กิวเมนต์ที่จำเป็น นอกเหนือจากเมธอดแล้ว อาร์กิวเมนต์ทางเลือกสามารถใช้ในตัวสร้าง ตัวสร้างดัชนี และผู้รับมอบสิทธิ์

ข้อดีอย่างหนึ่งของอาร์กิวเมนต์ทางเลือกคือทำให้โปรแกรมเมอร์สามารถจัดการกับเมธอดที่ซับซ้อนและการเรียกคอนสตรัคเตอร์ได้ง่ายขึ้น ท้ายที่สุด บ่อยครั้งจำเป็นต้องตั้งค่าพารามิเตอร์ในเมธอดมากกว่าที่จำเป็น และในกรณีเช่นนี้ พารามิเตอร์เหล่านี้บางส่วนสามารถกำหนดให้เป็นทางเลือกได้โดยใช้อาร์กิวเมนต์ทางเลือกอย่างระมัดระวัง ซึ่งหมายความว่าคุณจะต้องผ่านการโต้แย้งที่สำคัญในที่กำหนด กรณีเฉพาะไม่ใช่อาร์กิวเมนต์ทั้งหมด ซึ่งควรเป็นอย่างอื่น วิธีการนี้ช่วยให้เราสามารถหาเหตุผลเข้าข้างตนเองของวิธีการและทำให้โปรแกรมเมอร์จัดการกับมันได้ง่ายขึ้น

อาร์กิวเมนต์ที่มีชื่อ

อีกหนึ่ง ฟังก์ชันการทำงานซึ่งถูกเพิ่มเข้ามาใน C# ด้วยการเปิดตัว .NET 4.0 ซึ่งรองรับสิ่งที่เรียกว่า ชื่ออาร์กิวเมนต์. อย่างที่คุณทราบ เมื่อส่งอาร์กิวเมนต์ไปยังเมธอด ลำดับที่อาร์กิวเมนต์นั้นปรากฏตามกฎ จะต้องตรงกับลำดับที่กำหนดพารามิเตอร์ในเมธอดเอง กล่าวอีกนัยหนึ่ง ค่าอาร์กิวเมนต์ถูกกำหนดให้กับพารามิเตอร์ตามตำแหน่งในรายการอาร์กิวเมนต์

อาร์กิวเมนต์ที่มีชื่อออกแบบมาเพื่อเอาชนะข้อจำกัดนี้ อาร์กิวเมนต์ที่มีชื่อช่วยให้คุณสามารถระบุชื่อของพารามิเตอร์ที่กำหนดค่าให้ และในกรณีนี้ ลำดับของการโต้แย้งจะไม่มีความสำคัญอีกต่อไป ดังนั้น อาร์กิวเมนต์ที่มีชื่อจะค่อนข้างคล้ายกับตัวเริ่มต้นของวัตถุที่กล่าวถึงก่อนหน้านี้ แม้ว่าจะแตกต่างจากพวกเขาในไวยากรณ์ก็ตาม หากต้องการระบุอาร์กิวเมนต์ตามชื่อ ให้ใช้รูปแบบไวยากรณ์ต่อไปนี้:

Parameter_name: ค่า

ที่นี่ Parameter_nameหมายถึงชื่อของพารามิเตอร์ที่ส่งผ่านค่า แน่นอนว่า Parameter_name ต้องเป็นชื่อของพารามิเตอร์ที่ถูกต้องสำหรับเมธอดที่เรียกใช้

มันเกิดขึ้นเมื่อข้อมูลถูกถ่ายโอนไปยังโปรแกรมจากบรรทัดคำสั่งเมื่อมีการเรียกใช้ ข้อมูลดังกล่าวเรียกว่าอาร์กิวเมนต์บรรทัดคำสั่ง ดูเหมือนว่านี้ ตัวอย่างเช่น:

./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() นี่เป็นการพิสูจน์ว่าฟังก์ชันเริ่มต้นส่งคืนจำนวนเต็มไม่ใช่ค่าใด (โมฆะ) แม้ว่าสิ่งที่ฟังก์ชันส่งคืนสามารถ "แทนที่" ได้เสมอ ตัวอย่างเช่น 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, ถ่าน * arr)

ตัวแปรตัวแรก (n) มีจำนวนคำ และตัวแปรตัวที่สองมีตัวชี้ไปยังอาร์เรย์ของสตริง บ่อยครั้งที่พารามิเตอร์ตัวที่สองเขียนเป็น **arr อย่างไรก็ตาม มันก็เหมือนกัน จำได้ว่าอาร์เรย์ของสตริงนั้นมีตัวชี้ไปยังสตริงเป็นองค์ประกอบ และในฟังก์ชัน เราจะส่งตัวชี้ไปยังองค์ประกอบแรกของอาร์เรย์ ปรากฎว่าเรากำลังส่งตัวชี้ไปยังตัวชี้เช่น **อาร์

ออกกำลังกาย
เขียนโปรแกรมดังนี้

#รวม int main(int argc, ถ่าน ** argv) ( int i; printf ("%d \n", หาเรื่อง) ; สำหรับ (i= 0 ; i< argc; i++ ) puts (argv[ i] ) ; }

มันพิมพ์จำนวนคำบนบรรทัดคำสั่งเมื่อมีการเรียกใช้ และแต่ละคำด้วย บรรทัดใหม่. เรียกว่าไม่มีอาร์กิวเมนต์บรรทัดคำสั่งและมีข้อโต้แย้ง

ในโปรแกรม เราใช้ตัวแปรพารามิเตอร์ argc และ argv เป็นเรื่องปกติที่จะใช้ชื่อดังกล่าว แต่ในความเป็นจริงพวกเขาสามารถเป็นอะไรก็ได้ เป็นการดีกว่าที่จะปฏิบัติตามมาตรฐานนี้เพื่อให้โปรแกรมของคุณเข้าใจได้มากขึ้น ไม่เพียงสำหรับคุณเท่านั้น แต่ยังรวมถึงโปรแกรมเมอร์คนอื่นๆ ด้วย

ความสำคัญในทางปฏิบัติของการส่งข้อมูลไปยังโปรแกรม

หากคุณมีประสบการณ์เกี่ยวกับบรรทัดคำสั่ง GNU/Linux คุณจะรู้ว่าคำสั่งส่วนใหญ่มีสวิตช์และอาร์กิวเมนต์ ตัวอย่างเช่น เมื่อดูเนื้อหาของไดเร็กทอรี การคัดลอก การย้าย วัตถุจะถูกระบุเป็นอาร์กิวเมนต์ ระบบไฟล์ที่ดำเนินการคำสั่ง คุณสมบัติของการใช้งานถูกกำหนดโดยใช้ปุ่ม เช่น ในคำสั่ง

Cp -r ../les_1 ../les_101

cp คือชื่อของคำสั่ง -r คือสวิตช์ และ ../les_1 และ ../les_101 คืออาร์กิวเมนต์ของคำสั่ง

โดยทั่วไป บ่อยครั้งเมื่อเปิดโปรแกรม ที่อยู่ไฟล์และ "ตัวดัดแปลง" (ซึ่งเป็นคีย์) ของกระบวนการดำเนินการโปรแกรมจะถูกถ่ายโอน

มาเขียนโปรแกรมที่เปิดไฟล์ที่ระบุโดยผู้ใช้ในบรรทัดคำสั่งเพื่อเขียนหรือต่อท้ายและเขียน (เพิ่ม) ข้อมูลเดียวกันกับที่ผู้ใช้ป้อนจากแป้นพิมพ์ระหว่างการทำงานของโปรแกรม:

#รวม #รวม main (int argc, ถ่าน ** 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[ ผม+ 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 (จริง) ฟังก์ชัน strcmp() ช่วยให้คุณเปรียบเทียบสตริงและส่งกลับ 0 หากสตริงเท่ากัน
4. ใน สำหรับลูปไฟล์ถูกเปิดตามที่อยู่ที่ระบุซึ่งเริ่มต้นด้วยองค์ประกอบที่สามของอาร์เรย์ argv นั่นคือสาเหตุที่เพิ่ม 2 ให้กับ i เพื่อรับองค์ประกอบของอาร์เรย์ argv โดยเริ่มจากองค์ประกอบที่สาม นิพจน์ argc-2 ระบุจำนวนชื่อไฟล์ที่ส่งผ่าน เพราะ argc เก็บจำนวนอาร์กิวเมนต์บรรทัดคำสั่งทั้งหมด โดยสองรายการแรกไม่ใช่ชื่อไฟล์
5. นิพจน์ argv+1 อนุญาตให้คุณ "ตัด" สตริงย่อย "w" (หรือ "a") จากสตริง "-w" (หรือ "-a") เนื่องจาก argv เป็นตัวชี้ไปยังองค์ประกอบแรกของสตริง โดยการเพิ่มตัวชี้ เราจะเลื่อนไปยังองค์ประกอบถัดไปในอาร์เรย์
6. หากไม่สามารถเปิดไฟล์ได้ ฟังก์ชัน fopen() จะคืนค่า NULL ในกรณีนี้โปรแกรมจะสิ้นสุดลง
7. อักขระแต่ละตัวที่ป้อนโดยผู้ใช้จากแป้นพิมพ์จะถูกเขียนลงในไฟล์ที่เปิดอยู่ทั้งหมด
8. ในตอนท้ายไฟล์จะถูกปิด

เมื่อสร้างคอนโซลแอปพลิเคชันโดยอัตโนมัติในภาษาโปรแกรม C++ ฟังก์ชันหลักจะถูกสร้างขึ้นโดยอัตโนมัติซึ่งคล้ายกับฟังก์ชันนี้มาก:

int main(int argc, ถ่าน * argv)
{…}

ส่วนหัวของฟังก์ชันประกอบด้วยลายเซ็น ฟังก์ชั่นหลัก main() พร้อมอาร์กิวเมนต์ argc และ argv
หากโปรแกรมทำงานผ่านบรรทัดคำสั่ง จะสามารถถ่ายโอนข้อมูลใดๆ ไปยังโปรแกรมนี้ได้ มีอาร์กิวเมนต์บรรทัดคำสั่ง argc และ argv สำหรับสิ่งนี้
พารามิเตอร์ argc เป็นประเภท int และมีจำนวนพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชันหลัก นอกจากนี้ argc จะมีค่าอย่างน้อย 1 เสมอแม้ว่าจะไม่มีการส่งข้อมูลไปยังฟังก์ชันหลักก็ตาม เนื่องจากชื่อของแอปพลิเคชันถือเป็นพารามิเตอร์แรก
พารามิเตอร์ argv เป็นอาร์เรย์ของตัวชี้ไปยังสตริง เฉพาะข้อมูลประเภทสตริงเท่านั้นที่สามารถส่งผ่านบรรทัดคำสั่งได้

เมื่อเริ่มโปรแกรมผ่านคำสั่ง วินโดวส์ไลน์คุณสามารถส่งข้อมูลบางอย่างไปให้ ในกรณีนี้ บรรทัดคำสั่งจะมีลักษณะดังนี้:
ไดรฟ์:\path\name.exe argument1 argument2 ...

อาร์กิวเมนต์บรรทัดคำสั่งคั่นด้วยช่องว่างตั้งแต่หนึ่งช่องขึ้นไป

อาร์กิวเมนต์ argv มีชื่อแอปพลิเคชันแบบเต็ม:

#รวม
ใช้เนมสเปซ std;

ศาล<< argv << endl;

กลับ 0;
}

ผลการดำเนินการ

ตัวอย่าง : การคำนวณผลคูณของจำนวนเต็มสองจำนวน
โปรแกรมใช้สตริงเป็นฟังก์ชันการแปลงจำนวนเต็ม StrToInt() จากที่นี่

#รวม
ใช้เนมสเปซ std;
int StrToInt(ถ่าน*s) (...)
int หลัก (int argc, ถ่าน * argv) (

Int a = 0, b=0;

ถ้า (argc > 1)

a = StrToInt(argv);

ถ้า (argc > 2)

b = StrToInt(argv);

ศาล<< a <<«*» << b << «= « << a*b << endl;

กลับ 0;
}

โปรแกรมเปิดตัวเป็น

ผลการดำเนินการ

การดีบักโปรแกรมด้วยอาร์กิวเมนต์บรรทัดคำสั่ง

ในการส่งผ่านอาร์กิวเมนต์บรรทัดคำสั่งเมื่อทำการดีบักโปรแกรม คุณต้องเข้าถึงเมนู คุณสมบัติโครงการ.


บนแท็บ คุณสมบัติการกำหนดค่า -> ดีบักเลือก อาร์กิวเมนต์คำสั่งและตั้งค่าของพวกเขา

เมื่อคุณรันโปรแกรมในโหมดดีบัก อาร์กิวเมนต์ที่ป้อนจะถูกปฏิบัติโดยโปรแกรมเป็นอาร์กิวเมนต์บรรทัดคำสั่ง

บางครั้งเมื่อเริ่มต้นโปรแกรม การส่งข้อมูลบางอย่างไปยังโปรแกรมจะเป็นประโยชน์ โดยทั่วไป ข้อมูลนี้จะถูกส่งผ่านไปยังฟังก์ชัน main() ผ่านทางอาร์กิวเมนต์บรรทัดคำสั่ง อาร์กิวเมนต์บรรทัดคำสั่งเป็นข้อมูลที่ป้อนบนบรรทัดคำสั่งของระบบปฏิบัติการตามชื่อโปรแกรม ตัวอย่างเช่น ในการเริ่มคอมไพล์โปรแกรม คุณต้องพิมพ์ข้อความต่อไปนี้ในบรรทัดคำสั่งหลังข้อความแจ้ง:

ซีซี โปรแกรม_ชื่อ

โปรแกรม_ชื่อเป็นอาร์กิวเมนต์บรรทัดคำสั่งที่ระบุชื่อโปรแกรมที่คุณกำลังจะคอมไพล์

ในการยอมรับอาร์กิวเมนต์บรรทัดคำสั่ง จะใช้อาร์กิวเมนต์ในตัวพิเศษสองตัว: argc และ argv พารามิเตอร์ argc มีจำนวนอาร์กิวเมนต์บนบรรทัดคำสั่งและเป็นจำนวนเต็ม และมีอย่างน้อย 1 เสมอ เนื่องจากอาร์กิวเมนต์แรกคือชื่อของโปรแกรม และพารามิเตอร์ argv เป็นตัวชี้ไปยังอาร์เรย์ของตัวชี้ไปยังสตริง ในอาร์เรย์นี้ แต่ละองค์ประกอบจะชี้ไปที่อาร์กิวเมนต์บรรทัดคำสั่ง อาร์กิวเมนต์บรรทัดคำสั่งทั้งหมดเป็นสตริง ดังนั้นการแปลงตัวเลขใด ๆ ให้เป็นรูปแบบไบนารีที่ต้องการจะต้องมีอยู่ในโปรแกรมเมื่อมีการพัฒนา

นี่คือตัวอย่างง่ายๆ ของการใช้อาร์กิวเมนต์บรรทัดคำสั่ง หน้าจอจะแสดงคำว่า Hello และชื่อของคุณ ซึ่งจะต้องระบุเป็นอาร์กิวเมนต์บรรทัดคำสั่ง

#รวม #รวม int main(int argc, char *argv) ( if(argc!=2) ( printf("คุณลืมใส่ชื่อของคุณ\n"); exit(1); ) printf("สวัสดี %s", argv) ; กลับ 0; )

หากคุณตั้งชื่อโปรแกรมนี้ (ชื่อ) และชื่อของคุณคือ Tom หากต้องการรันโปรแกรม ให้ป้อนชื่อ Tom ที่บรรทัดคำสั่ง จากการรันโปรแกรม ข้อความ Hello, Tom จะปรากฏขึ้นบนหน้าจอ

ในหลายสภาพแวดล้อม อาร์กิวเมนต์บรรทัดคำสั่งทั้งหมดต้องแยกออกจากกันด้วยช่องว่างหรือแท็บ เครื่องหมายจุลภาค เครื่องหมายอัฒภาค และอักขระที่คล้ายกันไม่ถือเป็นตัวคั่น ตัวอย่างเช่น,

เรียกใช้สปอตเรียกใช้

ประกอบด้วยสตริงอักขระสามตัว ในขณะที่

เอริค, ริค, เฟร็ด

เป็นสตริงอักขระเดียว - โดยทั่วไปแล้วเครื่องหมายจุลภาคจะไม่ถือเป็นตัวคั่น

หากสตริงมีช่องว่าง ในบางสภาพแวดล้อม สตริงสามารถใส่เครื่องหมายอัญประกาศคู่เพื่อป้องกันไม่ให้สร้างอาร์กิวเมนต์หลายรายการได้ ดังนั้น สตริงทั้งหมดจะถูกพิจารณาเป็นหนึ่งอาร์กิวเมนต์ หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการตั้งค่าตัวเลือกบรรทัดคำสั่งบนระบบปฏิบัติการของคุณ โปรดดูเอกสารประกอบของระบบนั้น

การประกาศ argv อย่างถูกต้องเป็นสิ่งสำคัญมาก นี่คือวิธีที่พวกเขาทำบ่อยที่สุด:

ถ่าน *argv;

วงเล็บเหลี่ยมว่างแสดงว่าอาร์เรย์มีความยาวไม่จำกัด ขณะนี้คุณสามารถเข้าถึงแต่ละอาร์กิวเมนต์ได้โดยการจัดทำดัชนีอาร์เรย์ argv ตัวอย่างเช่น argv ชี้ไปที่สตริงอักขระตัวแรก ซึ่งเป็นชื่อโปรแกรมเสมอ argv ชี้ไปที่อาร์กิวเมนต์แรก และอื่นๆ

อีกตัวอย่างเล็กๆ ของการใช้อาร์กิวเมนต์บรรทัดคำสั่งคือโปรแกรมนับถอยหลังด้านล่าง โปรแกรมนี้นับถอยหลังจากค่าบางค่า (ระบุไว้ในบรรทัดคำสั่ง) และส่งเสียงบี๊บเมื่อถึง 0 โปรดทราบว่าอาร์กิวเมนต์แรกที่มีค่าเริ่มต้นจะถูกแปลงเป็นค่าจำนวนเต็มโดยใช้ฟังก์ชันมาตรฐาน atoi () หากอาร์กิวเมนต์ที่สองของบรรทัดคำสั่ง (และถ้าเราใช้ชื่อโปรแกรมเป็นอาร์กิวเมนต์ที่สาม) เป็นสตริง "แสดงผล" (ส่งออกไปยังหน้าจอ) ผลลัพธ์ของการนับถอยหลัง (ในลำดับย้อนกลับ) จะปรากฏขึ้น บนหน้าจอ.

/* โปรแกรมนับถอยหลัง */ #รวม #รวม #รวม #รวม int main(int argc, ถ่าน *argv) ( int disp, นับ; if(argc<2) { printf("В командной строке необходимо ввести число, с которого\n"); printf("начинается отсчет. Попробуйте снова.\n"); exit(1); } if(argc==3 && !strcmp(argv, "display")) disp = 1; else disp = 0; for(count=atoi(argv); count; --count) if(disp) printf("%d\n", count); putchar("\a"); /* здесь подается звуковой сигнал */ printf("Счет закончен"); return 0; }

โปรดทราบว่าหากไม่ได้ระบุอาร์กิวเมนต์บรรทัดคำสั่ง ข้อความแสดงข้อผิดพลาดจะแสดงขึ้น โปรแกรมที่มีอาร์กิวเมนต์บรรทัดคำสั่งมักจะทำสิ่งต่อไปนี้: เมื่อผู้ใช้รันโปรแกรมเหล่านี้โดยไม่ป้อนข้อมูลที่จำเป็น คำแนะนำจะแสดงวิธีระบุอาร์กิวเมนต์อย่างถูกต้อง

หากต้องการเข้าถึงอักขระตัวเดียวในอาร์กิวเมนต์บรรทัดคำสั่ง ให้ป้อนดัชนีตัวที่สองลงใน argv ตัวอย่างเช่น โปรแกรมต่อไปนี้พิมพ์อาร์กิวเมนต์ทั้งหมดที่ถูกเรียกใช้แบบอักขระต่ออักขระ:

#รวม int main(int argc, ถ่าน *argv) ( int t, i; for(t=0; t

โปรดจำไว้ว่าดัชนีแรกของ argv ให้การเข้าถึงสตริง และดัชนีที่สองให้การเข้าถึงอักขระแต่ละตัว

โดยปกติแล้ว argc และ argv จะใช้เพื่อส่งคำสั่งเริ่มต้นไปยังโปรแกรมที่จำเป็นเมื่อเริ่มทำงาน ตัวอย่างเช่น อาร์กิวเมนต์บรรทัดคำสั่งมักจะระบุข้อมูล เช่น ชื่อไฟล์ ตัวเลือก หรือลักษณะการทำงานอื่น การใช้อาร์กิวเมนต์บรรทัดคำสั่งทำให้โปรแกรมของคุณ "ดูเป็นมืออาชีพ" และทำให้ใช้งานในแบตช์ไฟล์ได้ง่ายขึ้น

ชื่อ argc และ argv เป็นชื่อดั้งเดิมแต่ไม่จำเป็น คุณสามารถตั้งชื่อพารามิเตอร์ทั้งสองนี้ในฟังก์ชัน main() ได้ตามต้องการ นอกจากนี้ คอมไพเลอร์บางตัวอาจสนับสนุน - ข้อโต้แย้งเพิ่มเติมสำหรับ main() ดังนั้น โปรดตรวจสอบเอกสารประกอบสำหรับคอมไพเลอร์ของคุณ

เมื่อโปรแกรมไม่ต้องการพารามิเตอร์บรรทัดคำสั่ง เป็นเรื่องธรรมดาที่สุดที่จะประกาศฟังก์ชัน main() อย่างชัดเจนว่าไม่มีพารามิเตอร์ ในกรณีนี้ จะใช้คีย์เวิร์ด void ในรายการพารามิเตอร์ของฟังก์ชันนี้

Borland C++ รองรับสามอาร์กิวเมนต์ main() สองอันแรกคือ argc และ argv แบบดั้งเดิม นี่เป็นอาร์กิวเมนต์เดียวของฟังก์ชัน main() ที่กำหนดโดยมาตรฐาน ANSI C พวกเขาอนุญาตให้ส่งอาร์กิวเมนต์บรรทัดคำสั่งไปยังโปรแกรม อาร์กิวเมนต์บรรทัดคำสั่งคือข้อมูลที่ตามหลังชื่อโปรแกรมบนบรรทัดคำสั่งของระบบปฏิบัติการ ตัวอย่างเช่น เมื่อโปรแกรมถูกคอมไพล์ด้วยคอมไพเลอร์แบบอินไลน์ของ Borland โดยทั่วไปแล้ว bcc จะถูกพิมพ์ โปรแกรม_ชื่อ

ที่ไหน โปรแกรม_ชื่อเป็นโปรแกรมที่จะคอมไพล์ ชื่อโปรแกรมจะถูกส่งผ่านไปยังคอมไพเลอร์เป็นอาร์กิวเมนต์

พารามิเตอร์ argc มีจำนวนอาร์กิวเมนต์บรรทัดคำสั่งและเป็นจำนวนเต็ม เป็นอย่างน้อย 1 เสมอ เนื่องจากชื่อโปรแกรมมีคุณสมบัติเป็นอาร์กิวเมนต์แรก พารามิเตอร์ argv เป็นตัวชี้ไปยังอาร์เรย์ของตัวชี้อักขระ แต่ละองค์ประกอบของอาร์เรย์นี้ชี้ไปที่อาร์กิวเมนต์บรรทัดคำสั่ง อาร์กิวเมนต์บรรทัดคำสั่งทั้งหมดเป็นสตริง โปรแกรมแปลงตัวเลขทั้งหมดเป็นรูปแบบภายใน โปรแกรมต่อไปนี้จะพิมพ์ "Hello" ตามด้วยชื่อผู้ใช้ หากพิมพ์ต่อจากชื่อโปรแกรม:

#รวม

{
ถ้า(argc!=2)
{
printf("คุณลืมพิมพ์ชื่อ\n");
กลับ 1;
}
printf("สวัสดี %s", argv);
กลับ 0;
}

หากคุณเรียกชื่อโปรแกรมนี้ และชื่อผู้ใช้คือ Sergey ดังนั้นในการรันโปรแกรม คุณควรพิมพ์:
ชื่อเซอร์เกย์
ผลลัพธ์ของโปรแกรมจะปรากฏขึ้น:
สวัสดีเซอร์เกย์

อาร์กิวเมนต์บรรทัดคำสั่งต้องคั่นด้วยช่องว่างหรือแท็บ เครื่องหมายจุลภาค เครื่องหมายอัฒภาค และอักขระที่คล้ายกันไม่ถือเป็นตัวคั่น ตัวอย่างเช่น:

ประกอบด้วยสามบรรทัดในขณะที่

เฮิร์บ,ริค,เฟร็ด

นี่คือหนึ่งบรรทัด - เครื่องหมายจุลภาคไม่ใช่ตัวคั่น

หากคุณต้องการส่งสตริงที่มีช่องว่างหรือแท็บเป็นอาร์กิวเมนต์เดียว ให้ใส่เครื่องหมายคำพูดคู่ ตัวอย่างเช่น นี่เป็นอาร์กิวเมนต์หนึ่ง:

"นี่คือการทดสอบ"

สิ่งสำคัญคือต้องประกาศ argv ให้ถูกต้อง วิธีทั่วไปที่สุดคือ:

วงเล็บว่างระบุว่าอาร์เรย์ไม่มีความยาวคงที่ คุณสามารถเข้าถึงแต่ละองค์ประกอบโดยใช้การจัดทำดัชนี argv ตัวอย่างเช่น argv ชี้ไปที่บรรทัดแรกซึ่งมีชื่อโปรแกรมเสมอ argv ชี้ไปที่บรรทัดถัดไป และอื่นๆ

ด้านล่างนี้คือตัวอย่างเล็กๆ ของการใช้อาร์กิวเมนต์บรรทัดคำสั่ง โดยจะนับถอยหลังจากค่าที่ระบุในบรรทัดคำสั่งและส่งสัญญาณเมื่อถึงศูนย์ โปรดทราบว่าอาร์กิวเมนต์แรกประกอบด้วยตัวเลขที่แปลงเป็นจำนวนเต็มโดยใช้ฟังก์ชันมาตรฐาน atoi() หากสตริง "display" แสดงเป็นอาร์กิวเมนต์ที่สอง ตัวนับจะแสดงบนหน้าจอ

/* โปรแกรมนับ */

#รวม
#รวม
#รวม
int หลัก (int argc, ถ่าน * argv)
{
int disp, นับ;
ถ้า (argc<2)
{
printf("คุณต้องป้อนความยาวของจำนวน\n");
printf("ในบรรทัดคำสั่ง ลองใหม่อีกครั้ง\n");
กลับ 1;
}
ถ้า (argc==3 && !srcmp(argv,"display")) disp = 1;
อื่น disp = 0;
สำหรับ (นับ = atoi (argv); นับ; - นับ)
ถ้า (แสดง) printf("%d", นับ);
printf("%c", "\a"); /* ในคอมพิวเตอร์ส่วนใหญ่จะเป็นการโทร */
กลับ 0;
}

โปรดทราบว่าหากไม่มีการระบุอาร์กิวเมนต์ ข้อความแสดงข้อผิดพลาดจะปรากฏขึ้น นี่เป็นเรื่องปกติที่สุดของโปรแกรมที่ใช้อาร์กิวเมนต์บรรทัดคำสั่งเพื่อออกคำสั่งหากมีการพยายามเรียกใช้โปรแกรมโดยไม่มีข้อมูลที่ถูกต้อง

ในการเข้าถึงอักขระบรรทัดคำสั่งแต่ละตัว ให้เพิ่มดัชนีที่สองใน argv ตัวอย่างเช่น โปรแกรมต่อไปนี้จะพิมพ์อาร์กิวเมนต์ทั้งหมดที่ถูกเรียกด้วยอักขระทีละตัว:

#รวม
int หลัก (int argc, ถ่าน * argv)
{
int t, ฉัน;
สำหรับ (t=0; t {
ฉัน = 0;
ในขณะที่(argv[t][i])
{
printf("%c", argv[t][i]);
}
พิมพ์f(");
}
กลับ 0;
}

ต้องจำไว้ว่าดัชนีแรกมีไว้สำหรับเข้าถึงสตริง และดัชนีที่สองมีไว้สำหรับเข้าถึงอักขระของสตริง

โดยทั่วไปจะใช้ argc และ argv เพื่อรับคำสั่งซอร์ส ในทางทฤษฎี คุณสามารถมีอาร์กิวเมนต์ได้มากถึง 32,767 อาร์กิวเมนต์ แต่ระบบปฏิบัติการส่วนใหญ่ไม่อนุญาตให้คุณเข้าใกล้อาร์กิวเมนต์นั้นด้วยซ้ำ โดยทั่วไป อาร์กิวเมนต์เหล่านี้ใช้เพื่อระบุชื่อไฟล์หรือตัวเลือก การใช้อาร์กิวเมนต์บรรทัดคำสั่งทำให้โปรแกรมดูเป็นมืออาชีพและอนุญาตให้ใช้โปรแกรมในแบตช์ไฟล์

หากคุณรวมไฟล์ WILDARGS.OBJ ที่มาพร้อมกับ Borland C++ คุณสามารถใช้สัญลักษณ์แทนในอาร์กิวเมนต์ประเภท *.EXE (Borland C++ จัดการรูปแบบโดยอัตโนมัติและเพิ่ม argc ตามนั้น) ตัวอย่างเช่น หากคุณเชื่อมต่อ WILDARGS.OBJ กับโปรแกรมต่อไปนี้ โปรแกรมจะพิมพ์จำนวนไฟล์ที่ตรงกับชื่อไฟล์ที่ระบุในบรรทัดคำสั่ง:

/* เชื่อมโยงโปรแกรมนี้กับ WILDARGS.OBJ */

#รวม
int หลัก (int argc, ถ่าน * argv)
{
ลงทะเบียน int ฉัน;
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, ถ่าน *argv, ถ่าน *env)
{
int เสื้อ;
สำหรับ (t=0; env[t]/ t++)
printf("%s\n", env[t]);
กลับ 0;
}

โปรดทราบว่าแม้ว่าโปรแกรมจะไม่ใช้ argc และ argv แต่จะต้องมีอยู่ในรายการพารามิเตอร์ C ไม่ทราบชื่อพารามิเตอร์ การใช้งานจะถูกกำหนดตามลำดับการประกาศพารามิเตอร์แทน อันที่จริง คุณสามารถเรียกพารามิเตอร์อะไรก็ได้ที่คุณต้องการ เนื่องจาก argc, argv และ env เป็นชื่อดั้งเดิม ควรใช้ต่อไปเพื่อให้ทุกคนที่อ่านโปรแกรมสามารถรับรู้ได้ทันทีว่าสิ่งเหล่านี้เป็นอาร์กิวเมนต์ของฟังก์ชัน main()

สำหรับโปรแกรม งานทั่วไปคือการค้นหาค่าที่กำหนดในสตริงสภาพแวดล้อม ตัวอย่างเช่น เนื้อหาของสตริง PATH อนุญาตให้โปรแกรมใช้เส้นทางการค้นหา โปรแกรมต่อไปนี้สาธิตวิธีค้นหาสตริงที่ประกาศเส้นทางการค้นหามาตรฐาน ใช้ฟังก์ชันไลบรารีมาตรฐาน strstr() ซึ่งมีต้นแบบดังต่อไปนี้:

ถ่าน *strstr(const ถ่าน *str1, const ถ่าน *str2);

ฟังก์ชัน strstr() ค้นหาสตริงที่ชี้โดย str1 ในสตริงที่ชี้โดย str2 หากพบสตริงดังกล่าว ตัวชี้ไปยังตำแหน่งแรกจะถูกส่งกลับ หากไม่พบรายการที่ตรงกัน ฟังก์ชันจะคืนค่า NULL

/* โปรแกรมค้นหาสตริงสภาพแวดล้อมเพื่อหาสตริงที่มี PATH */

#รวม
#รวม
int main (int argc, ถ่าน *argv, ถ่าน *env)
{
int เสื้อ;
สำหรับ (t=0; env[t]; t++)
{
ถ้า (strstr (env [t], "เส้นทาง"))
printf("%s\n", env[t]);
}
กลับ 0;
}