ลักษณะทั่วไปค. คำอธิบายฟังก์ชัน Scanf C

บทความนี้กล่าวถึงฟังก์ชัน scanf() ใน ปริทัศน์โดยไม่มีการอ้างอิงถึงมาตรฐานเฉพาะ ดังนั้น ข้อมูลจากมาตรฐาน C99, C11, C++11, C++14 ใดๆ จึงรวมไว้ที่นี่ บางที ในบางมาตรฐาน ฟังก์ชันอาจทำงานแตกต่างจากเนื้อหาที่นำเสนอในบทความ

ฟังก์ชัน scanf C - คำอธิบาย

scanf() เป็นฟังก์ชันที่อยู่ในไฟล์ส่วนหัว stdio.h(C) และ cstdio(C++) หรือที่เรียกว่าอินพุตโปรแกรมที่จัดรูปแบบ scanf อ่านอักขระจากสตรีมอินพุตมาตรฐาน (stdin) และแปลงอักขระตามรูปแบบ จากนั้นเขียนอักขระเหล่านั้นลงในตัวแปรที่ระบุ รูปแบบ - หมายความว่าข้อมูลจะถูกแปลงเป็นรูปแบบเฉพาะเมื่อได้รับ ดังนั้นฟังก์ชัน scanf C จึงอธิบายไว้ดังนี้

scanf("%รูปแบบ", &variable1[, &variable2,[...]]),

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

โปรแกรมเมอร์บางคนอ้างถึงฟังก์ชันอย่าง scanf() หรือ printf() เป็นโพรซีเดอร์เนื่องจากมีความคล้ายคลึงกับภาษาอื่น

Scanf ให้คุณป้อนภาษาพื้นฐานทุกประเภท: char, int, float, string เป็นต้น ในกรณีของตัวแปรประเภทสตริง ไม่จำเป็นต้องระบุเครื่องหมายที่อยู่ - "&" เนื่องจากตัวแปรประเภทสตริงคืออาร์เรย์ และชื่อของตัวแปรคือแอดเดรสขององค์ประกอบแรกของอาร์เรย์ในหน่วยความจำของคอมพิวเตอร์ .

รูปแบบการป้อนข้อมูลหรือสตริงควบคุม

เริ่มต้นด้วยการดูตัวอย่างการใช้ฟังก์ชัน scanf C จากคำอธิบาย

#รวม int main() ( int x; while (scanf("%d", &x) == 1) printf("%d\n", x); return 0; //requirement for linux system )

รูปแบบการป้อนข้อมูลประกอบด้วยสี่พารามิเตอร์ต่อไปนี้: ประเภท %[*][width][modifiers] ในกรณีนี้ เครื่องหมาย "%" และประเภทเป็นพารามิเตอร์บังคับ นั่นคือ รูปแบบขั้นต่ำของรูปแบบจะมีลักษณะดังนี้: “%s”, “%d” และอื่นๆ

โดยทั่วไป อักขระที่ประกอบกันเป็นสตริงรูปแบบจะแบ่งออกเป็น:

ตัวระบุรูปแบบ - ทุกอย่างที่ขึ้นต้นด้วยอักขระ %;
ตัวคั่นหรืออักขระช่องว่าง - พวกมันคือช่องว่าง แท็บ (\t) ขึ้นบรรทัดใหม่ (\n);
อักขระอื่นที่ไม่ใช่ช่องว่าง

ฟังก์ชันอาจไม่ปลอดภัย
ใช้ฟังก์ชัน scanf_s() แทน scanf()
(ข้อความจาก วิชวลสตูดิโอ)

ตัวระบุประเภท หรือรูปแบบ หรืออักขระการแปลง หรืออักขระควบคุม

การประกาศ scanf C อย่างน้อยต้องมีตัวระบุรูปแบบ ซึ่งระบุไว้ที่ส่วนท้ายของนิพจน์ที่ขึ้นต้นด้วยเครื่องหมาย "%" มันบอกโปรแกรมถึงประเภทของข้อมูลที่คาดหวังเมื่อป้อน โดยปกติจะมาจากแป้นพิมพ์ รายการตัวระบุรูปแบบทั้งหมดในตารางด้านล่าง

		ความหมาย
		โปรแกรมกำลังรอการป้อนอักขระ ตัวแปรที่จะเขียนต้องเป็นประเภท char

		โปรแกรมคาดว่าจะป้อนจำนวนเต็มทศนิยม ตัวแปรต้องเป็นประเภท int
		โปรแกรมคาดว่าจะป้อนเลขทศนิยม (จุลภาค) ในรูปแบบเลขชี้กำลัง ตัวแปรต้องเป็นประเภท float

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

อักขระในรูปแบบสตริง

สัญลักษณ์ดอกจัน (*)

เครื่องหมายดอกจัน (*) เป็นค่าสถานะที่ระบุว่าควรระงับการดำเนินการมอบหมาย เครื่องหมายดอกจันจะวางต่อจากเครื่องหมาย "%" ทันที ตัวอย่างเช่น,

Scanf("%d%*c%d", &x, &y); // ละเว้นอักขระระหว่างจำนวนเต็มสองตัว scanf("%s%*d%s", str, str2); // ละเว้นจำนวนเต็มระหว่างสองสตริง

นั่นคือถ้าคุณป้อนบรรทัด "45-20" ในคอนโซล โปรแกรมจะทำสิ่งต่อไปนี้:

ตัวแปร "x" จะถูกกำหนดค่า 45
ตัวแปร "y" จะถูกกำหนดค่าเป็น 20
และเครื่องหมายลบ (เส้นประ) "-" จะถูกละเว้นด้วย "%*c"

ความกว้าง (หรือความกว้างขอบ)

นี่คือจำนวนเต็มระหว่างเครื่องหมาย "%" และตัวระบุรูปแบบที่ระบุ จำนวนเงินสูงสุดอักขระที่จะอ่านสำหรับการดำเนินการอ่านปัจจุบัน

มีประเด็นสำคัญหลายประการที่ควรทราบ:

scanf จะยกเลิกหากพบอักขระคั่น แม้ว่าจะไม่ได้นับอักขระ 20 ตัวก็ตาม
หากป้อนอักขระมากกว่า 20 ตัว ระบบจะเขียนอักขระ 20 ตัวแรกลงใน str เท่านั้น

ตัวดัดแปลงประเภท (หรือความแม่นยำ)

เหล่านี้เป็นค่าสถานะพิเศษที่แก้ไขชนิดของข้อมูลที่คาดไว้สำหรับการป้อนข้อมูล แฟล็กถูกระบุทางด้านซ้ายของตัวระบุประเภท:

