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

คำนี้มักใช้เพื่อเปรียบเทียบกับการเขียนโปรแกรมเชิงประกาศซึ่งมุ่งเน้นไปที่สิ่งที่โปรแกรมควรทำสำเร็จโดยไม่ต้องระบุรายละเอียดทั้งหมดของวิธีการที่โปรแกรมจะบรรลุผลลัพธ์^{[ 2 ]}

การเขียนโปรแกรมเชิงขั้นตอน (Procedural programming)เป็นรูปแบบหนึ่งของการเขียนโปรแกรมเชิงคำสั่ง (Imperative programming) โดยที่โปรแกรมถูกสร้างขึ้นจากขั้นตอนหนึ่งหรือมากกว่า (เรียกอีกอย่างว่าซับรูทีนหรือฟังก์ชัน) คำศัพท์เหล่านี้มักใช้เป็นคำพ้องความหมาย แต่การใช้ขั้นตอนมีผลอย่างมากต่อลักษณะและโครงสร้างของโปรแกรมเชิงคำสั่ง การเขียนโปรแกรมเชิงขั้นตอนแบบเข้มข้น (Heavy procedural programming) ซึ่ง การเปลี่ยนแปลง สถานะถูกจำกัดไว้ในขั้นตอนหรือจำกัดไว้เฉพาะอาร์กิวเมนต์และค่าส่งคืนจากขั้นตอนเท่านั้น เป็นรูปแบบหนึ่งของการเขียนโปรแกรมเชิงโครงสร้าง (Structured programming ) ตั้งแต่ทศวรรษ 1960 เป็นต้นมา การเขียนโปรแกรมเชิงโครงสร้างและการเขียนโปรแกรมแบบโมดูลาร์โดยทั่วไปได้รับการส่งเสริมให้เป็นเทคนิคในการปรับปรุงความสามารถในการบำรุงรักษาและคุณภาพโดยรวมของโปรแกรมเชิงคำสั่ง แนวคิดเบื้องหลังการเขียนโปรแกรมเชิงวัตถุ (Object-oriented programming)พยายามที่จะขยายแนวทางนี้

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

รูปแบบการเขียนโปรแกรมที่ใช้ในการสร้างโปรแกรมสำหรับคอมพิวเตอร์เกือบทั้งหมดโดยทั่วไปจะใช้รูปแบบเชิงคำสั่ง^{[หมายเหตุ 1 ]}ฮาร์ดแวร์คอมพิวเตอร์ดิจิทัลได้รับการออกแบบมาเพื่อประมวลผลรหัสเครื่องซึ่งเป็นรหัสพื้นฐานของคอมพิวเตอร์และมักเขียนในรูปแบบเชิงคำสั่ง แม้ว่าจะมีคอมไพเลอร์และตัวแปลภาษาแบบระดับต่ำที่ใช้รูปแบบอื่นสำหรับสถาปัตยกรรมบางอย่าง เช่นเครื่อง Lispก็ตาม

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

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

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

