ลักษณะเฉพาะ

ทบทวน

ภาษาโปรแกรม C มีลักษณะแบบเรียบง่าย ผู้เขียนภาษาต้องการให้โปรแกรมต่างๆ ในภาษานั้นคอมไพล์ได้อย่างง่ายดายโดยใช้คอมไพเลอร์แบบ one-pass หลังจากการคอมไพล์แล้ว แต่ละส่วนประกอบพื้นฐานของโปรแกรมจะสอดคล้องกับคำสั่งเครื่องจำนวนน้อยมาก และการใช้องค์ประกอบพื้นฐานของภาษาไม่ได้ เกี่ยวข้องกับไลบรารีรันไทม์ คอมไพเลอร์แบบรอบเดียวจะคอมไพล์โปรแกรมโดยไม่ต้องกลับไปยังข้อความที่คอมไพล์แล้ว ดังนั้นการใช้ฟังก์ชันจะต้องนำหน้าด้วยการประกาศ รหัส C สามารถเขียนได้ง่ายในระดับนามธรรมต่ำ เกือบจะเหมือนกับภาษาแอสเซมบลี C บางครั้งเรียกว่า "universal assembler" หรือ "high-level assembler" ซึ่งสะท้อนถึงความแตกต่างในภาษาแอสเซมบลีสำหรับแพลตฟอร์มที่แตกต่างกันและความสามัคคีของมาตรฐาน C โค้ดที่สามารถคอมไพล์ได้โดยไม่ต้องเปลี่ยนแปลงในคอมพิวเตอร์เกือบทุกเครื่อง แบบอย่าง. C มักเรียกว่าภาษา ระดับกลางหรือแม้กระทั่ง ระดับต่ำโดยพิจารณาว่ามันทำงานได้ใกล้เคียงกับอุปกรณ์จริงแค่ไหน

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

โปรแกรม "สวัสดีชาวโลก!"

โปรแกรมง่ายๆ นี้ ซึ่งปรากฏใน The C Programming Language ฉบับพิมพ์ครั้งแรกโดย Kernighan และ Ritchie มักจะเป็นโปรแกรมแรกในหนังสือเรียน C ส่วนใหญ่ เธอพิมพ์ข้อความ "Hello World!" บนอุปกรณ์เอาท์พุตมาตรฐาน (ซึ่งโดยปกติจะเป็นมอนิเตอร์ (จอแสดงผล) แต่อาจเป็นไฟล์ อุปกรณ์บางตัว หรือพื้นที่ในหน่วยความจำก็ได้ ขึ้นอยู่กับว่าอุปกรณ์เอาท์พุตมาตรฐานจะสะท้อนให้เห็นบนแพลตฟอร์มที่กำหนดอย่างไร)

Main() ( printf ("สวัสดีชาวโลก! \n") ; }

แม้ว่าโปรแกรมนี้จะสามารถคอมไพล์ได้อย่างถูกต้องบนคอมไพเลอร์สมัยใหม่ส่วนใหญ่ แต่ก็สร้างคำเตือนหลายประการบนคอมไพเลอร์ ANSI C นอกจากนี้โค้ดนี้จะไม่คอมไพล์หากคอมไพเลอร์ปฏิบัติตามมาตรฐานอย่างเคร่งครัด

#รวม int main(void) ( printf ("สวัสดีชาวโลก! \n"-

กลับ 0 ; -

บรรทัดแรกของโปรแกรมประกอบด้วยคำสั่ง #include preprocessor เมื่อพบคำสั่งดังกล่าว คอมไพเลอร์จะแทนที่ด้วยข้อความเต็มของไฟล์ที่อ้างอิงถึง ในกรณีนี้ บรรทัดนี้จะถูกแทนที่ด้วยไฟล์ส่วนหัวมาตรฐาน บรรทัดถัดไปคือการประกาศฟังก์ชันที่เรียกว่า main ฟังก์ชันนี้ในโปรแกรม C มีลักษณะพิเศษ เนื่องจากจะถูกดำเนินการก่อนเมื่อโปรแกรมเริ่มทำงาน กล่าวคือ ทำหน้าที่เป็นฟังก์ชันที่เรียกว่า.