L หรือ l (ตัว L ตัวเล็ก) เมื่อใช้ "l" กับตัวระบุ d, i, o, u, x แฟล็กจะบอกโปรแกรมว่าต้องการอินพุตแบบยาว เมื่อใช้ "l" กับตัวระบุ e หรือ f แฟล็กจะบอกโปรแกรมว่าควรคาดหวังค่าสองเท่า การใช้ "L" เป็นการบอกโปรแกรมว่าคาดว่าจะมีความยาวสองเท่า การใช้ "l" กับตัวระบุ "c" และ "s" จะบอกโปรแกรมว่าต้องการอักขระสองไบต์ เช่น wchar_t ตัวอย่างเช่น "%lc", "%ls", "%l"
h เป็นธงระบุประเภทสั้น
hh - บ่งชี้ว่าตัวแปรเป็นตัวชี้ไปยังค่าประเภทที่ลงนามถ่านหรือถ่านที่ไม่ได้ลงนาม แฟล็กสามารถใช้กับตัวระบุ d, i, o, u, x, n
ll (ตัว L ตัวเล็กสองตัว) ระบุว่าตัวแปรเป็นตัวชี้ไปยังค่าประเภท sign int หรือ unsigned long long int แฟล็กใช้กับตัวระบุ: d, i, o, u, x, n
j - ระบุว่าตัวแปรเป็นตัวชี้ไปยังประเภท intmax_t หรือ uintmax_t จากไฟล์ส่วนหัว stdint.h ใช้กับตัวระบุ: d, i, o, u, x, n
z - ระบุว่าตัวแปรเป็นตัวชี้ไปยังประเภท size_t ซึ่งคำจำกัดความอยู่ใน stddef.h ใช้กับตัวระบุ: d, i, o, u, x, n
t - ระบุว่าตัวแปรเป็นตัวชี้ไปยังประเภท ptrdiff_t คำจำกัดความสำหรับประเภทนี้อยู่ใน stddef.h ใช้กับตัวระบุ: d, i, o, u, x, n

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

ตัวละครอื่นๆ

อักขระใด ๆ ที่พบในรูปแบบจะถูกยกเลิก ควรสังเกตว่าการมีช่องว่างหรืออักขระคั่น (ขึ้นบรรทัดใหม่ เว้นวรรค แท็บ) ในสตริงควบคุมสามารถนำไปสู่พฤติกรรมที่แตกต่างกันของฟังก์ชันได้ ในเวอร์ชันหนึ่ง scanf() จะอ่านโดยไม่บันทึกตัวคั่นจำนวนใดๆ จนกว่าจะเจออักขระอื่นที่ไม่ใช่ตัวคั่น และในอีกเวอร์ชันหนึ่ง ช่องว่าง (เท่านั้น) จะไม่มีบทบาทและนิพจน์ "%d + %d" เทียบเท่ากับ "%d+%d"

ตัวอย่าง

ลองพิจารณาตัวอย่างจำนวนหนึ่งที่ช่วยให้คุณคิดและเข้าใจการทำงานของฟังก์ชันได้แม่นยำยิ่งขึ้น

scanf("%3s", str); // หากคุณป้อนสตริง "1d2s3d1;3" ในคอนโซล เฉพาะ "1d2" เท่านั้นที่จะถูกเขียนไปยัง str scanf("%dminus%d", &x, &y); // อักขระลบระหว่างสองตัวเลขจะถูกยกเลิก scanf("%5", str); // อักขระจะถูกป้อนใน str จนครบ 5 ตัว และอักขระเป็นตัวเลขตั้งแต่ 0 ถึง 9 scanf("%lf", &d); // คาดหวังการป้อนข้อมูลสองครั้ง scanf("%hd", &x); // จำนวนที่คาดหวังของประเภท short scanf("%hu", &y); // คาดว่าจะสแกนสั้นหมายเลขที่ไม่ได้ลงนาม ("lx", & z); // จำนวนที่คาดหวังของประเภท long int

จากตัวอย่างที่ให้มา คุณจะเห็นการเปลี่ยนแปลงของจำนวนที่คาดหวังโดยใช้ สัญลักษณ์ต่างๆ.

scanf C - คำอธิบายสำหรับผู้เริ่มต้น

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