ภาษาเชิงคำสั่งยุคแรกสุดคือภาษาเครื่องของคอมพิวเตอร์รุ่นแรกๆ ในภาษาเหล่านี้ คำสั่งนั้นง่ายมาก ซึ่งทำให้การนำไปใช้ในฮาร์ดแวร์ง่ายขึ้น แต่ก็เป็นอุปสรรคต่อการสร้างโปรแกรมที่ซับซ้อน ฟ อร์ทราน ( Fortran)ซึ่งพัฒนาโดยจอห์น แบคคัส (John Backus)ที่บริษัทไอบีเอ็ม (IBM) ในปี 1954 เป็นภาษาโปรแกรมหลักภาษาแรกที่ขจัดอุปสรรคที่เกิดจากรหัสเครื่องในการสร้างโปรแกรมที่ซับซ้อน ฟอร์ทรานเป็นภาษาคอมไพล์ที่อนุญาตให้ใช้ตัวแปรที่มีชื่อ นิพจน์ที่ซับซ้อน โปรแกรมย่อย และคุณสมบัติอื่นๆ อีกมากมายที่พบได้ทั่วไปในภาษาเชิงคำสั่งในปัจจุบัน สองทศวรรษต่อมาได้มีการพัฒนาภาษาโปรแกรมเชิงคำสั่งระดับสูงอื่นๆ อีกมากมาย ในช่วงปลายทศวรรษ 1950 และ 1960 ภาษาALGOLได้รับการพัฒนาขึ้นเพื่อให้สามารถแสดงอัลกอริทึมทางคณิตศาสตร์ได้ง่ายขึ้น และยังทำหน้าที่เป็นภาษาเป้าหมายของระบบปฏิบัติการ สำหรับคอมพิวเตอร์บางเครื่องอีกด้วย MUMPS (1966) นำเอาแนวคิดการเขียนโปรแกรมเชิงคำสั่งไปสู่จุดสุดขั้วทางตรรกะ โดยไม่มีคำสั่งใดๆ เลย อาศัยเพียงคำสั่งอย่างเดียว แม้กระทั่งทำให้คำสั่ง IF และ ELSE เป็นอิสระต่อกัน โดยเชื่อมต่อกันด้วยตัวแปรภายในชื่อ $TEST เท่านั้นCOBOL (1960) และBASIC (1964) ต่างก็เป็นความพยายามที่จะทำให้ไวยากรณ์การเขียนโปรแกรมดูคล้ายกับภาษาอังกฤษมากขึ้น ในช่วงทศวรรษ 1970 ภาษา Pascalได้รับการพัฒนาโดยNiklaus Wirthและภาษา Cถูกสร้างขึ้นโดยDennis Ritchieขณะที่เขาทำงานอยู่ที่Bell Laboratories Wirth ยังได้ออกแบบ Modula-2และOberonต่อมาสำหรับความต้องการของกระทรวงกลาโหมสหรัฐฯ Jean Ichbiahและทีมงานที่Honeywellเริ่มออกแบบAdaในปี 1978 หลังจากโครงการ 4 ปีในการกำหนดข้อกำหนดสำหรับภาษา ข้อกำหนดดังกล่าวได้รับการเผยแพร่ครั้งแรกในปี 1983 โดยมีการแก้ไขเพิ่มเติมในปี 1995, 2005 และ 2012

ทศวรรษ 1980 ความสนใจในการเขียนโปรแกรมเชิงวัตถุ เติบโตอย่างรวดเร็ว ภาษาเหล่านี้มีรูปแบบเชิงคำสั่ง แต่เพิ่มคุณสมบัติเพื่อรองรับวัตถุสองทศวรรษสุดท้ายของศตวรรษที่ 20 ได้เห็นการพัฒนาภาษาดังกล่าวมากมายSmalltalk -80 ซึ่งคิดค้นโดยAlan Kayในปี 1969 ได้รับการเผยแพร่ในปี 1980 โดยศูนย์วิจัย Xerox Palo Alto ( PARC ) โดยดึงแนวคิดจากภาษาเชิงวัตถุอีกภาษาหนึ่งคือSimula (ซึ่งถือเป็น ภาษาการเขียนโปรแกรมเชิงวัตถุภาษาแรกของโลกพัฒนาขึ้นในทศวรรษ 1960) Bjarne Stroustrupได้ออกแบบC++ซึ่งเป็นภาษาเชิงวัตถุที่อิงจากภาษา CการออกแบบC++เริ่มขึ้นในปี 1979 และการใช้งานครั้งแรกเสร็จสมบูรณ์ในปี 1983 ในช่วงปลายทศวรรษ 1980 และ 1990 ภาษาเชิงคำสั่งที่โดดเด่นซึ่งดึงแนวคิดเชิงวัตถุมาใช้ ได้แก่Perlซึ่งเผยแพร่โดยLarry Wallในปี 1987 ภาษา Pythonที่เผยแพร่โดยGuido van Rossumในปี 1990; Visual BasicและVisual C++ (ซึ่งรวมถึงMicrosoft Foundation Class Library (MFC) 2.0) ที่เผยแพร่โดยMicrosoftในปี 1991 และ 1993 ตามลำดับ; PHPที่เผยแพร่โดยRasmus Lerdorfในปี 1994; JavaโดยJames Gosling ( Sun Microsystems ) ในปี 1995; JavaScriptโดยBrendan Eich ( Netscape ); และRubyโดย Yukihiro "Matz" Matsumoto ซึ่งทั้งสองภาษาเผยแพร่ในปี 1995 เฟรมเวิร์ก .NET ของ Microsoft (2002) เป็นภาษาเชิงคำสั่งเป็นหลัก เช่นเดียวกับภาษาเป้าหมายหลักอย่างVB.NETและC# ที่ทำงานบนเฟรมเวิร์กนี้ อย่างไรก็ตาม F#ของ Microsoft ซึ่งเป็นภาษาเชิงฟังก์ชัน ก็สามารถทำงานบน เฟรมเวิร์กนี้ได้เช่นกัน