จุดเข้าสู่โปรแกรม

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

บรรทัดถัดไป "เรียก" หรือเรียกใช้ฟังก์ชัน stdio.h และมีข้อมูลที่อธิบายว่าควรเรียกใช้ฟังก์ชันอย่างไร ในตัวอย่างนี้ อาร์กิวเมนต์เดียวจะถูกส่งผ่านไปยังฟังก์ชันนี้ โดยมีสตริงข้อความ “Hello, World!\n” ลำดับ \n จะถูกแปลเป็นอักขระ "ขึ้นบรรทัดใหม่" ซึ่งเมื่อแสดงขึ้น จะหมายถึงการขึ้นบรรทัดใหม่ตามลำดับ ฟังก์ชัน printf ส่งกลับค่า int ซึ่งละทิ้งไปโดยสิ้นเชิงในตัวอย่างนี้

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

ความคิดเห็น

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

ประเภท

การจัดเก็บข้อมูล

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

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

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

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

ชุดสัญลักษณ์ที่ใช้

ภาษา C ถูกสร้างขึ้นหลังจากการแนะนำมาตรฐาน Fortran; Lisp และ Cobol ใช้เพียงวงเล็บ () แต่ C มีวงเล็บ () และสี่เหลี่ยมจัตุรัสและหยิก () นอกจากนี้ C ยังแยกความแตกต่างระหว่างตัวอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก ในขณะที่ภาษาเก่าใช้เฉพาะตัวอักษรตัวพิมพ์ใหญ่เท่านั้น

ปัญหา

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

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

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

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

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

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

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

เรื่องราว

การพัฒนาในช่วงแรก

ภาษาการเขียนโปรแกรม C ได้รับการพัฒนาที่ Bell Labs ระหว่างปี 1973 ถึง 1973 จากข้อมูลของ Ritchie ช่วงเวลาแห่งความคิดสร้างสรรค์ที่กระฉับกระเฉงที่สุดเกิดขึ้นในปี 1972 ภาษานี้เรียกว่า "C" (C คืออักษรตัวที่สามของอักษรละติน) เนื่องจากคุณลักษณะหลายอย่างมีต้นกำเนิดมาจากภาษาเก่า "B" (B คืออักษรตัวที่สองของอักษรละติน) ที่มาของชื่อ Bi มีหลายเวอร์ชัน Ken Thompson ชี้ไปที่ภาษาการเขียนโปรแกรม

มีหลายคำอธิบายเกี่ยวกับเหตุผลในการพัฒนา C และความสัมพันธ์กับระบบปฏิบัติการ เช่น สำหรับการแสดงผลแบบกราฟิก

คอมไพเลอร์บางตัวไม่ปฏิบัติตามมาตรฐาน ANSI C หรือตัวตายตัวแทนโดยค่าเริ่มต้น หรือ

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

C99

บทความหลัก: ในปี 1995 มีการแก้ไขกฎระเบียบครั้งแรกตามมาตรฐาน C แต่แทบไม่มีใครยอมรับ) อย่างไรก็ตาม ในช่วงปลายทศวรรษ 1990 มาตรฐานได้รับการแก้ไข ซึ่งนำไปสู่การตีพิมพ์ ISO 9899:1999ในปี 1999 มาตรฐานนี้มักเรียกว่า "C99" ในเดือนมีนาคม พ.ศ. 2543 ANSI ได้รับการรับรองและดัดแปลง

นี่คือคุณสมบัติใหม่ของ C99:

• ฟังก์ชั่นอินไลน์ (อินไลน์);
• ไม่มีข้อจำกัดในการประกาศตัวแปรท้องถิ่น (เช่นใน C ++)
• ชนิดข้อมูลใหม่ เช่น int แบบยาว (เพื่อให้เปลี่ยนจากตัวเลข 32 เป็น 64 บิตได้ง่ายขึ้น) ชนิดข้อมูลบูลีนที่ชัดเจน และชนิดเชิงซ้อนเพื่อแสดงจำนวนเชิงซ้อน
• อาร์เรย์ที่มีความยาวผันแปรได้
• รองรับพอยน์เตอร์ที่ถูกจำกัด (จำกัด);
• ชื่อการเริ่มต้นของโครงสร้าง: struct ( int x, y, z; ) point = ( .y=10, .z=20, .x=30 );
• รองรับความคิดเห็นบรรทัดเดียวที่ขึ้นต้นด้วย // ยืมมาจาก C ++ (คอมไพเลอร์ C หลายตัวรองรับก่อนหน้านี้เป็นส่วนเพิ่มเติม)
• ฟังก์ชั่นไลบรารีใหม่หลายอย่างเช่น snprintf;
• ไฟล์ส่วนหัวใหม่หลายไฟล์ เช่น stdint.h

ขณะนี้ความสนใจในการรองรับฟีเจอร์ใหม่ของ C99 มีความหลากหลาย แม้ว่า GCC, คอมไพเลอร์ C ของ Sun Microsystems และคอมไพเลอร์อื่นๆ อีกหลายตัวจะรองรับฟีเจอร์ C99 ใหม่ส่วนใหญ่ในปัจจุบัน แต่คอมไพเลอร์ของ Microsoft ไม่รองรับ และดูเหมือนว่าทั้งสองบริษัทจะไม่เพิ่มฟีเจอร์เหล่านี้เข้าไป

การเชื่อมต่อกับ C++

ลำดับความสำคัญของการดำเนินงานใน C

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

การดำเนินการ Postfix	() . -> ++ --
การดำเนินการ Unary (R->L)	- ขนาด (ชนิด)
การคูณ	* / %
สารเติมแต่ง	+ -
เฉือน	<< >>
การเปรียบเทียบการดำเนินงาน	< > <= >=
การดำเนินการทดสอบความเท่าเทียมกัน	== !=
ระดับบิต	& ^ |
ช่วยพัฒนาสมอง	&& ||
การทำงานแบบมีเงื่อนไข (R->L)	?:
การดำเนินการมอบหมาย (R->L)	= *= /= %= += -= <<= >>= &= ^= |=
การคำนวณตามลำดับ	,

คอมไพเลอร์ C ที่รู้จักกันดี

OpenWatcom

คอมไพเลอร์สำหรับภาษาและแพลตฟอร์มแบบไดนามิก

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

โครงการต่อไปนี้มีวัตถุประสงค์เพื่อวัตถุประสงค์เหล่านี้:

• Alchemy เป็นคอมไพเลอร์ C/C++ สำหรับแอปพลิเคชัน Flash และ Adobe AIR
• คอมไพเลอร์ AMPC - C สำหรับเครื่องเสมือน

  หมายเหตุ

  ดูสิ่งนี้ด้วย

  • Cyclone (ภาษาการเขียนโปรแกรม) - ภาษาถิ่นที่ปลอดภัยของภาษา C
  • หมวดหมู่:ซีคอมไพเลอร์

  ลิงค์

  • บ้านอย่างเป็นทางการของ ISO/IEC JTC1/SC22/WG14 (ภาษาอังกฤษ) - หน้าอย่างเป็นทางการของคณะทำงานระหว่างประเทศเกี่ยวกับมาตรฐานของภาษาโปรแกรม C สืบค้นเมื่อ 20 กุมภาพันธ์ 2552.

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

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

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

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

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

สภาพแวดล้อมและคอมไพเลอร์สำหรับการเขียนโปรแกรม C

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

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