คุณลักษณะนี้ค่อนข้างเลิกใช้แล้ว มีการใช้งานที่แตกต่างกันหลายอย่างในไลบรารี รุ่นต่างๆ. ตัวอย่างเช่น ฟังก์ชัน scanf SC ที่ได้รับการปรับปรุง ซึ่งมีคำอธิบายอยู่ในไมโครซอฟท์
จำนวนตัวระบุในรูปแบบต้องตรงกับจำนวนอาร์กิวเมนต์ที่ส่งไปยังฟังก์ชัน
องค์ประกอบของสตรีมอินพุตต้องคั่นด้วยอักขระคั่นเท่านั้น: ช่องว่าง แท็บ บรรทัดใหม่ เครื่องหมายจุลภาค เครื่องหมายอัฒภาค จุด ฯลฯ - อักขระเหล่านี้ไม่ใช่ตัวคั่นสำหรับฟังก์ชัน scanf()
หาก scanf พบอักขระคั่น การป้อนข้อมูลจะหยุดลง หากมีตัวแปรให้อ่านมากกว่าหนึ่งตัว scanf จะอ่านตัวแปรถัดไป
ความไม่สอดคล้องกันเพียงเล็กน้อยในรูปแบบของข้อมูลอินพุตนำไปสู่ผลลัพธ์ที่คาดเดาไม่ได้ของโปรแกรม ถ้าโปรแกรมจบลงด้วยข้อผิดพลาด แต่บ่อยครั้งโปรแกรมยังคงทำงานและทำงานผิดพลาด
scanf("%20s...",...); หากสตรีมอินพุตเกิน 20 อักขระ scanf จะอ่านอักขระ 20 ตัวแรกและยกเลิกหรืออ่านตัวแปรถัดไปหากมีการระบุ ในกรณีนี้ การเรียกใช้ scanf ครั้งต่อไปจะอ่านอินพุตสตรีมต่อจากจุดที่การทำงานของการเรียก scanf ครั้งก่อนหยุดลง หากพบอักขระตัวคั่นขณะอ่านอักขระ 20 ตัวแรก scanf จะยกเลิกหรือไปยังการอ่านตัวแปรถัดไป แม้ว่าจะไม่ได้อ่านอักขระ 20 ตัวสำหรับตัวแปรแรกก็ตาม ในกรณีนี้ อักขระที่ยังไม่ได้อ่านทั้งหมดจะถูกแนบไปกับตัวแปรถัดไป
หากชุดของอักขระที่สแกนขึ้นต้นด้วยเครื่องหมาย "^" scanf จะอ่านข้อมูลจนกว่าจะพบอักขระตัวคั่นหรืออักขระจากชุด ตัวอย่างเช่น "%[^A-E1-5]" จะอ่านข้อมูลจากสตรีมจนกว่าจะพบอักขระภาษาอังกฤษตัวพิมพ์ใหญ่ตั้งแต่ A ถึง E หรือหนึ่งในตัวเลขตั้งแต่ 1 ถึง 5
ตามคำจำกัดความ ฟังก์ชัน scanf C จะส่งคืนตัวเลขเท่ากับจำนวนของการเขียนตัวแปรที่สำเร็จ หาก scanf เขียนตัวแปร 3 ตัว ผลลัพธ์สำเร็จของฟังก์ชันจะคืนค่าเป็น 3 หาก scanf ไม่สามารถเขียนตัวแปรใดๆ ได้ ผลลัพธ์จะเป็น 0 และสุดท้าย หาก scanf ไม่สามารถเริ่มทำงานได้เลยด้วยเหตุผลบางประการ ผลลัพธ์จะเป็น EOF
หากฟังก์ชัน scanf() ทำงานผิดพลาด ตัวอย่างเช่น scanf("%d", &x) - ต้องการตัวเลข แต่อินพุตได้รับอักขระ การเรียกใช้ scanf() ครั้งต่อไปจะเริ่มที่จุดในสตรีมอินพุตซึ่งการเรียกใช้ฟังก์ชันก่อนหน้านี้หยุดทำงาน เพื่อแก้ไขปัญหานี้จำเป็นต้องกำจัดตัวละครที่มีปัญหา ซึ่งสามารถทำได้โดยการเรียก scanf("%*s") นั่นคือฟังก์ชันจะอ่านสตริงอักขระแล้วโยนทิ้งไป ด้วยวิธีการที่ยุ่งยากนี้ คุณสามารถป้อนข้อมูลที่จำเป็นต่อไปได้
การใช้งาน scanf() บางอย่างไม่อนุญาตให้สแกน "-" ในชุดอักขระ
ตัวระบุ "%c" อ่านอักขระแต่ละตัวจากสตรีม นั่นคือมันยังอ่านอักขระตัวคั่น หากต้องการข้ามอักขระคั่นและอ่านอักขระที่ต้องการต่อไป สามารถใช้ "%1s" ได้
เมื่อใช้ตัวระบุ "c" คุณสามารถใช้ความกว้าง "%10c" ได้ แต่ในรูปแบบ ตัวแปรฟังก์ชัน scanf จำเป็นต้องผ่านอาร์เรย์ขององค์ประกอบประเภท char
“%” หมายถึง “ตัวอักษรภาษาอังกฤษตัวเล็กทั้งหมด” และ “%” หมายถึงอักขระเพียง 3 ตัว: 'z', 'a', '-' กล่าวอีกนัยหนึ่ง อักขระ "-" หมายถึงช่วงเฉพาะเมื่ออยู่ระหว่างอักขระสองตัวที่อยู่ในลำดับที่ถูกต้อง ถ้า "-" อยู่ที่ส่วนท้ายของนิพจน์ ที่จุดเริ่มต้น หรืออยู่ในลำดับที่ไม่ถูกต้องของอักขระที่ด้านใดด้านหนึ่ง แสดงว่านั่นเป็นเพียงอักขระยัติภังค์ ไม่ใช่ช่วง

บทสรุป

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

ไลบรารีมาตรฐาน C/C++ มีฟังก์ชันจำนวนหนึ่งสำหรับการอ่านและเขียนไปยังคอนโซล (แป้นพิมพ์และจอภาพ) ฟังก์ชันเหล่านี้อ่านและเขียนข้อมูลเป็นชุดอักขระอย่างง่าย

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

printf() ฟังก์ชันเอาต์พุตมาตรฐาน

ฟังก์ชัน printf() เป็นฟังก์ชันเอาต์พุตมาตรฐาน ด้วยฟังก์ชันนี้ คุณสามารถแสดงสตริงอักขระ ตัวเลข ค่าตัวแปรบนหน้าจอมอนิเตอร์ ...

ฟังก์ชัน printf() มีต้นแบบอยู่ในไฟล์ stdio.h
int printf (อักขระ * สตริงควบคุม, ...);

หากสำเร็จ ฟังก์ชัน printf() จะส่งคืนจำนวนอักขระที่พิมพ์

สตริงควบคุมประกอบด้วยข้อมูลสองประเภท: อักขระที่แสดงบนหน้าจอโดยตรง และตัวระบุรูปแบบที่กำหนดวิธีส่งออกอาร์กิวเมนต์

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

ตัวระบุรูปแบบ:

%กับ	เครื่องหมาย
%d	เลขฐานสิบจำนวนเต็ม
%ฉัน	เลขฐานสิบจำนวนเต็ม
%e	เลขฐานสิบในรูป x.xx e+xx
%E	เลขฐานสิบในรูป x.xx E+xx
%ฉ
%F	ทศนิยมทศนิยม xx.xxxx
% กรัม	%f หรือ %e แล้วแต่จำนวนใดจะสั้นกว่า
%G	%F หรือ %E แล้วแต่จำนวนใดจะสั้นกว่า
%o	เลขฐานแปด
%s	สตริงอักขระ
%ยู	เลขทศนิยมที่ไม่ได้ลงนาม
%x	เลขฐานสิบหก
%X	เลขฐานสิบหก
%%	เครื่องหมาย %
% หน้า	ตัวชี้
%n	ตัวชี้

นอกจากนี้ยังสามารถใช้ตัวแก้ไข l และ h กับคำสั่งจัดรูปแบบได้

%ld	พิมพ์ int ยาว
%ฮู	พิมพ์สั้น ๆ ที่ไม่ได้ลงนาม
%Lf	พิมพ์ยาวคู่

ในตัวระบุรูปแบบ หลังจากสัญลักษณ์ % สามารถระบุความแม่นยำ (จำนวนหลักหลังจุดทศนิยม) ได้ ตั้งค่าความแม่นยำดังนี้: %.n<код формата>. โดยที่ n คือจำนวนหลักหลังจุดทศนิยม และ<код формата>- หนึ่งในรหัสข้างต้น

ตัวอย่างเช่น หากเรามีตัวแปร x=10.3563 เป็นประเภท float และเราต้องการแสดงค่าด้วยทศนิยม 3 ตำแหน่ง เราควรเขียนดังนี้

printf("ตัวแปร x = %.3f",x);

ผลลัพธ์:
ตัวแปร x = 10.356

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

ตัวอย่างเช่น หากคุณเขียนว่า:

printf("%5d",20);

ผลลัพธ์จะเป็น:
20