ภาษาฟอร์ทราน (Fortran) เปิดตัวในปี 1958 ในชื่อ "ระบบแปลงสูตรทางคณิตศาสตร์ของ IBM" ออกแบบมาเพื่อการคำนวณทางวิทยาศาสตร์ โดยไม่มี ฟังก์ชันการจัดการ สตริงนอกจากการประกาศตัวแปร นิพจน์และคำสั่งแล้ว ยังรองรับสิ่งต่อไปนี้:

• อาร์เรย์
• ซับรูทีน
• ลูป "do"

มันประสบความสำเร็จเพราะ:

• ค่าใช้จ่ายในการเขียนโปรแกรมและแก้ไขข้อผิดพลาดต่ำกว่าค่าใช้จ่ายในการใช้งานคอมพิวเตอร์
• ได้รับการสนับสนุนจาก IBM
• แอปพลิเคชันในขณะนั้นเป็นไปในเชิงวิทยาศาสตร์^{[ 3 ]}

อย่างไรก็ตาม ผู้จำหน่ายที่ไม่ใช่ IBM ก็ได้เขียนคอมไพเลอร์ Fortran เช่นกัน แต่มีไวยากรณ์ที่อาจทำให้คอมไพเลอร์ของ IBM ล้มเหลว^{[ 3 ]}สถาบันมาตรฐานแห่งชาติอเมริกัน (ANSI) ได้พัฒนามาตรฐาน Fortran ฉบับแรกในปี 1966 ในปี 1978 Fortran 77 ได้กลายเป็นมาตรฐานจนถึงปี 1991 Fortran 90 รองรับ:

• บันทึก
• ตัวชี้ไปยังอาร์เรย์

COBOL (1959) ย่อมาจาก "COmmon Business Oriented Language" ภาษา Fortran ใช้สัญลักษณ์ในการประมวลผล ต่อมาจึงได้ตระหนักว่าสัญลักษณ์ไม่จำเป็นต้องเป็นตัวเลข จึงได้มีการนำสตริงมาใช้^{[ 4 ]}กระทรวงกลาโหมสหรัฐฯมีอิทธิพลต่อการพัฒนา COBOL โดยGrace Hopperเป็นผู้มีส่วนร่วมสำคัญ คำสั่งต่างๆ มีลักษณะคล้ายภาษาอังกฤษและค่อนข้างละเอียด เป้าหมายคือการออกแบบภาษาเพื่อให้ผู้จัดการสามารถอ่านโปรแกรมได้ อย่างไรก็ตาม การขาดคำสั่งที่มีโครงสร้างทำให้เป้าหมายนี้เป็นไปได้ยาก^{[ 5 ]}