C เป็นภาษาโปรแกรมคอมไพล์ ใน GNU/Linux เพื่อรับไฟล์ปฏิบัติการ GCC จะถูกใช้ - ชุดของคอมไพเลอร์รวมถึงคอมไพเลอร์สำหรับ C หากต้องการรับไฟล์ปฏิบัติการจากไฟล์ต้นฉบับ (โดยปกติแล้วไฟล์ดังกล่าวจะมีนามสกุล *.c) คุณต้องเรียกใช้ คำสั่งในเทอร์มินัลที่มีลักษณะดังนี้:

gcc -o สวัสดี hello.c

โดยที่ gcc คือคำสั่งที่เรียกทำงานโปรแกรมที่ดำเนินการคอมไพล์และการดำเนินการอื่นๆ -o – สวิตช์ระบุว่าเราระบุชื่อของไฟล์ปฏิบัติการด้วยตนเอง สวัสดี – ชื่อของไฟล์ปฏิบัติการที่เป็นผลลัพธ์ hello.c คือชื่อของไฟล์ซอร์สโค้ด ชื่อของไฟล์ปฏิบัติการสามารถละเว้นได้:

gcc สวัสดี.ซี

ในกรณีนี้ ไฟล์ปฏิบัติการจะมีชื่อเริ่มต้น a.out

Windows มีชุดคอมไพเลอร์ของตัวเอง - MinGW สามารถใช้เดี่ยวๆ ได้ แต่รวมอยู่ในสภาพแวดล้อมการพัฒนา Dev-C++ แบบธรรมดา ซึ่งเป็นทางเลือกที่ดีสำหรับการเรียนรู้การเขียนโปรแกรมใน C และ C++

เมื่อบันทึก ให้เลือกประเภทไฟล์ "ไฟล์ต้นฉบับ C (*.c)" โปรแกรมถูกคอมไพล์และเปิดใช้งานโดยการกดปุ่ม F9 หลังจากดำเนินการ โปรแกรมจะปิดทันทีและไม่สามารถมองเห็นผลลัพธ์ได้ เพื่อป้องกันไม่ให้สิ่งนี้เกิดขึ้น ให้เขียนเพิ่มเติมอีกสองบรรทัด: #include และ getch() (อาจไม่เกี่ยวข้องกับ Dev-C++ เวอร์ชันใหม่กว่า)

"สวัสดีชาวโลก" ใน GNU/Linux:

#รวม \n") ; }

"Hello World" บน Windows:

#รวม #รวม int main() (printf("Hello World \n"-

รับ(); -

ในทางกลับกัน มีสภาพแวดล้อมการพัฒนาข้ามแพลตฟอร์มจำนวนมาก ตัวอย่างเช่น โมดูล Eclipse + CDT, KDevelop, CLion อย่างหลังได้รับค่าตอบแทน ผลิตโดย JetBrains ผู้นำด้านการพัฒนา IDE แต่มีช่วงทดลองใช้งาน 30 วัน ซึ่งอาจเพียงพอสำหรับการฝึกอบรม CLion สะดวกกว่า IDE อื่นๆ

"สวัสดีชาวโลก" ใน C

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

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

ฟังก์ชัน printf() ออกแบบมาเพื่อพิมพ์ข้อมูล วัตถุประสงค์คล้ายกับขั้นตอน write() ใน Pascal และฟังก์ชัน print() ใน Python ฟังก์ชัน printf() จะไม่แตกเป็นบรรทัดใหม่หลังการพิมพ์ ดังนั้นจึงใช้อักขระพิเศษสำหรับการเปลี่ยนแปลง ซึ่งแสดงด้วยชุดค่าผสม \n นิพจน์ C ที่สมบูรณ์จะถูกคั่นด้วยเครื่องหมายอัฒภาค