โปรดทราบว่าหมายเลข 20 ไม่ได้พิมพ์ตั้งแต่ต้นบรรทัด หากคุณต้องการให้ตำแหน่งที่ไม่ได้ใช้ของฟิลด์เต็มไปด้วยศูนย์ คุณต้องใส่อักขระ 0 ข้างหน้าความกว้างของฟิลด์

ตัวอย่างเช่น:

printf("%05d",20);

ผลลัพธ์:
00020

นอกจากตัวระบุรูปแบบข้อมูลแล้ว สตริงควบคุมยังสามารถมีอักขระควบคุม:

\b	BS, ก้นหลุม
\f	เพจใหม่ แปลเพจ
\n	ขึ้นบรรทัดใหม่ ป้อนบรรทัด
\r	การกลับรถ
\t	แท็บแนวนอน
\v	แท็บแนวตั้ง
\"	คำพูดคู่
\"	เครื่องหมายอัญประกาศเดี่ยว
\\	แบ็กสแลช
\0	อักขระ Null, null ไบต์
\a	สัญญาณ
\N	ค่าคงที่ฐานแปด
\xN	ค่าคงที่เลขฐานสิบหก
\?	เครื่องหมายคำถาม

ส่วนใหญ่คุณจะใช้อักขระ \n ด้วยอักขระควบคุมนี้ คุณจะสามารถข้ามไปยังบรรทัดใหม่ได้ ดูตัวอย่างโปรแกรมแล้วคุณจะเข้าใจทุกอย่าง

ตัวอย่างโปรแกรม

/* ตัวอย่างที่ 1 */
#รวม

โมฆะหลัก (โมฆะ)
{
int a,b,c; // ประกาศ ตัวแปร a,b,c
ก=5;
ข=6;
ค=9;
printf("a=%d, b=%d, c=%d",a,b,c);
}

ผลลัพธ์ของโปรแกรม:
ก=5, ข=6, ค=9

/* ตัวอย่างที่ 2 */
#รวม

โมฆะหลัก (โมฆะ)
{
ลอย x,y,z;

X=10.5;
y=130.67;
z=54;

Printf("พิกัดวัตถุ: x:%.2f, y:%.2f, z:%.2f", x, y, z);
}

ผลลัพธ์ของโปรแกรม:
พิกัดวัตถุ: x:10.50, y:130.67, z:54.00

/* ตัวอย่างที่ 3 */
#รวม

โมฆะหลัก ()
{
intx;

X=5;
printf("x=%d", x*2);
}

ผลลัพธ์ของโปรแกรม:
x=10

/* ตัวอย่างที่ 4 */
#รวม

โมฆะหลัก (โมฆะ)
{
printf("\"ข้อความในเครื่องหมายคำพูด\"");
printf("\nปริมาณออกซิเจน: 100%%");
}

ผลลัพธ์ของโปรแกรม:
"ข้อความในเครื่องหมายคำพูด"
ปริมาณออกซิเจน: 100%

/* ตัวอย่างที่ 5 */
#รวม

โมฆะหลัก (โมฆะ)
{
int a;

ก=11; // 11 ในรูปทศนิยม เท่ากับ b ในรูปฐานสิบหก
printf("a-dec=%d, a-hex=%X",a,a);
}

ผลลัพธ์ของโปรแกรม:
a-dec=11, a-hex=b

/* ตัวอย่างที่ 6 */
#รวม

โมฆะหลัก (โมฆะ)
{
ถ่าน ch1,ch2,ch3;

Ch1="A";
ch2="B";
ch3="ค";

Printf("%c%c%c",ch1,ch2,ch3);
}

ผลลัพธ์ของโปรแกรม:
เอบีซี

/* ตัวอย่างที่ 7 */
#รวม

โมฆะหลัก (โมฆะ)
{
char *str="สตริงของฉัน";

Printf("นี่คือ %s", str);
}

ผลลัพธ์ของโปรแกรม:
นี่คือแนวของฉัน

/* ตัวอย่างที่ 8 */
#รวม

โมฆะหลัก (โมฆะ)
{
printf("สวัสดี!\n"); // หลังจากพิมพ์ จะมีบรรทัดใหม่ - \n
printf("ฉันชื่อพอล"); // สิ่งนี้จะถูกพิมพ์ในบรรทัดใหม่
}

ผลลัพธ์ของโปรแกรม:
สวัสดี!
ฉันชื่อพาเวล

scanf() ฟังก์ชันอินพุตมาตรฐาน

ฟังก์ชัน scanf() เป็นฟังก์ชันอินพุตที่จัดรูปแบบ ด้วยคุณสามารถป้อนข้อมูลจากอุปกรณ์อินพุตมาตรฐาน (แป้นพิมพ์) อินพุตสามารถเป็นจำนวนเต็ม ตัวเลขทศนิยม อักขระ สตริง และพอยน์เตอร์

ฟังก์ชัน scanf() มีต้นแบบต่อไปนี้ใน stdio.h:
int scanf (ถ่าน * สตริงควบคุม);

ฟังก์ชันส่งกลับจำนวนตัวแปรที่ได้รับการกำหนดค่า

สตริงควบคุมประกอบด้วยอักขระสามชนิด: ตัวระบุรูปแบบ ช่องว่าง และอักขระอื่นๆ ตัวระบุรูปแบบเริ่มต้นด้วยอักขระ %

ตัวระบุรูปแบบ:

เมื่อป้อนสตริงโดยใช้ฟังก์ชัน scanf() (ตัวระบุรูปแบบ %s) สตริงจะถูกป้อนจนถึงช่องว่างแรก!! เหล่านั้น. หากคุณป้อนสตริง "Hello world!" โดยใช้ฟังก์ชัน scanf()

scanf("%s",str);

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

ถ่าน * ได้รับ (ถ่าน * buf);

ด้วยฟังก์ชัน gets() คุณสามารถป้อนสตริงแบบเต็มได้ ฟังก์ชัน gets() อ่านอักขระจากแป้นพิมพ์จนกระทั่งอักขระปรากฏขึ้น บรรทัดใหม่(\n). อักขระขึ้นบรรทัดใหม่จะปรากฏขึ้นเมื่อคุณกดปุ่ม Enter ฟังก์ชันส่งกลับตัวชี้ไปยังบัฟ buf - บัฟเฟอร์ (หน่วยความจำ) สำหรับสตริงอินพุต

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

#รวม

โมฆะหลัก (โมฆะ)
{
ชาร์บัฟเฟอร์; // อาร์เรย์ (บัฟเฟอร์) สำหรับสตริงอินพุต

รับ (บัฟเฟอร์); // ป้อนสตริงแล้วกด Enter
printf("%s",บัฟเฟอร์); // ส่งออกสตริงที่ป้อนไปที่หน้าจอ
}

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

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