การพัฒนา COBOL ถูกควบคุมอย่างเข้มงวด ดังนั้นจึงไม่มีภาษาถิ่นเกิดขึ้นที่ต้องใช้มาตรฐาน ANSI ส่งผลให้ไม่มีการเปลี่ยนแปลงเป็นเวลา 15 ปี จนกระทั่งปี 1974 เวอร์ชันในช่วงทศวรรษ 1990 มีการเปลี่ยนแปลงที่สำคัญ เช่น การ เขียนโปรแกรมเชิงวัตถุ^{[ 5 ]}

ALGOL (1960) ย่อมาจาก "ALGOrithmic Language" ซึ่งมีอิทธิพลอย่างมากต่อการออกแบบภาษาโปรแกรม^{[ 6 ]}เกิดขึ้นจากคณะกรรมการผู้เชี่ยวชาญด้านภาษาโปรแกรมจากยุโรปและอเมริกา โดยใช้สัญลักษณ์ทางคณิตศาสตร์มาตรฐานและมีโครงสร้างการออกแบบที่อ่านง่าย ALGOL เป็นภาษาแรกที่กำหนดไวยากรณ์โดยใช้รูปแบบ Backus–Naur [ ^{6 ] ซึ่ง}นำไปสู่ คอมไพเลอร์ ที่กำกับด้วยไวยากรณ์ นอกจากนี้ ยังเพิ่มคุณสมบัติต่างๆ เช่น:

• โครงสร้างแบบบล็อก โดยที่ตัวแปรต่างๆ จะอยู่เฉพาะภายในบล็อกนั้นๆ
• อาร์เรย์ที่มีขอบเขตแปรผันได้
• ลูป "for"
• ฟังก์ชัน
• การเรียกซ้ำ^{[ 6 ]}

^ภาษาที่สืบทอดโดยตรงจาก ALGOL ได้แก่Pascal , Modula-2 , Ada , DelphiและOberonในสาขาหนึ่ง ส่วนในอีกสาขาหนึ่งมีC , C++และJava ^{[ 6} ]

BASIC (1964) ย่อมาจาก "Beginner's All Purpose Symbolic Instruction Code" ซึ่งพัฒนาขึ้นที่วิทยาลัยดาร์ทมัธเพื่อให้นักเรียนทุกคนได้เรียนรู้^{[ 7 ]}หากนักเรียนไม่ได้เรียนต่อในภาษาที่มีประสิทธิภาพมากกว่า นักเรียนก็ยังคงจำ BASIC ได้^{[ 7 ]}มีการติดตั้งตัวแปลภาษา BASIC ในไมโครคอมพิวเตอร์ที่ผลิตในช่วงปลายทศวรรษ 1970 เมื่ออุตสาหกรรมไมโครคอมพิวเตอร์เติบโตขึ้น ภาษา BASIC ก็เติบโตขึ้นเช่นกัน^{[ 7 ]}

BASIC เป็นผู้บุกเบิกเซสชันแบบโต้ตอบ^{[ 7 ]}โดยนำเสนอ คำสั่ง ระบบปฏิบัติการภายในสภาพแวดล้อมของมัน:

• คำสั่ง 'new' สร้างหน้าว่างเปล่าขึ้นมา
• คำแถลงจะได้รับการประเมินทันที
• สามารถตั้งโปรแกรมคำสั่งได้โดยใส่หมายเลขบรรทัดนำหน้าคำสั่งนั้น
• คำสั่ง 'list' แสดงผลโปรแกรมออกมา
• คำสั่ง 'run' ได้ทำการเรียกใช้โปรแกรม

อย่างไรก็ตาม ไวยากรณ์ BASIC นั้นง่ายเกินไปสำหรับโปรแกรมขนาดใหญ่^{[ 7 ]}ภาษาถิ่นล่าสุดได้เพิ่มโครงสร้างและส่วนขยายเชิงวัตถุVisual Basic ของ Microsoft ยังคงใช้กันอย่างแพร่หลายและสร้าง อินเทอร์เฟ ซผู้ใช้แบบกราฟิก^{[ 8 ]}

