โปรแกรม คือ ชุดคำสั่งที่สามารถประมวลผลโดยคอมพิวเตอร์ เพื่อให้ได้ผลการทำงานตามที่ผู้ใช้งานต้องการ โปรแกรมถูกพัฒนาขึ้นโดยอาศัยภาษาคอมพิวเตอร์ ภาษา C++ จัดเป็นภาษาคอมพิวเตอร์ภาษาหนึ่งที่มีความสามารถ และเป็นที่นิยมใช้อย่างแพร่หลาย ทั้งนี้เนื่องจากว่า ภาษา C++ เป็นภาษาที่เอื้อให้ผู้เขียนโปรแกรมสามารถพัฒนาโปรแกรมได้อย่างมีประสิทธิภาพ และ ยังเป็นภาษาที่รองรับการพัฒนาโปรแกรมเชิงวัตถุ (object-oriented program)
ในหัวข้อนี้ จะแสดงตัวอย่างโปรแกรมภาษา C++ อย่างง่าย เพื่อให้นักเรียนเห็นโครงร่างของโปรแกรมที่พัฒนาโดยใช้ภาษา C++
ตัวอย่าง 1.1 โปรแกรมแสดงข้อความ “Hello, World!”
#include <iostream> int main ( ) { std :: cout << "Hello, World! \n"; }
ทดสอบโปรแกรม
Hello, World!
บรรทัดแรกในโปรแกรมตัวอย่างเป็นคำสั่งประกาศตัวประมวลผลก่อน (preprocessor directive) เพื่อแจ้งแก่โปรแกรมแปลโปรแกรมภาษา C++ (C++ compiler) ให้รู้ว่า จะหานิยาม (definition) ของวัตถุ std :: cout เพื่อนำมาใช้งานในคำสั่งบรรทัดที่ 3 ได้จากที่ใด โดยคำสั่งประกาศในโปรแกรมจะต้องระบุสัญลักษณ์ # ไว้ก่อนหน้า เช่น #include เป็นต้น นิพจน์ <iostream> เป็นส่วนหัวมาตรฐาน (standard header) ของไฟล์ในคลังโปรแกรมภาษา C++ มาตรฐาน (standard C++ library) โดย iostream มาจากคำว่า input / output stream หมายถึง สายข้อมูลนำเข้าและส่งออก เป็นคลังโปรแกรมที่รวมนิยามของวัตถุที่เกี่ยวข้องกับการนำเข้าและส่งออกข้อมูล ไฟล์ส่วนหัวภาษา C++ ต้องเขียนอยู่ภายในเครื่องหมาย < > เสมอ
ในบรรทัดที่ 2 เป็นส่วนเริ่มต้นของโปรแกรม โดยทุกโปรแกรมในภาษา C++ ต้องประกอบด้วยฟังก์ชันอย่างน้อยหนึ่งฟังก์ชันที่ชื่อ main เสมอ โดยฟังก์ชัน main ( ) จะเป็นฟังก์ชันแรกที่จะถูกนำไปประมวลผล สัญลักษณ์ ( ) เป็นสิ่งที่ระบุว่า main เป็นชื่อของฟังก์ชัน คำว่า int เป็นคำสงวนมาจากคำว่า integer ซึ่งหมายถึง ข้อมูลชนิดจำนวนเต็มในภาษา C++ เป็นคำที่บ่งบอกว่าชนิดข้อมูลที่ฟังก์ชัน main จะส่งค่ากลับ คือ ข้อมูลชนิดจำนวนเต็ม ภาษา C++ เป็นภาษาที่อ่อนไหวต่อตัวพิมพ์ (case-sensitive) ดังนั้น การตั้งชื่อในภาษา C++ ถ้าใช้ตัวพิมพ์ที่ต่างกัน จะถือว่าเป็นคนละชื่อ กล่าวคือ ชื่อ main( ) จะถือว่าเป็นคนละชื่อกับ Main( )
บรรทัดสุดท้ายเป็นส่วนโครงร่างของโปรแกรม (program body) ที่ประกอบด้วยชุดลำดับของคำสั่งเขียนอยู่ภายในเครื่องหมาย { } โดยโปรแกรมตัวอย่างประกอบด้วยคำสั่งเพียง 1 คำสั่ง คือ
std :: cout << "Hello, World! \n";
ซึ่งเป็นคำสั่งที่มีผลการทำงานให้นำสายอักขระ (string) “Hello, World! \n” ไปใส่ในวัตถุ std :: cout ผลที่เกิดขึ้น คือ ข้อความ Hello, World! จะถูกแสดงออกทางจอภาพ แล้วขึ้นบรรทัดใหม่
สายอักขระในภาษา C++ จะเขียนอยู่ภายในเครื่องหมาย “ ” สำหรับ \n จะแทนอักขระขึ้นบรรทัดใหม่ (newline character) ซึ่งเป็นอักขระที่ไม่แสดงค่าสัญลักษณ์ตัวพิมพ์ แต่แสดงผลการเลื่อนตัวชี้ตำแหน่ง (cursor) ไปที่ตำแหน่งแรกของบรรทัดถัดไป แล้วทำการล้างข้อมูลในบัฟเฟอร์ (buffer) ของวัตถุ iostream ด้วย
สัญลักษณ์ << เป็นตัวดำเนินการส่งออกข้อมูล (output operator) ที่กระทำกับวัตถุ std :: cout ในการส่งข้อมูลของนิพจน์ที่อยู่ทางขวาของตัวดำเนินการทีละตัวไปยังบัฟเฟอร์ของวัตถุ iostream และเมื่อประมวลผล ข้อมูลในบัฟเฟอร์จะแสดงออกทางอุปกรณ์ส่งออก (จอภาพ)
เครื่องหมาย ; เป็นสัญลักษณ์ที่ใช้เพื่อระบุการจบคำสั่ง โดยทุกคำสั่งในโปรแกรมจะต้องปิดท้ายด้วยเครื่องหมาย ; เสมอ
บรรทัดใหม่ในโปรแกรมไม่ได้หมายถึงการเขียนคำสั่งใหม่ เพราะฉะนั้น ในโปรแกรมภาษา C++ ผู้เขียนโปรแกรมอาจเขียนทุกคำสั่งในโปรแกรมไว้ในบรรทัดเดียวกันก็ได้ ยกเว้นส่วนของคำสั่งประกาศ เช่น
#include <iostream> int main ( ) { std :: cout << "Hello, World! \n";}
อย่างไรก็ดี การเขียนทุกคำสั่งในบรรทัดเดียวกันอย่างต่อเนื่อง ทำให้โปรแกรมที่พัฒนายากแก่การอ่านและทำความเข้าใจ หลักการเขียนโปรแกรมโดยทั่วไป จึงนิยมเขียนคำสั่งแต่ละคำสั่งไว้คนละบรรทัด ดังแสดงในตัวอย่าง 1.1
ตัวอย่าง 1.2 โปรแกรมแสดงข้อความ “Hello, World!” ตัวอย่างที่ 2
#include <iostream> using namespace std; int main ( ) { // prints Hello World! cout << "Hello, World! \n"; return 0; }
ทดสอบโปรแกรม
Hello, World!
ในบรรทัดที่ 2 เขียนคำสั่ง
using namespace std;
เพื่อกำหนดให้ใช้ตัวเติมหน้า (prefix) std :: กับวัตถุทุกตัวในโปรแกรมที่ต้องมีการระบุตัวเติมหน้า เช่น cout ทำให้โปรแกรมอ่านง่ายขึ้น โดยเฉพาะกับโปรแกรมที่มีขนาดใหญ่ๆ
เครื่องหมาย // ในบรรทัดที่ 4 เป็นสัญลักษณ์ที่ใช้ระบุส่วนหมายเหตุ (comment) ของโปรแกรม โดยโปรแกรมแปลโปรแกรมจะถือว่า ตั้งแต่ตำแหน่งดังกล่าวจนสิ้นสุดบรรทัดนั้นไม่เกี่ยวข้องกับโปรแกรม ในกรณีที่ต้องการระบุหมายเหตุมากกว่า 1 บรรทัด ผู้เขียนโปรแกรมสามารถใช้สัญลักษณ์ /* บอกจุดเริ่มต้นของหมายเหตุ และใช้สัญลักษณ์ */ บอกจุดสิ้นสุดของหมายเหตุ เช่น
/* prints Hello World! this line is also in a comment */
คำสั่งในบรรทัดที่ 6
return 0;
เป็นส่วนที่ละเว้นได้สำหรับฟังก์ชัน main ( ) ของภาษา C++ มาตรฐาน แต่สำหรับโปรแกรมแปลโปรแกรมภาษา C++ บางตัว เช่น Microsoft Visual C++ ยังจำเป็นต้องระบุคำสั่งดังกล่าวเป็นคำสั่งสุดท้ายในฟังก์ชัน main ( )
std ในโปรแกรม คือ namespace ซึ่งเป็นชื่อกลุ่มของนิยามซึ่งประกอบด้วยวัตถุต่างๆ โดยที่วัตถุใดมีการเรียกใช้นอก namespace ที่ตัวเองอยู่ จะต้องมีการระบุชื่อของ namespace เป็นตัวเติมหน้า โดยใช้สัญลักษณ์ :: เป็นตัวเชื่อม เช่น std :: cout
ตัวอย่างโปรแกรมทุกตัวอย่างต่อจากนี้ จะถือว่ามีการเริ่มต้นด้วยคำสั่ง
#include <iostream> using namespace std;
โดยผู้เขียนขอละไว้เพื่อให้โปรแกรมสั้น กระชับ และ ง่ายแก่การเรียนรู้ นอกจากนี้ ผู้เขียนยังขอละการเขียนคำสั่ง
return 0;
ในฟังก์ชัน main ( )
คำสำคัญ (keywords) ในภาษาคอมพิวเตอร์ หมายถึง คำที่ถูกกำหนดบทบาทหน้าที่ที่แน่นอนในภาษาคอมพิวเตอร์เพื่อใช้ในการเขียนคำสั่งในโปรแกรม คำสำคัญบางคำจะพบทั่วไปในภาษาคอมพิวเตอร์ระดับสูง เช่น คำว่า if และ else แต่คำสำคัญบางคำอาจมีใช้เฉพาะในบางภาษาคอมพิวเตอร์ เช่น ในภาษา C++ มีการสำรองคำสำคัญ dynamic_cast ที่ไม่ปรากฏในภาษาอื่น
คำสำคัญสามารถแบ่งออกได้เป็น 2 ประเภท คือ คำสงวน (reserved words) และ ชื่อบ่งชี้มาตรฐาน (standard identifiers) คำสงวน คือ คำสำคัญที่สำรองไว้เพื่อใช้เป็นตัวกำหนดโครงสร้างของ ไวยกรณ์ในคำสั่งของโปรแกรม ตัวอย่างคำสงวนในภาษา C++ เช่น if และ else ในขณะที่ ชื่อบ่งชี้มาตรฐาน เป็นคำสำคัญที่ใช้ในการแทนชื่อของหน่วย (elements) ที่มีหน้าที่เฉพาะในภาษาคอมพิวเตอร์ เช่น bool และ int จัดเป็นชื่อบ่งชี้มาตรฐานในการประกาศข้อมูลชนิด bool และ int ตามลำดับ ในภาษา C++ มาตรฐานมีการกำหนดคำสำคัญไว้ใช้งานทั้งสิ้น 74 ตัว ดังต่อไปนี้
and and_eq asm auto bitand bitor bool break case catch char class compl const const_cast continue default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new not not_eq operator or or_eq private protected public register reinterpret_cast return short signed sizeof static static_cast struct switch template this throw true try typedef typeid typename using union unsigned virtual void volatile wchar_t while xor xor_eq
สัญลักษณ์ << ในภาษา C++ หมายถึง ตัวดำเนินการส่งออก (output operator หรือ put operator ) ตัวดำเนินการส่งออก << จะทำการเพิ่มค่าของนิพจน์ที่ระบุอยู่ทางขวาของตัวดำเนินการ ลงในสายข้อมูลส่งออก (output stream) ซึ่งระบุอยู่ทางซ้ายของตัวดำเนินการ โดยส่วนใหญ่จะเป็นวัตถุ cout อันได้แก่สายข้อมูลส่งออกของจอคอมพิวเตอร์ เช่น คำสั่ง
cout << 66 ;
จะแสดงเลขจำนวน 66 ออกทางจอภาพ สัญลักษณ์ << มีลักษณะคล้ายกับลูกศรที่แสดงทิศทางจากซ้ายไปขวา ซึ่งเปรียบได้กับการไหลส่งของข้อมูลจากนิพจน์ทางซ้าย ไปยังสายข้อมูลส่งออกทางขวา ทำให้ง่ายแก่การจดจำ
ตัวอย่าง 1.3 โปรแกรมแสดงข้อความ “Hello, World!” ตัวอย่างที่ 3
int main ( ) { // prints Hello World! cout << "Hel" << "lo, Wo" << "rld! " << endl; }
โปรแกรมนี้จะได้ผลรันเช่นเดียวกับโปรแกรมในตัวอย่างก่อนหน้า คำสั่งในบรรทัดที่ 3 มีการใช้ตัวดำเนินการส่งออก << 4 ตัว ในการนำวัตถุ 4 วัตถุ ได้แก่ “Hel”, “lo, Wo”, “rld! ” และ endl ไปบรรจุลงสายข้อมูล cout ตามลำดับ วัตถุ 3 ตัวแรกเป็นสายอักขระ ที่เมื่อประกอบกันจะได้สายอักขระเป็นข้อความ “Hello, World! ” ส่วน endl มาจากคำว่า end of line มีค่าและผลการทำงานเหมือนกับตัวอักขระ '\n'
วัตถุ “Hel”, “lo, Wo” และ “rld! ” ในตัวอย่างก่อนหน้านี้ เรียกว่า สัญพจน์สายอักขระ (string literal) หมายถึง ชุดลำดับของตัวอักขระเรียงต่อเนื่องกัน โดยในภาษา C++ กำหนดให้เขียนลำดับตัวอักขระไว้ในเครื่องหมาย “ ” (quotation marks)
อักขระ (character) หมายถึง อักขระ 1 ตัวเขียนอยู่ในเครื่องหมาย ' ' (single quote) อักขระประกอบด้วย ตัวอักษรภาษาอังกฤษพิมพ์ใหญ่และพิมพ์เล็ก ตัวเลข ช่องไฟ เครื่องหมายต่างๆ และ อักขระควบคุม ในภาษา C++ ใช้รหัสแอสกีในการแทนค่าอักขระ (ดูภาคผนวก) ตัวอักขระควบคุมเป็นอักขระที่ไม่มีการแสดงสัญลักษณ์ตัวอักขระออกมา แต่มีผลต่อการแสดงผล เช่น
\a เสียงร้องเตือน (bell, alert)
\b อักขระถอยหลัง (backspace)
\f อักขระเลื่อนหน้ากระดาษ (form feed, new page)
\n อักขระขึ้นบรรทัดใหม่ (new line)
\r อักขระปัดแคร่ (carriage return)
\t อักขระตั้งระยะ (tab)
ในการเขียนอักขระ \ ให้เป็นส่วนหนึ่งของสัญพจน์สายอักขระ ทำได้โดยเขียน \\ และ การระบุอักขระ * ในสัญพจน์สายอักขระ ทำได้โดยเขียน \*
ตัวอย่าง 1.4 โปรแกรมแสดงข้อความ “Hello, World!” ตัวอย่างที่ 4
int main ( ) { // prints Hello World! cout << "Hello, W" << 'o' << "rld" << '!' << '\n'; }
การทำงานของตัวดำเนินการส่งออก << กับอักขระ มีผลเช่นเดียวกับสายอักขระ จากตัวอย่าง สายอักขระ “Hello, W” และ “rld“ เมื่อประกอบกับอักขระ 'o' และ '!' จะได้สายอักขระเป็นข้อความ “Hello, World!” ส่วนอักขระ '\n' จะมีผลให้ตัวชี้ตำแหน่งไปที่บรรทัดใหม่
ตัวอย่าง 1.5 โปรแกรมเพิ่มสัญพจน์ตัวเลขในสายข้อมูลส่งออก
int main ( ) { // prints The Millennium ends Dec 31 2000 cout << "The Millennium ends Dec " << 3 << 1 << ' ' << 2000 << endl; }
ทดสอบโปรแกรม
The Millennium ends Dec 31 2000
สัญพจน์ตัวเลข (numeric literal) หมายถึง ข้อมูลคงที่เลขจำนวน เช่น 3, 1 และ 2000 ในตัวอย่าง ตัวดำเนินการส่งออก << จะเปลี่ยนสัญพจน์ตัวเลขเป็นสัญพจน์สายอักขระ ก่อนส่งค่าไปใส่ในบัฟเฟอร์สายข้อมูลส่งออก ตัวอย่างเช่น เลขจำนวน 3 จะถูกเปลี่ยนเป็น “3” เลขจำนวน 1 จะถูกเปลี่ยนเป็น “1” และ เลขจำนวน 2000 จะถูกเปลี่ยนเป็น “2000” ก่อนบรรจุลงบัฟเฟอร์ ในการส่งออกข้อมูลที่เป็นสัญพจน์ตัวเลข 2 ตัวต่อเนื่องกัน ผู้เขียนโปรแกรมจำเป็นต้องส่งออกอักขระช่องว่าง ' ' เพื่อแยกเลขจำนวนทั้งสองออกจากกัน มิฉะนั้น เมื่อนำไปแสดงผลจะแสดงผลเสมือนหนึ่งว่าเป็นเลขจำนวนเดียวกัน เช่น คำสั่ง
cout << 3 << 1;
จะแสดงผลเลขจำนวน 31 ออกทางจอภาพ
ตัวแปร (variable) เป็นสัญลักษณ์ที่ใช้แทนค่าตำแหน่งที่มีการสำรองเนื้อที่ในหน่วยความจำ เพื่อใช้เก็บค่า (value) ไว้ใช้งานในการประมวลผลคำสั่งในโปรแกรม วิธีการที่จะนำค่าไปเก็บไว้ในตัวแปร ใช้คำสั่งกำหนดค่า (assignment statement) โดยใช้ตัวดำเนินการกำหนดค่า (assignment operator) ซึ่งในภาษา C++ ใช้สัญลักษณ์ = ตามรูปแบบคำสั่ง
variable = expression ;
ผลของนิพจน์ (expression) จะถูกนำไปเก็บในตัวแปรตามการทำงานของตัวดำเนินการกำหนดค่า =
ตัวอย่าง 1.6 โปรแกรมกำหนดค่า 44 ให้กับตัวแปร m และค่า m + 33 ให้กับตัวแปร n
int main ( ) { // prints m = 44 and n = 77 int m , n; m = 44; // assigns value 44 to the variable m cout << "m = " << m; n = m + 33; // assigns value 77 to the variable n cout << "and n = " << n << endl; }
ทดสอบโปรแกรม
m = 44 and n = 77
คำสั่งในบรรทัดที่ 4
m = 44;
มีผลให้นำค่า 44 ไปเก็บไว้ในตัวแปร m ตามการทำงานของตัวดำเนินการ = ส่วนคำสั่งในบรรทัดที่ 6
n = m + 33;
มีผลให้นำค่าที่ได้จากการนำค่าในตัวแปร m (ซึ่งมีค่าเป็น 44) มาบวกกับ 33 ตามการทำงานของตัวดำเนินการ + ได้ผลลัพธ์เป็น 77 นำไปเก็บไว้ในตัวแปร n ตามการทำงานของตัวดำเนินการ =
ในการใช้งานตัวแปรในภาษา C++ จำเป็นต้องมีการประกาศตัวแปรก่อน ตามรูปแบบคำสั่งของการประกาศตัวแปร ดังนี้
[specifier] type name [initializer] ;
โดยที่ specifier เป็นการระบุคำสำคัญเพื่อกำหนดทางเลือกให้กับชื่อตัวแปรที่ประกาศ
type เป็นการระบุชนิดของข้อมูลที่เก็บในหน่วยความจำของตัวแปรนั้น
name เป็นชื่อที่ประกาศขึ้นเพื่อใช้งานในโปรแกรม และ
initializer เป็นการกำหนดค่าเริ่มต้นที่ต้องการให้มีการจัดเก็บในหน่วยความจำของตัวแปรนั้น
ในส่วนของการระบุคำสำคัญ และการกำหนดค่าเริ่มต้นอาจมีในคำสั่งการประกาศตัวแปร หรือไม่มีก็ได้ เช่น
int m, n;
คำสั่งดังกล่าว จะมีการสำรองเนื้อที่ในหน่วยความจำไว้ 2 ตำแหน่ง ที่สามารถอ้างอิงได้ผ่านชื่อตัวแปร m และ n ตามลำดับ โดยจะมีการสำรองเนื้อที่ให้เพียงพอ เพื่อใช้เก็บค่าเลขจำนวนเต็มสำหรับการทำงานของโปรแกรม จะเห็นว่า เราสามารถประกาศตัวแปรที่เก็บข้อมูลชนิดเดียวกัน ไว้ในคำสั่งเดียวกันได้
ตำแหน่งที่ประกาศตัวแปรแสดงถึงขอบเขตการใช้งานของตัวแปรนั้น โดยผู้เขียนโปรแกรมสามารถใช้งานตัวแปรได้เริ่มจากตำแหน่งที่ประกาศตัวแปร ไปจนถึงจุดสิ้นสุดของโครงร่างที่ตัวแปรนั้นประกาศใช้ เช่น ถ้าประกาศตัวแปรในฟังก์ชัน main ( ) ก็จะสามารถใช้งานตัวแปรนั้นได้ ตั้งแต่ประกาศตัวแปร จนสิ้นสุดฟังก์ชัน main ( ) <!– การตั่งชื่อ –>
ในภาษา C++ ตัวแปรที่ไม่ได้กำหนดค่าเริ่มต้น จะมีค่าเป็นค่าขยะ (garbage) ซึ่งเป็นค่าของข้อมูลเดิมที่มีอยู่ในหน่วยความจำในตำแหน่งที่สำรองให้กับตัวแปรนั้น และ เมื่อมีการนำค่าในตัวแปรไปใช้งานก่อนที่จะมีการกำหนดค่าใหม่ให้กับตัวแปร จะส่งผลให้โปรแกรมได้ผลการทำงานที่ไม่ถูกต้อง ดังนั้น ในบางกรณี ผู้เขียนโปรแกรมควรจะกำหนดค่าเริ่มต้นให้กับตัวแปรเมื่อมีการประกาศใช้ตัวแปร
ตัวอย่าง 1.7 โปรแกรมกำหนดค่าเริ่มต้นให้กับตัวแปร
int main ( ) { // prints m = ?? and n = 44 int m; // BAD: m is not initialized int n = 44; cout << "m = " << m << " and n = " << n<< endl; }
ทดสอบโปรแกรม
m = ?? and n = 44
หมายเหตุ โปรแกรมแปลโปรแกรมแต่ละตัวอาจแสดงผลค่าขยะแตกต่างกัน บางโปรแกรมอาจแสดงผลเป็น ?? ดังตัวอย่าง แต่บางโปรแกรมอาจแสดงผลตามค่าขยะจริงที่มีในหน่วยความจำในขณะที่ประมวลผล
วัตถุ (object) เป็นพื้นที่ต่อเนื่องในหน่วยความจำที่ประกอบด้วย เลขที่อยู่ (address), ขนาด (size), ชนิดข้อมูล (type) และ ค่า (value) โดยที่ เลขที่อยู่ เป็นตำแหน่งเริ่มต้นไบต์แรกของข้อมูล ขนาด หมายถึง จำนวนไบต์ของข้อมูลที่สำรองเนื้อที่ ซึ่งจะขึ้นกับชนิดข้อมูล และ ค่า หมายถึง ค่าของข้อมูลจริงที่เก็บอยู่ในหน่วยความจำ เช่น คำสั่ง
int n = 22;
อาจมีค่าเลขที่อยู่เป็น 0x3fffcd6 ในหน่วยความจำ ที่มีการสำรองเนื้อที่ขนาด 4 ไบต์ต่อเนื่อง เพื่อใช้เก็บข้อมูลจำนวนเต็ม และ มีค่า 22 เก็บในตำแหน่งดังกล่าว
ตัวแปร (variable) เป็นวัตถุที่มีชื่อกำกับ สำรองไว้เพื่อใช้งานในโปรแกรม โดยสามารถเปลี่ยนค่าได้ จากตัวอย่างข้างต้น ตัวแปรอ้างอิงผ่านชื่อ n ส่วนตัวคงที่ (constant) เป็นวัตถุที่มีชื่อกำกับ ที่ไม่สามารถเปลี่ยนแปลงค่าได้ระหว่างการทำงานของโปรแกรม ในภาษา C++ ผู้เขียนโปรแกรมสามารถประกาศตัวคงที่ โดยระบุ specifier เป็นคำสำคัญ const เช่น คำสั่ง
const int N = 22;
จะทำการสำรองเนื้อที่ในหน่วยความจำ ที่สามารถอ้างอิงผ่านชื่อ N เพื่อเก็บค่าคงที่จำนวนเต็ม 22 โดยในโปรแกรม ตัวคงที่ N จะมีค่าเป็น 22 เสมอตลอดการทำงานของโปรแกรม ผู้เขียนโปรแกรมไม่สามารถเขียนคำสั่งทำการเปลี่ยนค่าในตัวคงที่ N
ตัวอย่าง 1.8 โปรแกรมประกาศตัวคงที่
int main ( ) { // defines constants; has no output const char BEEP = '\b'; const int MAXINT = 2147483647; const int N = MAXINT / 2; const float KM_PER_MILE = 1.60934; const double PI = 3.14159265358979323846; }
ขอบเขตของชื่อตัวบ่งชี้ (scope of identifiers) หมายถึง ส่วนของโปรแกรมที่ผู้เขียนโปรแกรมสามารถใช้งานชื่อตัวบ่งชี้ที่กำหนดได้ โดยขอบเขตของตัวแปรเริ่มตั้งแต่ตำแหน่งที่ตัวแปรถูกประกาศใช้ จนสิ้นสุดฟังก์ชัน หรือ บล็อก (block) ที่ตัวแปรถูกประกาศไว้ ผู้เขียนโปรแกรมไม่สามารถใช้งานตัวแปรก่อนที่จะมีการประกาศตัวแปร
ตัวอย่าง 1.9 ขอบเขตของตัวแปร
int main ( ) { //illustrates the scope of variables: x = 11; // ERROR: this is not the scope of x int x; { x = 22; // OK: this is in the scope of x y = 33; // ERROR: this is not the scope of y int y; x = 44; // OK: this is in the scope of x y = 55; // OK: this is in the scope of y } x = 66; // OK: this is in the scope of x y = 77; // ERROR: this is not the scope of y }
ขอบเขตของตัวแปร x เริ่มต้นที่ตำแหน่งประกาศ จนถึงสิ้นสุดฟังก์ชัน main ( ) ดังนั้น คำสั่ง x = 11; ในบรรทัดที่ 3 จึงเป็นการเขียนที่ผิด ส่วนขอบเขตของ y เริ่มต้นที่ตำแหน่งประกาศ ถึง สิ้นสุดภายในบล็อกที่ y ถูกประกาศ ดังนั้น คำสั่ง y = 33; ในบรรทัดที่ 6 และ y = 77; ในบรรทัดที่ 12 จึงเป็นการเขียนที่ผิด โปรแกรมอาจประกาศชื่อตัวแปรเหมือนกันได้ ตราบเท่าที่ตัวแปรดังกล่าวอยู่กันคนละส่วนของโปรแกรม
ตัวอย่าง 1.10 ขอบเขตซ้อน
#include <iostream> using namespace std; int x = 11; // this x is global int main ( ) { //illustrates the nested and parallel scopes: int x = 22; // begin scope of x { int x = 33; // begin scope of internal block cout << "In block inside main() : x = " << x << endl; cout << "In block inside main() : ::x = " << ::x << endl; } // end scope of internal block cout << "In main() : x = " << x << endl; cout << "In main() : ::x = " << ::x << endl; } // end scope of main
ทดสอบโปรแกรม
In block inside main() : x = 33 In main() : x = 22 In main() : ::x = 11
จากตัวอย่าง มีการประกาศตัวแปรชื่อ x อยู่ 3 แห่ง ตัวแปร x ที่ถูกกำหนดให้มีค่าเริ่มต้นเป็น 11 เป็นตัวแปรส่วนรวม (global variable) ดังนั้น ผู้เขียนโปรแกรมสามารถใช้งานตัวแปร x ดังกล่าวได้ทุกแห่งในโปรแกรม ตัวแปร x ที่มีค่าเริ่มต้นเป็น 22 มีขอบเขตจำกัดอยู่ภายในฟังก์ชัน main ( ) เท่านั้น ภายในฟังก์ชัน main ( ) มีการเขียนบล็อกคำสั่ง พร้อมทั้ง ประกาศตัวแปร x ที่มีค่าเริ่มต้นเป็น 33 ตัวแปร x = 33 สามารถใช้งานได้เฉพาะในบล็อกนี้เท่านั้น จะเห็นว่า ผู้เขียนโปรแกรมสามารถประกาศชื่อวัตถุเหมือนกันได้ ตราบเท่าที่วัตถุแต่ละตัวอยู่คนละส่วนกัน โดยการใช้งานกับชื่อที่เหมือนกัน จะหมายถึงชื่อของวัตถุในส่วนที่คำสั่งอยู่ เช่น การแสดงค่าของตัวแปร x ในบล็อก จะหมายถึง ตัวแปร x ที่มีค่าเป็น 33 และ ถ้าในโปรแกรมต้องการอ้างอิงถึงตัวแปร x ที่เป็นตัวแปรส่วนรวม จะต้องระบุเครื่องหมาย :: ไว้หน้าตัวแปร สัญลักษณ์ :: เรียกว่า ตัวดำเนินการแยกขอบเขต (scope resolution operator)
ตัวอย่าง 1.11 การใช้บล็อกในการจำกัดขอบเขตของตัวแปร
int main ( ) { int n = 44; cout << "n1 = " << n << endl; { int n = 77; //scope of n is in this 2 lines (in this block) cout << "n2 = " << n << endl; } { cout << "n3 = " << n << endl; //is n, declared first in main } { int n; //scope n is in this block cout << "n4 = " << n << endl; } cout << "n5 = " << n << endl; // n in main }
ทดสอบโปรแกรม
n1 = 44 n2 = 77 n3 = 44 n4 = 4313352 n5 = 44
ตัวแปร n ที่ตำแหน่ง n1 เป็นตัวแปรภายในขอบเขตของฟังก์ชัน main( ) จึงมีค่าเป็น 44 ส่วนตัวแปร n ที่ตำแหน่ง n2 เป็นตัวแปรท้องถิ่นประกาศภายในบล็อกแรกที่กำหนดในฟังก์ชัน main( ) จึงมีค่าเป็น 77 ในขณะที่ บล็อกที่สองที่กำหนดในฟังก์ชัน main( ) ไม่มีการประกาศตัวแปร n ซ้อน ดังนั้น ค่าของตัวแปร n ที่ตำแหน่ง n3 จึงหมายถึงตัวแปร n ที่ประกาศในฟังก์ชัน main( ) ซึ่งมีค่าเป็น 44 ในบล็อกสุดท้ายที่กำหนดในฟังก์ชัน main( ) มีการประกาศตัวแปร n ซ้อน อย่างไรก็ดี ในการประกาศตัวแปร n ไม่มีการกำหนดค่า ทำให้ค่าของตัวแปร n เป็นค่าขยะ (garbage) ในหน่วยความจำ (ดังที่อธิบายแล้วในหัวข้อก่อน) ค่าตัวแปร n ตัวสุดท้ายที่ตำแหน่ง n5 มีค่าเป็น 44 เนื่องจาก เป็นตัวแปรที่ปรากฏอยู่ในขอบเขตของฟังก์ชัน main( )
ตัวดำเนินการนำเข้า (input operator หรือ get operator) ในภาษา C++ ใช้สัญลักษณ์ » โดยจะมีลักษณะการทำงานคล้ายกับตัวดำเนินการส่งออก โดยที่ ตัวดำเนินการ » จะกระทำกับวัตถุ cin ที่ระบุอยู่ทางซ้ายของตัวดำเนินการ ในการนำค่าจากบัฟเฟอร์ของสายข้อมูลนำเข้าที่ได้จากแป้นพิมพ์ มาจัดเก็บในตัวแปร ที่ระบุอยู่ทางขวาของตัวดำเนินการ
ตัวอย่าง 1.12 โปรแกรมนำเข้าข้อมูล
int main ( ) { // test the input of integer, floats and characters int m, n; cout << "Enter two integers: "; cin >> m >> n; cout << "m = " << m << " and n = " << n << end; double x, y, z; cout << "Enter three decimal numbers: "; cin >> x >> y >> z; cout << "x = " << x << ", y = " << y << ", z = " << z << endl; char c1 ,c2 ,c3, c4; cout << "Enter four characters: "; cin >> c1 >> c2 >> c3; cout << "c1 = " << c1 << ", c2 = " << c2 << ", c3 = " << c3 << ", c4 = " << c4 << endl; }
ทดสอบโปรแกรม เมื่อป้อนค่าจำนวนเต็ม 2 จำนวนเป็น (22 และ 44) ป้อนค่าจำนวนจริง 3 จำนวนเป็น (2.2 4.4 และ 6.6) และ ป้อนค่าอักขระ 4 ตัวเป็น (A B C และ D)
Enter two integers: 22 44 m = 22 n = 44 Enter three decimal numbers: 2.2 4.4 6.6 x = 2.2, y = 4.4, z = 6.6 Enter four characters: ABCD c1 = A, c2 = B, c3 = C, c4 = D