มาดูตัวอย่างโปรแกรมที่แสดงวิธีใช้ &

#รวม

โมฆะหลัก (โมฆะ)
{
intx;

Printf("ใส่ตัวแปร x:");
scanf("%d",&x);
printf("ตัวแปร x=%d",x);
}

ตอนนี้กลับไปที่บรรทัดควบคุมของฟังก์ชัน scanf() อีกครั้ง:

int scanf (ถ่าน * สตริงควบคุม);

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

ตัวคั่นระหว่างตัวเลขอินพุตสองตัวคือช่องว่าง แท็บ หรืออักขระขึ้นบรรทัดใหม่ * หลัง % และก่อนรหัสรูปแบบ (ตัวระบุรูปแบบ) สั่งให้อ่านข้อมูลประเภทที่ระบุ แต่ไม่ให้กำหนดค่านั้น

ตัวอย่างเช่น:

scanf("%d%*c%d",&i,&j);

การพิมพ์ 50+20 จะตั้งค่า i เป็น 50, j เป็น 20 และเครื่องหมาย + จะถูกอ่านและไม่สนใจ

คำสั่งรูปแบบสามารถระบุความกว้างของฟิลด์ที่ใหญ่ที่สุดที่จะอ่าน

ตัวอย่างเช่น:

scanf("%5s",str);

ระบุให้อ่านอักขระ 5 ตัวแรกจากสตรีมอินพุต หากคุณป้อน 1234567890ABC อาร์เรย์ str จะมีเพียง 12345 อักขระที่เหลือจะถูกละเว้น ตัวคั่น: เว้นวรรค แท็บ และขึ้นบรรทัดใหม่ - เมื่อป้อนอักขระ จะถือว่าเหมือนกับอักขระอื่นๆ ทั้งหมด

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

scanf("%dplus%d",&x,&y);

จะกำหนด x เป็น 10, y เป็น 20 และข้ามเครื่องหมายบวกเนื่องจากอักขระเหล่านั้นเกิดขึ้นในบรรทัดควบคุม

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

#รวม

โมฆะหลัก (โมฆะ)
{
ถ่าน str1, str2;
scanf("%%s", str1, str2);
printf("\n%s\n%s",str1,str2);
}
มาใส่ชุดอักขระกันเถอะ:
12345abcdefg456

บนหน้าจอโปรแกรมจะแสดง:
12345
abcdefg456

เมื่อระบุชุดการค้นหา คุณสามารถใช้อักขระยัติภังค์เพื่อระบุช่องว่าง เช่นเดียวกับความกว้างสูงสุดของช่องป้อนข้อมูล

scanf("%10", str1);

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

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

ถ่าน str; // อาร์เรย์สำหรับ 80 ตัวอักษร
scanf("%s",str);

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

ตัวอย่างโปรแกรม

ตัวอย่างที่ 1
โปรแกรมนี้แสดงข้อความค้นหา "How old are you?:" และรอการป้อนข้อมูล ตัวอย่างเช่น หากคุณป้อนหมายเลข 20 โปรแกรมจะแสดงข้อความว่า "คุณอายุ 20 ปี" เมื่อเราเรียกใช้ฟังก์ชัน scanf() เราจะนำหน้าตัวแปรอายุด้วย & เนื่องจากฟังก์ชัน scanf() ต้องการที่อยู่ของตัวแปร ฟังก์ชัน scanf() จะเขียนค่าที่ป้อนไปยังที่อยู่ที่ระบุ ในกรณีของเรา ค่าที่ป้อน 20 จะถูกเขียนไปยังที่อยู่ของตัวแปรอายุ

/* ตัวอย่างที่ 1 */

#รวม

โมฆะหลัก (โมฆะ)
{
อายุ int;

Printf("\nคุณอายุเท่าไหร่:");
scanf("%d",&อายุ);
printf("คุณอายุ %d ปี.", อายุ);
}

ตัวอย่างที่ 2
โปรแกรมเครื่องคิดเลข. เครื่องคิดเลขนี้สามารถบวกตัวเลขได้เท่านั้น หากคุณป้อน 100+34 โปรแกรมจะส่งกลับผลลัพธ์: 100+34=134

/* ตัวอย่างที่ 2 */

#รวม

โมฆะหลัก (โมฆะ)
{
int x, y;

Printf("\nเครื่องคิดเลข:");
scanf("%d+%d", &x, &y);
printf("\n%d+%d=%d", x, y, x+y);
}

ตัวอย่างที่ 3
ตัวอย่างนี้แสดงวิธีการตั้งค่าความกว้างของฟิลด์การอ่าน ในตัวอย่างของเรา ความกว้างของฟิลด์คือห้าอักขระ หากคุณป้อนสตริงที่มีอักขระมากกว่านี้ อักขระทั้งหมดหลังจากอักขระที่ 5 จะถูกยกเลิก ให้ความสนใจกับการเรียกใช้ฟังก์ชัน scanf() เครื่องหมาย & ไม่นำหน้าชื่อของชื่ออาร์เรย์ เนื่องจากชื่อของชื่ออาร์เรย์เป็นที่อยู่ขององค์ประกอบแรกของอาร์เรย์

/* ตัวอย่างที่ 3 */

#รวม

โมฆะหลัก (โมฆะ)
{
เสน่ห์;

Printf("\nใส่ชื่อผู้ใช้ของคุณ (สูงสุด 5 ตัวอักษร):");
scanf("%5s", ชื่อ);
printf("\nคุณป้อน %s", ชื่อ);
}

ตัวอย่างที่ 4
ตัวอย่างสุดท้ายในบทความนี้แสดงวิธีที่คุณสามารถใช้ชุดการค้นหา หลังจากเริ่มโปรแกรม ให้ป้อนตัวเลขตั้งแต่ 2 ถึง 5

/* ตัวอย่างที่ 4 */

#รวม

โมฆะหลัก (โมฆะ)
{
ถ่าน;

Printf("คะแนนของคุณคือ 2,3,4,5:");
scanf("%", &bal);
printf("\nคะแนน %c", bal);
}

ภาษาโปรแกรม C++

ปรับปรุงล่าสุด: 08/28/2017

ภาษาโปรแกรม C++ เป็นภาษาโปรแกรมคอมไพล์ระดับสูงสำหรับใช้งานทั่วไป การพิมพ์แบบคงที่ซึ่งเหมาะสำหรับการสร้างแอพพลิเคชั่นที่หลากหลาย C++ เป็นหนึ่งในภาษาที่ได้รับความนิยมและแพร่หลายมากที่สุดในปัจจุบัน