ภาษาโปรแกรม C (1973) ได้รับชื่อนี้เนื่องจากภาษาBCPLถูกแทนที่ด้วยBและAT&T Bell Labsเรียกเวอร์ชันถัดไปว่า "C" จุดประสงค์คือเพื่อเขียนระบบปฏิบัติการUNIX ^{[ 9 ]} C เป็นภาษาที่มีขนาดค่อนข้างเล็ก ทำให้เขียนคอมไพเลอร์ได้ง่าย การเติบโตของมันสะท้อนให้เห็นถึงการเติบโตของฮาร์ดแวร์ในช่วงทศวรรษ 1980 ^{[ 9 ]}การเติบโตของมันยังเป็นเพราะมีคุณสมบัติของภาษาแอสเซมบลีแต่ใช้ไวยากรณ์ระดับสูงมันได้เพิ่มคุณสมบัติขั้นสูงเช่น:

• ตัวประกอบแบบอินไลน์
• การคำนวณเลขคณิตบนตัวชี้
• ตัวชี้ไปยังฟังก์ชัน
• การดำเนินการบิต
• การรวม ตัวดำเนินการที่ซับซ้อนอย่างอิสระ^{[ 9 ]}

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

• ส่วนข้อมูลส่วนกลางและคงที่นั้นตั้งอยู่เหนือ ส่วน โปรแกรม (ส่วนโปรแกรมในทางเทคนิคเรียกว่า ส่วน ข้อความซึ่งเป็นที่เก็บคำสั่งของเครื่อง)
  • พื้นที่ข้อมูลทั่วโลกและคงที่นั้นในทางเทคนิคแล้วประกอบด้วยสองพื้นที่^{[ 10 ]}พื้นที่หนึ่งเรียกว่าส่วนข้อมูลที่เริ่มต้นแล้วซึ่งเป็นที่เก็บตัวแปรที่ประกาศด้วยค่าเริ่มต้น อีกพื้นที่หนึ่งเรียกว่าส่วนบล็อกที่เริ่มต้นโดยซึ่งเป็นที่เก็บตัวแปรที่ประกาศโดยไม่มีค่าเริ่มต้น
  • ตัวแปรที่จัดเก็บในพื้นที่ข้อมูลส่วนกลางและแบบคงที่ จะถูกกำหนด ที่อยู่เมื่อทำการคอมไพล์ และจะคงค่าเดิมไว้ตลอดอายุการใช้งานของกระบวนการ
  • พื้นที่ทั่วโลกและคงที่จัดเก็บตัวแปรทั่วโลกที่ประกาศไว้ด้านบน (ภายนอก) main()ฟังก์ชัน^{[ 11 ]}ตัวแปรทั่วโลกสามารถมองเห็นได้main()โดยทุกฟังก์ชันอื่นในซอร์สโค้ด
• ในทางกลับกัน การประกาศตัวแปรภายในmain()ฟังก์ชันอื่น หรือภายใน{}ตัวคั่นบล็อก ถือเป็นตัวแปรโลคอลตัวแปรโลคอลยังรวมถึงตัวแปรพารามิเตอร์อย่างเป็นทางการด้วย ตัวแปรพารามิเตอร์จะอยู่ภายในวงเล็บของคำจำกัดความฟังก์ชัน^{[ 12 ]}พวกมันทำหน้าที่เป็นอินเทอร์เฟซให้กับฟังก์ชัน
  • ตัวแปรโลคอลที่ประกาศโดยใช้staticคำนำหน้าจะถูกจัดเก็บไว้ในพื้นที่ข้อมูลส่วนกลางและคงที่ด้วย^{[ 10 ]}ต่างจากตัวแปรส่วนกลาง ตัวแปรคงที่สามารถมองเห็นได้เฉพาะภายในฟังก์ชันหรือบล็อกเท่านั้น ตัวแปรคงที่ยังคงรักษาค่าของมันไว้เสมอ ตัวอย่างการใช้งานคือฟังก์ชัน

    int increment_counter () { static int counter = 0 ; counter ++ ; return counter ; }