ในภาษา C ฟังก์ชัน I/O ไม่ได้เป็นส่วนหนึ่งของภาษา ตัวอย่างเช่น ใน Python เราไม่จำเป็นต้องนำเข้าโมดูลใดๆ เพื่อใช้ฟังก์ชัน print() และ input() ในภาษาซี เราไม่สามารถเรียกใช้ฟังก์ชัน printf() ได้ง่ายๆ เพราะ C เองก็ไม่มีมัน ฟังก์ชันนี้รวมถึงฟังก์ชันอื่นๆ อีกมากมายสามารถเปิดใช้งานได้โดยใช้ไฟล์ส่วนหัว stdio.h นี่เป็นสาเหตุที่แน่ชัดว่าเหตุใดจึงเขียนบรรทัดไว้ที่จุดเริ่มต้นของโปรแกรม #รวม - รวม แปลจากภาษาอังกฤษว่า "เปิด" และ stdio เป็นตัวย่อของ "อินพุต-เอาต์พุตมาตรฐาน"

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

การปฏิบัติงาน

แสดงความคิดเห็นในบรรทัดแรกของโค้ด HelloWorld ลองคอมไพล์โปรแกรมครับ คุณสามารถรับไฟล์ปฏิบัติการได้หรือไม่? คอมไพเลอร์ให้คำเตือนอะไร?

1 // - ความคิดเห็นหนึ่งบรรทัดในภาษา C; /* … */ - ความคิดเห็นหลายบรรทัดในภาษา C

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

• ลูปมีสามประเภทหลัก: FOR, WHILE และ DO...WHILE

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

#รวม int main () ( int y ; สำหรับ ( y = 0 ; y< 15 ; y ++ ){ printf ( "%d \n " , y ); } getchar (); }

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

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

#รวม int main () ( int y ; ในขณะที่ ( y<= 15 ){ printf ( "%d \n " , y ); y ++ ; } getchar (); }

• คำสั่ง y++ จะเพิ่มค่าหนึ่งให้กับค่าของตัวแปร y ทุกครั้งที่ดำเนินการวนซ้ำ ทันทีที่ตัวแปร y กลายเป็น 16 (โปรดทราบว่าจะต้องดำเนินการวนซ้ำจนกระทั่งตัวแปร น้อยกว่าหรือเท่ากับ 15) วงจรจะหยุดลง

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

#รวม int main () ( int y ; y = 5 ; do ( printf ( "The loop is running! \n " ); ) while ( y != 5 ); getchar ( ; )

• การวนซ้ำนี้จะแสดงข้อความที่ต้องการแม้ว่าการทดสอบเงื่อนไขจะล้มเหลวก็ตาม ตัวแปร y ถูกตั้งค่าเป็น 5 และการวนซ้ำจะต้องทำซ้ำเมื่อตัวแปรไม่เท่ากับ 5 ดังนั้นจึงออกจากการวนซ้ำ ข้อความจะปรากฏบนหน้าจอหนึ่งครั้ง เนื่องจากมีการตรวจสอบเงื่อนไขในตอนท้ายสุดเท่านั้น
• ส่วนคำสั่ง WHILE ในลูป DO...WHILE จะต้องลงท้ายด้วยเครื่องหมายอัฒภาค นี่เป็นการวนซ้ำเดียวที่ต้องใช้เครื่องหมายอัฒภาคต่อท้าย

การเรียนรู้พื้นฐานและความซับซ้อนของภาษาการเขียนโปรแกรม 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 ++

สภาระหว่างภาคส่วนเพื่อการกำหนดมาตรฐานเทคโนโลยีสารสนเทศของคณะกรรมการ RSPP ว่าด้วยกฎระเบียบทางเทคนิค การกำหนดมาตรฐาน และการประเมินความสอดคล้อง

ล็อกอินเข้าสู่เว็บไซต์เก่า TK-MTK-22

โปรดแก้ตัวข้อผิดพลาดชั่วคราวใด ๆ พอร์ทัลอยู่ระหว่างการพัฒนา ดังนั้นบางส่วนจึงถูกบล็อกชั่วคราว

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

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

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

ทบทวนกิจกรรมหลักของคณะกรรมการกลาง SIT

การทำให้เป็นมาตรฐาน

มาตรฐานไอทีคืออะไร - ควรเป็นมาตรฐานไอที - ไม่ควรเป็นมาตรฐานไอที