มีรากฐานมาจากภาษาซี ซึ่งพัฒนาขึ้นในปี พ.ศ. 2512-2516 ที่ Bell Labs โดยโปรแกรมเมอร์ Dennis Ritchie ในช่วงต้นทศวรรษ 1980 โปรแกรมเมอร์ชาวเดนมาร์ก Bjarne Stroustrup ซึ่งขณะนั้นอยู่ที่ Bell Labs ได้พัฒนา C++ เป็นส่วนเสริมของภาษา C อันที่จริง ในตอนแรก C++ เป็นเพียงการเสริมภาษา C ด้วยคุณสมบัติบางอย่างของการเขียนโปรแกรมเชิงวัตถุ ในตอนแรก Stroustrup เองก็เรียกมันว่า "C with class" ("C with class")

ต่อจากนั้น ภาษาใหม่เริ่มได้รับความนิยม คุณลักษณะใหม่ถูกเพิ่มเข้ามา ซึ่งไม่ได้เป็นเพียงการเพิ่มภาษา C แต่เป็นภาษาการเขียนโปรแกรมใหม่ทั้งหมด ด้วยเหตุนี้ "C ที่มีคลาส" จึงถูกเปลี่ยนชื่อเป็น C++ และตั้งแต่นั้นมาทั้งสองภาษาก็เริ่มพัฒนาเป็นอิสระจากกัน

C++ เป็นภาษาที่ทรงพลัง สืบทอดความสามารถของหน่วยความจำที่หลากหลายจากภาษาซี ดังนั้น C++ มักจะพบแอปพลิเคชันในการเขียนโปรแกรมระบบ โดยเฉพาะเมื่อสร้าง ระบบปฏิบัติการ, ไดรเวอร์ , ยูทิลิตี้ต่างๆ , แอนตี้ไวรัส ฯลฯ อย่างไรก็ตาม Windows ส่วนใหญ่เขียนด้วย C++ แต่โปรแกรมโปรแกรมระบบเท่านั้น ภาษาที่กำหนดไม่จำกัด สามารถใช้ C++ ในโปรแกรมระดับใดก็ได้ที่ความเร็วและประสิทธิภาพเป็นสิ่งสำคัญ มักใช้เพื่อสร้าง แอพพลิเคชั่นกราฟิก, หลากหลาย โปรแกรมประยุกต์. นอกจากนี้ยังใช้บ่อยเป็นพิเศษในการสร้างเกมที่มีภาพที่สมบูรณ์ นอกจากนี้ ทิศทางมือถือเพิ่งได้รับแรงผลักดันซึ่ง C ++ ก็พบแอปพลิเคชันเช่นกัน และแม้กระทั่งในการพัฒนาเว็บ คุณยังสามารถใช้ C++ เพื่อสร้างเว็บแอปพลิเคชันหรือบริการเสริมบางประเภทที่ให้บริการเว็บแอปพลิเคชันได้ โดยทั่วไปแล้ว C++ เป็นภาษาที่ใช้กันอย่างแพร่หลาย ซึ่งคุณสามารถเขียนโปรแกรมได้เกือบทุกชนิด

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

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

เหตุการณ์สำคัญของการพัฒนา

ในปี พ.ศ. 2522-2523 Bjarne Stroustrup ได้พัฒนาส่วนเสริมสำหรับภาษา C - "C with class" ในปี 1983 ภาษาถูกเปลี่ยนชื่อเป็น C++

ในปี พ.ศ. 2528 ภาษา C++ เวอร์ชันเชิงพาณิชย์รุ่นแรกได้รับการเผยแพร่ เช่นเดียวกับหนังสือ "The C++ Programming Language" ฉบับพิมพ์ครั้งแรก ซึ่งแสดงถึงคำอธิบายแรกของภาษานี้ในกรณีที่ไม่มีมาตรฐานที่เป็นทางการ

วางจำหน่ายในปี 1989 รุ่นใหม่ C++ 2.0 ซึ่งมีคุณลักษณะใหม่ๆ มากมาย หลังจากนั้นภาษาก็พัฒนาค่อนข้างช้าจนถึงปี 2554 แต่ในเวลาเดียวกัน ในปี 1998 มีความพยายามครั้งแรกในการสร้างมาตรฐานของภาษาโดย ISO (International Organization for Standardization) มาตรฐานแรกเรียกว่า ISO/IEC 14882:1998 หรือเรียกสั้นๆ ว่า C++98 ต่อมาในปี 2546 ได้มีการเผยแพร่มาตรฐาน C++03 เวอร์ชันใหม่

ในปี 2011 มีการเผยแพร่มาตรฐาน C++11 ใหม่ ซึ่งมีส่วนเพิ่มเติมมากมายและเสริมความสมบูรณ์ให้กับภาษา C++ จำนวนมากฟังก์ชั่นใหม่ ตามมาในปี 2014 โดยการเพิ่มมาตรฐานเล็กน้อยหรือที่เรียกว่า C++14 และมีกำหนดการเผยแพร่ภาษาหลักอื่นในปี 2560

คอมไพเลอร์และสภาพแวดล้อมการพัฒนา

ในการพัฒนาโปรแกรมใน C++ คุณต้องมีคอมไพเลอร์ ซึ่งจะแปลซอร์สโค้ด C++ ให้เป็นไฟล์เรียกทำงาน ซึ่งสามารถเรียกใช้ได้ แต่ในขณะนี้มีคอมไพเลอร์ที่แตกต่างกันมากมาย อาจแตกต่างกันในด้านต่าง ๆ โดยเฉพาะอย่างยิ่งในการดำเนินการตามมาตรฐาน รายการพื้นฐานของคอมไพเลอร์สำหรับ C++ สามารถพบได้ในวิกิพีเดีย ขอแนะนำสำหรับการพัฒนาให้เลือกคอมไพเลอร์ที่พัฒนาและใช้มาตรฐานล่าสุดทั้งหมด ตัวอย่างเช่น ตลอดบทช่วยสอนนี้ จะใช้คอมไพเลอร์ g++ ที่ใช้งานได้ฟรีซึ่งพัฒนาโดยโปรเจ็กต์ GNU เป็นหลัก

คุณสามารถใช้ IDE เช่น Visual Studio, Netbeans, Eclipse, Qt เป็นต้น เพื่อสร้างโปรแกรม