• พื้นที่ สแต็กเป็นบล็อกหน่วยความจำที่ต่อเนื่องกันซึ่งอยู่ใกล้กับที่อยู่หน่วยความจำด้านบน^{[ 13 ]}ตัวแปรที่อยู่ในสแต็กจะถูกเติมจากบนลงล่าง^{[ 13 ]}ตัวชี้สแต็ก เป็น รีจิสเตอร์เฉพาะที่ใช้ติดตามที่อยู่หน่วยความจำสุดท้ายที่ถูกเติม^{[ 13 ]}ตัวแปรจะถูกวางลงในสแต็กโดยใช้ คำสั่ง PUSH ของ ภาษาแอสเซมบลีดังนั้น ที่อยู่ของตัวแปรเหล่านี้จึงถูกตั้งค่าในระหว่างการทำงานวิธีการที่ทำให้ตัวแปรในสแต็กสูญเสียขอบเขตคือการใช้คำสั่ง POP
  • ตัวแปรโลคอลที่ประกาศโดยไม่มีstaticคำนำหน้า รวมถึงตัวแปรพารามิเตอร์อย่างเป็นทางการ^{[ 14 ]}เรียกว่าตัวแปรอัตโนมัติ^{[ 11 ]}และจะถูกเก็บไว้ในสแต็ก^{[ 10 ]}ตัวแปรเหล่านี้สามารถมองเห็นได้ภายในฟังก์ชันหรือบล็อก และจะสูญเสียขอบเขตเมื่อออกจากฟังก์ชันหรือบล็อก
  • พื้นที่ฮีปตั้งอยู่ด้านล่างของสแต็ก^{[ 10 ]}มันถูกเติมจากล่างขึ้นบนระบบปฏิบัติการจัดการฮีปโดยใช้ตัวชี้ฮีปและรายการของบล็อกหน่วยความจำที่จัดสรร^{[ 15 ]}เช่นเดียวกับสแต็ก ที่อยู่ของตัวแปรฮีปจะถูกตั้งค่าในระหว่างการทำงาน ข้อผิดพลาด หน่วยความจำไม่เพียงพอจะเกิดขึ้นเมื่อตัวชี้ฮีปและตัวชี้สแต็กมาบรรจบกัน
  • Cมีmalloc()ฟังก์ชันไลบรารีสำหรับจัดสรรหน่วยความจำฮีป^{[ 16 ]}การเติมข้อมูลลงในฮีปเป็นฟังก์ชันการคัดลอกเพิ่มเติม ตัวแปรที่จัดเก็บในฮีปจะถูกส่งไปยังฟังก์ชันโดยใช้พอยเตอร์อย่างประหยัด หากไม่มีพอยเตอร์ ข้อมูลทั้งบล็อกจะต้องถูกส่งไปยังฟังก์ชันผ่านทางสแต็ก

ในช่วงทศวรรษ 1970 วิศวกรซอฟต์แวร์ต้องการการสนับสนุนทางภาษาเพื่อแบ่งโครงการขนาดใหญ่ออกเป็นโมดูล[ ^{17 ] คุณสมบัติ}ที่เห็นได้ชัดอย่างหนึ่งคือการแบ่งโครงการขนาดใหญ่ออก เป็น ไฟล์แยกต่างหากคุณสมบัติที่ไม่ชัดเจนนักคือการแบ่งโครงการขนาดใหญ่ออกเป็นประเภทข้อมูลนามธรรม^{[ 17 ]}ในขณะนั้น ภาษาต่างๆ รองรับประเภทข้อมูลที่เป็นรูปธรรม ( สเกลาร์ ) เช่นจำนวนเต็ม จำนวน ทศนิยมและสตริงของอักขระประเภทข้อมูลที่เป็นรูปธรรมมีการแสดงเป็นส่วนหนึ่งของชื่อ^{[ 18 ]}ประเภทข้อมูลนามธรรมเป็นโครงสร้างของประเภทข้อมูลที่เป็นรูปธรรม โดยมีการกำหนดชื่อใหม่ ตัวอย่างเช่นรายการของจำนวนเต็มอาจเรียกว่า integer_list

ในศัพท์เฉพาะเชิงวัตถุ ข้อมูลประเภทนามธรรมเรียกว่าคลาสอย่างไรก็ตามคลาสเป็นเพียงคำจำกัดความเท่านั้น ไม่มีการจัดสรรหน่วยความจำ เมื่อมีการจัดสรรหน่วยความจำให้กับคลาส จะเรียกว่าวัตถุ^{[ 19 ]}

ภาษาเชิงวัตถุแบบคำสั่งได้รับการพัฒนาโดยการผสมผสานความต้องการคลาสและความต้องการการเขียนโปรแกรมเชิงฟังก์ชันที่ปลอดภัย[ 20 ^{]ในภาษา}เชิงวัตถุ ฟังก์ชันจะถูกกำหนดให้กับคลาส ฟังก์ชันที่กำหนดแล้วจะถูกเรียกว่าเมธอดฟังก์ชันสมาชิกหรือการดำเนินการ การ เขียน^{โปรแกรม}เชิงวัตถุคือการดำเนินการกับวัตถุ^[ 21 ^]

ภาษาเชิงวัตถุสนับสนุนไวยากรณ์เพื่อจำลอง ความสัมพันธ์ระหว่าง เซตย่อยและเซตใหญ่ในทฤษฎีเซต องค์ประกอบของเซตย่อยจะสืบทอดคุณลักษณะทั้งหมดที่มีอยู่ในเซตใหญ่ ตัวอย่างเช่น นักเรียนเป็นบุคคล ดังนั้น เซตของนักเรียนจึงเป็นเซตย่อยของเซตของบุคคล ผลที่ตามมาคือ นักเรียนจะสืบทอดคุณลักษณะทั้งหมดที่เหมือนกันในบุคคลทั้งหมด นอกจากนี้ นักเรียนยังมีคุณลักษณะเฉพาะที่บุคคลอื่นไม่มีภาษาเชิงวัตถุจำลอง ความสัมพันธ์ ระหว่างเซตย่อยและเซตใหญ่โดยใช้การสืบทอด^{[ 22 ]}การเขียนโปรแกรมเชิงวัตถุกลายเป็นกระบวนทัศน์ภาษาที่โดดเด่นในช่วงปลายทศวรรษ 1990 ^{[ 17 ]}

C++ (1985) เดิมทีเรียกว่า "C ที่มีคลาส" ^{[ 23 ]}ออกแบบมาเพื่อขยายขีด ความสามารถ ของ Cโดยเพิ่มสิ่งอำนวยความสะดวกเชิงวัตถุของภาษาSimula ^{[ 24 ]}

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

// grade.h // -------// ใช้เพื่ออนุญาตให้ไฟล์ต้นฉบับหลายไฟล์สามารถรวมไฟล์ส่วนหัวนี้ได้โดยไม่เกิดข้อผิดพลาดจากการทำซ้ำ// ดู: https://en.wikipedia.org/wiki/Include_guard // ---------------------------------------------- #ifndef GRADE_H #define GRADE_HคลาสGRADE { public : // นี่คือการดำเนินการของคอนสตรัคเตอร์// ---------------------------------- GRADE ( const char letter );// นี่คือตัวแปรคลาส// ------------------------- char letter ;// นี่คือการดำเนินการกับสมาชิก// --------------------------- int grade_numeric ( const char letter );// นี่คือตัวแปรคลาส// ------------------------- int numeric ; }; #endif

การ ดำเนินการ ตัวสร้างคือฟังก์ชันที่มีชื่อเดียวกันกับชื่อคลาส^{[ 25 ]}จะถูกดำเนินการเมื่อการดำเนินการที่เรียกใช้ดำเนินการnewคำสั่ง

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