เรียนรู้พื้นฐานและรายละเอียดปลีกย่อยของภาษาโปรแกรม C++ หนังสือเรียนพร้อมงานปฏิบัติและแบบทดสอบ คุณต้องการเรียนรู้วิธีการเขียนโปรแกรมหรือไม่? ถ้าอย่างนั้นคุณมาถูกที่แล้ว - ที่นี่ การศึกษาฟรีการเขียนโปรแกรม ไม่ว่าคุณจะมีประสบการณ์หรือไม่ก็ตาม บทเรียนการเขียนโปรแกรมเหล่านี้จะช่วยคุณเริ่มต้นสร้าง คอมไพล์ และดีบักโปรแกรม C++ ในสภาพแวดล้อมการพัฒนาต่างๆ: Visual Studio, Code::Blocks, Xcode หรือ Eclipse

ตัวอย่างมากมายและคำอธิบายโดยละเอียด เหมาะสำหรับทั้งผู้เริ่มต้น (หุ่น) และขั้นสูง ทุกอย่างอธิบายตั้งแต่เริ่มต้นจนถึงรายละเอียดที่เล็กที่สุด บทเรียนเหล่านี้ (200+) จะทำให้คุณมีพื้นฐาน / พื้นฐานที่ดีในการทำความเข้าใจการเขียนโปรแกรมไม่เพียง แต่ในภาษา C ++ แต่ยังรวมถึงภาษาโปรแกรมอื่น ๆ ด้วย และฟรีแน่นอน!

พิจารณาด้วย การสร้างทีละขั้นตอนเกม c++, ห้องสมุดกราฟิก SFML และมากกว่า 50 งานเพื่อทดสอบทักษะและความรู้ของคุณใน C++ โบนัสเพิ่มเติมคือ

สำหรับรีโพสต์ +20 ถึงกรรมและความกตัญญูของฉัน!

บทที่ 0 การแนะนำ. จุดเริ่มต้นของการทำงาน

บทที่ 1 พื้นฐานของภาษา C++

บทที่ 2 ตัวแปรและประเภทข้อมูลพื้นฐานใน C++

บทที่ 3 ตัวดำเนินการใน C++

บทที่ 4 ขอบเขตและตัวแปรประเภทอื่นๆ ใน C++

บทที่ 5 ลำดับที่รหัสถูกดำเนินการในโปรแกรม ลูปสาขาใน C ++

บทช่วยสอนเหล่านี้มีไว้สำหรับทุกคน ไม่ว่าคุณจะยังใหม่ต่อการเขียนโปรแกรมหรือคุณมีประสบการณ์การเขียนโปรแกรมในภาษาอื่นมาแล้วมากมาย! เนื้อหานี้เหมาะสำหรับผู้ที่ต้องการเรียนรู้ภาษา C / C ++ ตั้งแต่พื้นฐานจนถึงโครงสร้างที่ซับซ้อนที่สุด

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

การติดตั้ง /IDE

สิ่งแรกที่คุณควรทำก่อนที่จะเริ่มเรียนรู้ C++ คือต้องแน่ใจว่าคุณมี IDE ซึ่งเป็นสภาพแวดล้อมการพัฒนาแบบบูรณาการ (โปรแกรมที่คุณจะเขียนโปรแกรม) หากคุณไม่มี IDE แสดงว่าคุณอยู่ที่นี่ เมื่อคุณตัดสินใจเลือก IDE แล้ว ให้ติดตั้งและฝึกฝนการสร้างโปรเจ็กต์อย่างง่าย

รู้เบื้องต้นเกี่ยวกับ C++

ภาษา C++ เป็นชุดคำสั่งที่บอกให้คอมพิวเตอร์ทราบว่าต้องทำอะไร ชุดของคำสั่งนี้มักจะเรียกว่าซอร์สโค้ดหรือเพียงแค่รหัส คำสั่งเป็น "ฟังก์ชัน" หรือ " คำหลัก". คำสำคัญ (คำสงวน C/C++) เป็นหน่วยการสร้างพื้นฐานของภาษา ฟังก์ชันเป็นแบบเอกสารสำเร็จรูปที่ซับซ้อน เนื่องจากถูกเขียนขึ้นโดยใช้ฟังก์ชันที่ง่ายกว่า ดังที่คุณจะเห็นในโปรแกรมแรกด้านล่างของเรา โครงสร้างการทำงานนี้คล้ายกับเนื้อหาของหนังสือ สารบัญสามารถแสดงบทต่างๆ ของหนังสือ แต่ละบทในหนังสือสามารถมีสารบัญของตัวเองซึ่งประกอบด้วยย่อหน้า แต่ละย่อหน้าสามารถมีย่อหน้าย่อยของตัวเองได้ แม้ว่า C ++ จะมีมากมาย ฟังก์ชั่นทั่วไปและคำสงวนที่คุณสามารถใช้ได้ ยังต้องเขียนฟังก์ชันของคุณเอง

คุณเริ่มโปรแกรมในส่วนใด แต่ละโปรแกรมใน C++ มีหนึ่งฟังก์ชัน ซึ่งเรียกว่า main หรือ main-function การทำงานของโปรแกรมจะเริ่มต้นด้วยฟังก์ชันนี้ จาก ฟังก์ชั่นหลักคุณยังสามารถเรียกใช้ฟังก์ชันอื่นๆ ได้อีกด้วย ไม่ว่าฟังก์ชันเหล่านั้นจะเขียนขึ้นโดยเราหรือตามที่กล่าวไว้ก่อนหน้านี้ โดยคอมไพเลอร์

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

#รวม << "Моя первая программа на С++\n"; cin.get(); }

มาดูองค์ประกอบของโปรแกรมกันดีกว่า #include เป็นคำสั่ง "ตัวประมวลผลล่วงหน้า" ที่บอกให้คอมไพเลอร์ใส่โค้ดจากไฟล์ส่วนหัวของ iostream ลงในโปรแกรมของเราก่อนที่จะสร้างไฟล์ปฏิบัติการ ด้วยการรวมไฟล์ส่วนหัวไว้ในโปรแกรมของคุณ คุณจะสามารถเข้าถึงฟังก์ชันต่างๆ มากมายที่คุณสามารถใช้ในโปรแกรมของคุณได้ ตัวอย่างเช่น คำสั่งศาลต้องการ iostream บรรทัดที่ใช้เนมสเปซ std; บอกให้คอมไพเลอร์ใช้กลุ่มของฟังก์ชันที่เป็นส่วนหนึ่งของไลบรารีมาตรฐาน std บรรทัดนี้ยังอนุญาตให้โปรแกรมใช้ตัวดำเนินการเช่น cout เครื่องหมายอัฒภาคเป็นส่วนหนึ่งของไวยากรณ์ C++ เป็นการบอกคอมไพเลอร์ว่านี่คือจุดสิ้นสุดของคำสั่ง คุณจะเห็นในภายหลังว่ามีการใช้เครื่องหมายอัฒภาคเพื่อยุติคำสั่งส่วนใหญ่ใน C++

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