// grade.cpp // --------- #include "grade.h"GRADE :: GRADE ( const char letter ) { // อ้างอิงถึงอ็อบเจ็กต์โดยใช้คีย์เวิร์ด 'this' // ---------------------------------------------- this -> letter = letter ;// นี่คือความสอดคล้องเชิงเวลา// ------------------------- this -> numeric = grade_numeric ( letter ); }int GRADE :: grade_numeric ( const char letter ) { if ( ( letter == 'A' || letter == 'a' ) ) return 4 ; else if ( ( letter == 'B' || letter == 'b' ) ) return 3 ; else if ( ( letter == 'C' || letter == 'c' ) ) return 2 ; else if ( ( letter == 'D' || letter == 'd' ) ) return 1 ; else if ( ( letter == 'F' || letter == 'f' ) ) return 0 ; else return -1 ; }

นี่คือ ไฟล์เฮดเดอร์ C++ สำหรับคลาส PERSONในแอปพลิเคชันโรงเรียนอย่างง่าย:

// person.h // -------- #ifndef PERSON_H #define PERSON_HคลาสPERSON { public : PERSON ( const char * name ); const char * name ; }; #endif

นี่คือ ไฟล์ซอร์สโค้ด C++ สำหรับคลาส PERSONในแอปพลิเคชันโรงเรียนอย่างง่าย:

// person.cpp // ---------- #include "person.h"บุคคล:: บุคคล( const char * name ) { this -> name = name ; }

นี่คือ ไฟล์เฮดเดอร์ C++ สำหรับคลาส STUDENTในแอปพลิเคชันโรงเรียนอย่างง่าย:

// student.h // --------- #ifndef STUDENT_H #define STUDENT_H#include "person.h" #include "grade.h"// นักเรียนเป็นส่วนย่อยของบุคคล// -------------------------------- class STUDENT : public PERSON { public : STUDENT ( const char * name ); ~ STUDENT (); GRADE * grade ; }; #endif

นี่คือ ไฟล์ซอร์สโค้ด C++ สำหรับคลาส STUDENTในแอปพลิเคชันโรงเรียนอย่างง่าย:

// student.cpp // ----------- #include "student.h" #include "person.h"นักเรียน:: นักเรียน( const char * name ) : // เรียกใช้คอนสตรัคเตอร์ของคลาสแม่ PERSON // ------------------------------------------------- PERSON ( name ) { // ไม่ต้องทำอะไรเพิ่มเติม// ------------------- }นักเรียน::~ นักเรียน() { // ปลดปล่อยหน่วยความจำของเกรด// เพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำ// ------------------------------------------------- ลบสิ่งนี้-> เกรด; }

นี่คือโปรแกรมไดรเวอร์สำหรับสาธิต:

// student_dvr.cpp // --------------- #include <iostream> #include "student.h"int main ( void ) { STUDENT * student = new STUDENT ( "The Student" ); student -> grade = new GRADE ( 'a' );std :: cout // สังเกตว่านักเรียนสืบทอดชื่อมาจาก PERSON << student- > name << ": เกรดตัวเลข = " << student- > grade- > numeric << " \n " ;// ยกเลิกการจัดสรรหน่วยความจำของนักเรียน// เพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำ// ------------------------------------------------- delete student ;ส่งคืนค่า0 ; }

นี่คือไฟล์ makefileสำหรับคอมไพล์ทุกอย่าง:

# makefile # -------- ทั้งหมด: student_dvrล้างไฟล์: rm student_dvr *.o student_dvr : student_dvr . cpp grade . o student . o person . o c++ student_dvr.cpp grade.o student.o person.o -o student_dvrgrade.o : grade.cpp grade.h c ++ -c grade.cpp​​​student.o : student.cpp student.h c ++ -c student.cpp​​​person.o : person.cpp person.h c ++ -c person.cpp ​​​

• โจเซฟ โกเกนและ แกรนท์ มัลคอล์ม "ความหมายเชิงพีชคณิตของโปรแกรมเชิงบังคับ" สำนักพิมพ์ MIT ปี 1966 ISBN 9780262071727