ใน C++ วัตถุ cout ใช้เพื่อแสดงข้อความ (ออกเสียงว่า "cout") เขาใช้ตัวอักษร<< , известные как «оператор сдвига», чтобы указать, что отправляется к выводу на экран. Результатом вызова функции cout << является отображение текста на экране. Последовательность \n фактически рассматривается как единый символ, который обозначает новую строку (мы поговорим об этом позже более подробно). Символ \n перемещает курсор на экране на следующую строку. Опять же, обратите внимание на точку с запятой, её добавляют в конец, после каждого оператора С++.

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

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

#รวม ใช้เนมสเปซ std; int main() ( ศาล<<"Моя первая программа на С++\n"; cin.get(); return 1; }

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

อย่าลืมแสดงความคิดเห็นเกี่ยวกับโปรแกรมของคุณ!

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

จะทำอย่างไรกับตัวแปรประเภทนี้?

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

การประกาศตัวแปรในภาษา C++

ในการประกาศตัวแปร ให้ใช้ประเภทไวยากรณ์<имя>; . ตัวอย่างการประกาศตัวแปรมีดังนี้

จำนวน int; อักขระ; ลอย num_float;

อนุญาตให้ประกาศตัวแปรประเภทเดียวกันหลายตัวในหนึ่งบรรทัดได้ โดยแต่ละตัวแปรจะต้องคั่นด้วยเครื่องหมายจุลภาค

int x, y, z, d;

หากคุณพิจารณาอย่างใกล้ชิด คุณอาจเห็นว่าการประกาศตัวแปรจะตามด้วยเครื่องหมายอัฒภาคเสมอ คุณสามารถอ่านเพิ่มเติมเกี่ยวกับแบบแผน - "เกี่ยวกับการตั้งชื่อตัวแปร"

ข้อผิดพลาดทั่วไปเมื่อประกาศตัวแปรใน C++

หากคุณพยายามใช้ตัวแปรที่ไม่ได้ประกาศ โปรแกรมของคุณจะไม่คอมไพล์และคุณจะได้รับข้อผิดพลาด ใน C++ คีย์เวิร์ดของภาษาทั้งหมด ฟังก์ชันทั้งหมด และตัวแปรทั้งหมดจะพิจารณาตัวพิมพ์เล็กและใหญ่

การใช้ตัวแปร

ตอนนี้คุณรู้วิธีประกาศตัวแปรแล้ว นี่คือตัวอย่างโปรแกรมที่สาธิตการใช้ตัวแปร:

#รวม ใช้เนมสเปซ std; int main() ( จำนวน int; cout<< "Введите число: "; cin >> หมายเลข; cin.ignore(); ศาล<< "Вы ввели: "<< number <<"\n"; cin.get(); }

มาดูโปรแกรมนี้และศึกษาโค้ดของมันทีละบรรทัด คีย์เวิร์ด int บอกว่าตัวเลขนั้นเป็นจำนวนเต็ม ฟังก์ชัน cin >> อ่านค่าเป็นตัวเลข ผู้ใช้ต้องกด enter หลังตัวเลขที่ป้อน cin.ignore() เป็นฟังก์ชันที่อ่านอักขระและละเว้น เราได้จัดระเบียบอินพุตของเราในโปรแกรม หลังจากป้อนตัวเลขแล้ว เรากดแป้น ENTER ซึ่งเป็นอักขระที่ส่งผ่านไปยังสตรีมอินพุตด้วย เราไม่ต้องการมัน เราก็เลยทิ้งมันไป โปรดทราบว่าตัวแปรได้รับการประกาศให้เป็นประเภทจำนวนเต็ม หากผู้ใช้พยายามป้อนเลขฐานสิบ ตัวแปรจะถูกตัดออก (เช่น ส่วนทศนิยมของตัวเลขจะถูกละเว้น) ลองป้อนเลขทศนิยมหรือลำดับอักขระเมื่อคุณเรียกใช้โปรแกรมตัวอย่าง คำตอบจะขึ้นอยู่กับค่าที่ป้อน

โปรดทราบว่าไม่ได้ใช้เครื่องหมายอัญประกาศเมื่อพิมพ์จากตัวแปร การไม่มีเครื่องหมายอัญประกาศบอกคอมไพเลอร์ว่ามีตัวแปร ดังนั้นโปรแกรมจึงต้องตรวจสอบค่าของตัวแปรเพื่อแทนที่ชื่อตัวแปรด้วยค่าเมื่อเรียกใช้งาน ตัวดำเนินการหลายกะในบรรทัดเดียวกันเป็นที่ยอมรับอย่างสมบูรณ์ และผลลัพธ์จะถูกดำเนินการตามลำดับเดียวกัน คุณต้องแยกสตริงลิเทอรัล (สตริงที่ยกมา) และตัวแปรออกจากกัน โดยให้ตัวดำเนินการกะแต่ละตัวแตกต่างกัน<< . Попытка поставить две переменные вместе с одним оператором сдвига << выдаст сообщение об ошибке . Не забудьте поставить точку с запятой. Если вы забыли про точку с запятой, компилятор выдаст вам сообщение об ошибке при попытке скомпилировать программу.

การเปลี่ยนแปลงและการเปรียบเทียบค่า

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

* การคูณ
- การลบ
+ นอกจากนี้
/ แผนก,
= การมอบหมาย,
== ความเท่าเทียมกัน
> มากขึ้น
< меньше.
!= ไม่เท่ากัน
>= มากกว่าหรือเท่ากับ
<= меньше или равно

ต้องใช้ตัวดำเนินการที่ทำหน้าที่ทางคณิตศาสตร์ทางด้านขวาของเครื่องหมายกำหนด เพื่อกำหนดผลลัพธ์ให้กับตัวแปรทางด้านซ้าย

นี่คือตัวอย่างบางส่วน:

ก = 4 * 6; // ใช้บรรทัด comment และเครื่องหมายอัฒภาค a คือ 24 a = a + 5; // เท่ากับผลรวมของค่าเดิมและห้า a == 5 // ไม่ได้กำหนดห้า ตรวจสอบ และเท่ากับ 5 หรือไม่

คุณมักจะใช้ == ในการสร้างเช่นคำสั่งเงื่อนไขและลูป

ก< 5 // Проверка, a менее пяти? a >5 // ตรวจสอบว่า a มากกว่า 5 หรือไม่ a == 5 // ตรวจสอบว่า a เป็นห้าหรือไม่ a != 5 // ตรวจสอบว่า a ไม่เท่ากับ 5 หรือไม่ a >= 5 // ตรวจสอบว่า a มากกว่าหรือเท่ากับ 5 หรือไม่ ก<= 5 // Проверка, a меньше или равно пяти?

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