บทที่ 4 ตัวแปร

ตัวแปร

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

ที่มีขนาดของด้าน คือ 5 จากสูตรพื้นที่สี่เหลี่ยมจัตุรัส = ด้าน * ด้าน เราสามารถเขียนได้ดังนี้

#include “iostream.h”

int main()

{

 cout << 5 * 5

; return 0;

}

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

โปรแกรมที่ 4-1 ตัวอย่างการประกาศและการใช้ตัวแปร

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int Len;

5: cout << "Please enter Length :";

6: cin >> Len;

7: cout << "The area = " << Len * Len;

8: return 0;

9:}

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

ในรอบแรกใส่เลข 50

Output

Please enter Length :50

The area =2500

ลองรันอีกครั้งคราวนี้ใส่เลข 100

Please enter Length :100

The area =10000

อธิบาย Source code

บรรทัดที่ 4:เป็นการประกาศตัวแปรชื่อ Len เป็นประเภท int(รายละเอียดของประเภทของตัวแปรจะกล่าวในส่วนต่อไปในบทนี้)

บรรทัดที่ 6:เป็นการรับข้อมูลจากทาง คีย์บอร์ดโดยใช้ โอเปอเรเตอร์ cin โดยมีรูปแบบดังนี้

cin >> [ตัวแปร]

เช่น

cin  >> Len;

บรรทั่ดที่ 7:เป็นการพิมพ์ข้อความ The area = และค่าของตัวแปร Len คูณกับตัว แปร Len

ไอเด็นติฟายเออร์

 ไอเด็นติฟายเออร์ หมายถึง ชื่อที่มีอยู่ในส่วนต่างๆของโครงสร้างของ โปรแกรมภาษา เช่นชื่อของตัวแปร Function

 ไอเด็นติฟายเออร์มี 2 ประเภทคือ

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

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t

 2.ไอเด็นติฟายเออร์ที่เรากำหนดขึ้นเอง หมายถึงชื่อที่เราตั้งขึ้นมาเอง โดยต้องทำตามกฎดังนี้

 1.ชื่อต้องไม่เหมือนกับคีย์เวิร์ด

 2.ความยาวของชื่อจะเท่าไหร่ก็ได้ แต่ Compilerจะเห็นความแตกต่างแค่ 32 ตัวอักษรแรกเท่านั้น 

 3.ชื่อจะต้องเริ่มด้วยตัวอักษรหรือเครื่องหมาย_(อันเดอร์สกอร์) แต่ตำแหน่งต่อไป

สามารถเป็นได้ทั้งตัวเลข เครื่องหมาย_ หรือตัวอักษรก็ได้

 4.คอมไพเลอร์จะถือว่าตัวอักษรพิมพ์เล็กหรือตัวอักษรพิมพ์ใหญ่มีความแตกต่างกันและจะถือเป็นคนละตัวกัน เช่น

 Name

 name

 NAME

จะถือเป็นคนละตัวกัน

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

เกี่ยวกับกฎข้อ 2 ของการตั้งชื่อ ไอเด็นติเฟอร์

 กฎข้อ 2 ที่บอกว่า Compiler จะเห็นความแตกต่างแค่ 32 ตัวอักษรแรกเท่านั้น

ใน ที่นี้มีความหมายว่าถ้า ชื่อยาว 33 ตัวอักษร แต่ 32 ตัวแรกเหมือนกันจะเห็นเป็นตัวเดียวกัน เช่น

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2

ทั้ง 2 ตัวนี้ Compiler จะถือ ว่าเป็นคนละตัวกันตามกฎแต่ในความเป็นจริงแล้วความกว้างของ ไอเด็นติฟายเออร์ นันขึ้นอยู่กับ Compiler ที่ใช้ จากที่ผู้เขียนได้ทดลองดูเกี่ยวกับการตั้งชื่อ ไอเด็นติฟายเออร์นั้น TurboC++ 4.5 for win และ Visual C++6.0 for win Compiler จะสามารถเห็นความแตกต่างได้มากกว่านั้น

เช่น

int AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1;

int AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2;

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1=500;

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2=900;

cout << AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1 << endl;

cout << AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2 ;

Output ที่ได้คือ

500

900

โปรแกรมนี้ถ้าหากผู้อ่านดูแล้วไม่เข้าใจขอให้ข้ามไปอ่านส่วนของการประกาศตัวแปรและการกำหนดค่าให้กับตัวแปร ก่อน

ทั้งๆที่เราประกาศตัวแปรมา 2 ตัวกว้างถึง 41 ตัวอักษรโดยชื่อของ ไอเด็นติฟายเออร์นั้นคล้ายกันมากจะแตกต่างกันก็แค่ตัวอักษรที่ 41 คือ เป็นเลข 1 กับ เลข 2 ส่วนตัวอักษรตัวที่ 1 ถึง 40 เป็นตัว A เหมือนกันหมด

 ถ้าหาก Compiler สามารถแยกแยะความแตกต่างได้แค่ 32 ตัวอักษรแรก ก็น่าจะเห็นเป็นตัวเดียวกันเพราะทั้ง 32 ตัวแรก เหมือนกัน (จริงๆแล้วเหมือนกันตั้ง 40 ตัวอักษรแน่ะ) แต่Compiler กับเห็นเป็นคนละตัว เพราะว่าทั้ง 2 ตัวนี้ ต่างก็เก็บค่า 500 และ 900 ซึ่งนั่นเป็นการแสดงให้เห็นว่ากฎที่บอกว่าเห็นความแตกต่างกันแค่ 32 ตัวแรกนั้นขึ้นอยู่กับ Compiler หรือระบบที่ใช้ด้วย

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

การตั้งขื่อ ไอเด็นติฟายเออร์

1.ควรตั้งชื่อให้มีความหมายและเข้าใจง่ายเช่น

ถ้าหากตั้งชื่อเก็บตัวแปร ชื่อ นามสกุล อายุควรตั้งแบบนี้

 Name , Surname , Age

จะเข้าใจง่ายกว่า

 A, BB,JJ

 ในกรณีที่ไม่รู้ว่าคำคำนั้นเป็นภาษาอังกฤษใช้คำว่าอะไร เราอาจใช้ภาษาโอเกะแทนก็ได้เช่น

ดอกเบี้ย เราอาจตั้งเป็น Dokbie

ตำบล เราอานตั้งเป็น Tumbon

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

2.ลักษณะการตั้งชื่อควรให้เป็นมาตรฐาน เช่น

 ถ้าตั้งชื่อตัวแปรที่เก็บชื่อ นามสกุลเราก็อาจตั้งเป็น

 Firstname , Lastname

หรือ

 FirstName,LastName

หรือ

 FIRSTNAME,LASTNAME

จะเห็นได้ว่าแบบแรก ตัวแปรจะเป็นตัวใหญ่เฉพาะตัวแรก ตัวแปรตัวอื่นๆก็ควรจะเป็นตัวใหญ่เฉพาะตัวแรกด้วย

แบบที่ 2 ตัวแปรจะเป็นตัวใหญ่ในกรณที่เป็นตัวแรกของคำที่มีความหมาย 

เช่น firstname มีคำว่า first กับ name พอตั้งเป็นตัวแปรถึงแม้จะเป็นตัวแปรตัวเดียวแต่มีคำที่มีความหมาย 2 คำเราก็ตั้งให้ ตัวอักษรตัวแรกของทั้ง 2 ตัวนั้นเป็นตัวใหญ่ เช่น FirstNameและตัวแปรตัวอื่นๆก็ควรทำตามมาตรฐานนี้ด้วย

แบบที่ 3 เป็นตัวใหญ่หมดเลย การตั้งชื่อตัวแปรตัวอื่นๆก็ควรจะให้เป็นตัวใหญ่หมดเลยเหมือนกันหมด

3.การตั้งชื่อตัวแปรแบบฮังกาเรียน

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

ของ ประเภทตัวแปรไว้นำหน้าโดยที่ถ้าเป็นคำย่อก็ให้เป็นตัวอักษรตัวเล็กแล้วต่อด้วยชื่อตัวแปร

 เช่นตัวแปรเก็บข้อมูลอายุปกติเราอาจตั้งเป็น ตัวแปรประเภท int  และชื่อว่า Age ก็ให้เราเปลี่ยนใหม่เป็น

 intAge หรือ iAge

 เวลาประกาศก็ประกาศเหมือนปกติเช่น

 int intAge;

 ถ้าหากเป็นตัวแปร float ก็อาจใช้เป็น flo หรือ flt หรือ f อะไรก็ได้ก็ตามแต่ที่คนเราจะเข้าใจได้ว่ามันคือตัวแปรประเภท float เช่น

 float floArea;

เป็นการประกาศตัวแปรประเภท float ชื่อ floArea พอเวลาคนอื่นมาอ่าน Source code ของเราพอเค้าเจอตัวแปร floArea เค้าก็พอจะเข้าใจได้ว่า เป็นตัวแปรประเภท flo เอาไว้เก็บค่าArea โดยหลักเกณฐ์ในการพิจารณาว่าตัวแปรนั้นเป็นประเภทอะไร อาจมีการตกลงกันก่อนว่าถ้าเป็น int จะใช้อะไร หรือ ถ้าเป็น float จะใช้อะไร แต่ถ้าหากคนที่มาดู Source code เป็นคนที่ไม่รู้กฎที่เราตั้งขึ้นเค้าก็พอจะเดาออกได้เป็นประเภทอะไรถ้าหากเราทำตามกฎที่ว่า

ประเภทของตัวแปรจะอยู่ข้างหน้าเป็นตัวอักษรตัวเล็ก

ชื่อที่สื่อความหมายว่าจะเอาไปใช้ทำอะไรตัวแรกให้เป็นตัวใหญ่เข่น

floSalary

หรือเราอาจตั้งเป็น

fSalary

ถ้าหากเราตั้งว่า floSalary คนทั่วไปเห็นตัวอักษรที่เป็นตัวเล็ก 3 ตัวแรกว่าเป็นfloก็พอเดาได้ว่าตัวแปรนี้ต้องเป็นประเภท float หรือ เราตั้งว่า fSalary ก็พอจะเดาได้เหมือนกัน ส่วนตัวอักษรตัวใหญ่ตัวแรกคือตัว S ที่ต่อจาก ประเภทของตัวแปร ก็จะเป็น Salaryเพราะฉะนั้นจึงหมายความว่าตัวแปรนี้เป็นตัวแปรประเภท float เอาไว้ใช้เก็บข้อมูลเงินเดือน

การประกาศตัวแปร

ก่อนที่เราจะใช้ตัวแปรเราต้องประกาศตัวแปรก่อน รูปแบบการประกาศตัวแปรมีดังนี้

 ประเภทตัวแปร ชื่อตัวแปร;

โดยที่ชื่อของตัวแปรต้องตั้งตามกฎของ ไอเด็นทิฟายเออร์

เช่น

รูปแบบของการประกาศ

int Salary;

int hour;

มีความหมายว่า ประกาศตัวแปรประเภท int ชื่อ Salary และ hour

เราสามารถเขียนได้อีกอย่าง

int Salary,hour;

แบบนี้จะเป็นการประกาศตัวแปรอีกแบบหนึ่ง ในกรณีที่ตัวแปรหลายๆตัวเป็นประเภทเดียวกันเราสามารถประกาศแบบนี้ได้

การกำหนดค่าให้กับตัวแปรและการนำค่าจากตัวแปรมาใช้

 การกำหนดค่าให้กับตัวแปรมีรูปแบบดังนี้

 ตัวแปร = ค่าที่ต้องการกำหนด

เช่น

 int j;

 j = 300;

เป็นการกำหนดค่าให้กับตัวแปร j ให้มีค่า 300

เราไม่สามารถกำหนดค่าให้กับประเภทของตัวแปรได้เช่น

 int = 5;

ถ้าพิมพ์อย่างนี้เวลา Compile จะ Error

เราสามารถกำหนดค่าให้กับตัวแปรตั้งแต่ตอนที่ประกาศได้ เช่น

 int A = 5;

หรือ

 float A = 10.63,B = 20.1;

การนำค่าจากตัวแปรมาใช้

เราสามารถนำค่าจากตัวแปรมาใช้ เช่นใช้ ในการแสดงผล หรือ นำมาใช้ในการกำหนดค่าให้กับตัว แปรอีกตัวก็ได้

 การนำค่าตัวแปรมาแสดงผลโดยใช้ cout มีรูปแบบดังนี้

 int i;

 cout << i 

การนำค่าจากตัวแปรมาใช้ในการกำหนดค่าให้กับตัวแปรอื่น สามารถทำได้โดยใช้เครื่องหมาย= โดยที่ตัวแปรที่ถูกกำหนดค่าจะอยู่ทางซ้าย

 เช่น

 int i,z;

 i = 500;

 z = 2000;

 i = z;

 cout << i << endl;

 cout << z ;

โปรแกรมนี้จะเป็นการแสดงผลค่า i และค่า z ซึ่งได้ 2000 ทั้ง 2ตัว

โปรแกรมที่ 4-2 ตัวอย่างการประกาศและการกำหนดค่าให้กับตัวแปร

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int Salary,hour,rate;

5: cout << "Please enter hour :";

6: cin >> hour;

7:

8: cout << "Please enter rate :";

9: cin >> rate;

10:

11: Salary = hour * rate;

12: cout << "Salary  =" << Salary;

13: return 0;

14:

15:}

Output

Please enter hour :200

Please enter rate :30

Salary =6000

อธิบาย Source code

โปรแกรมที่ 4-3 ตัวอย่างการประกาศและการกำหนดค่าให้กับตัวแปร

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int i,j;

5: i = 5;

6: j = 23;

7: i = j;

8: cout << i << endl;

9: cout << j << endl;

10: return 0;

11:}

Output

23

23

อธิบาย Source code

บรรทัดที่ 4: เป็นการประกาศตัวแปรประเภท int ชื่อ i และ j

บรรทัดที่ 5 และ บรรทัดที่ 6: เป็นการกำหนดค่า 5 ให้ตัวแปร i  และ ค่า 23 ให้ตัวแปร j

บรรทัดที่ 7: i = j; เป็นการกำหนดค่าตัวแปร j (23) ให้กับตัวแปร i (5) ซึ่งstatement นี้จะทำให้ค่า i เป็น 23 และค่า j ไม่ได้มีการเปลี่ยนแปลง

 สาเหตุที่  i = j; โดยที่ i = 5 และ j = 23 

เป็นการกำหนดให้ทั้ง i เท่ากับ j คื่อ 23 ทั้ง 2 ตัว แต่ไม่ได้เป็นการกำหนด ค่า j ให้เท่ากับ iคือเป็น 5 ทั้ง 2 ตัวเนื่องจากว่าในการเขียนโปรแกรม ตัวแปรที่ถูกกำหนดค่าจะอยู่ทางซ้ายเสมอ ถ้าเราอยากเขียนโปรแกรมให้ กำหนด ค่า j ให้เท่ากับ i คือเป็น 5 ทั้ง 2 ตัว ก็ให้เขียน ให้ตัวแปร j อยู่ทางซ้าย

  j = i;

ถ้าเขียนแบบนี้ ค่า j ก็จะเท่ากับ i คือมีค่าเป็น 5 ทั้ง 2 ตัว

บรรทัดที่ 8 และ บรรทัดที่ 9 : เป็นการสั่งให้แสดงผลค่าตัวแปร i  และ j ทั้ง 2 ตัว ซึ่งขณะนี้ ทั้ง 2 ตัวมีค่า 23

ประเภทของตัวแปร

 สาเหตุที่ต้องมีประเภทของตัวแปรเนื่องจากว่าถ้าเรากำหนดตัวแปรขึ้นมา 1 ตัวโดยที่ตัวแปรนั้นสามารถบรรจุข้อมูลที่เป็นจำนวนเต็มได้ตั้งแต่ 1 ถึง 4,000,000,000 เราก็จะเสียเนื้อที่ในหน่วยความจำไปประมาณ 4 byte ในขณะที่โปรแกรมที่ 4-1 เราต้องการใช้ตัวแปรที่เก็บค่าแค่ประมาณ 1 ถึง 30000 เท่านั้น ซึ่งจะใช้หน่วยความจำประมาณ 2 byte เท่านั้น ถ้าหากมีประเภทของตัวแปรที่สามารถเก็บเลขจำนวนเต็มได้ตังแต่ 1 ถึง 32000 เราก็ควรจะใช้ตัวแปรประเภทนั้นมากกว่า ใน C++ ได้แบ่งประเภทของตัวแปรพื้นฐาน 4 ประเภทดังนี้

ประเภท หน่วยความจำที่ใช้

char 1 byte 

int 2 byte 

float 4 byte

double 8 byte

ตัวแปร int

 ตัวแปรประเภท int เป็นตัวแปรที่สามารถเก็บเลขจำนวนเต็มได้ สามารถเก็บค่าได้ ระหว่าง –32768 ถึง 32767

จะเกิดอะไรขึ้นถ้าเรากำหนดค่าทศนิยมให้ตัวแปร int เช่น

 int i;

 i =99.1;

ค่า i จะเท่ากับ 99

 i =99.56;

ค่า i จะเท่ากับ 99

 i =99.999;

ค่า i จะเท่ากับ 99

จะเห็นได้ว่า เมื่อเรากำหนดค่าตัวแปร int ชื่อ i เป็นเลขทศนิยม Compiler จะไม่ปัดขึ้นให้ไม่ว่าตัวเลขหลังทศนิยมจะเป็นเลขอะไร Compiler จะตัดตัวเลขหลังทศนิยมออก

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

ตัวแปรประเภท int ออกเสียงว่า ไอ-เอ็น-ที หรืออยากจะออกเสียงว่า อินท์ ก็ได้ แต่บางครั้งคนเรานิยมออกเสียงว่า อิน-ทิเ-จอร์(intger) มากกว่า เพราะในโปรแกรมภาษาอื่นส่วนใหญ่ ก็ใช้ integer แต่ใน C++ จะเป็นตัวแปรประเภท int  ไม่ว่าเราจะออกเสียงว่า ไอเอ็นที หรือ อินทิเจอร์ แบบใดแบบหนึ่งคนในทีมก็น่าจะเข้าใจถ้าหากเค้าเคยเขียนโปรแกรมภาษาอื่นๆมาบ้าง เราคงไม่ต้องจริงจังขนาดตกลงกับคนในทีมว่า ให้ออกเสียงเป็น ไอเอ็นที หรือ อินทิเจอร์ ผู้เขียนเพียงต้องการบอกว่าถ้าได้ยินคนพูดถึงตัวแปร อินทิเจอร์ ให้นึกถึงตัวแปร ไอเอ็นที ในแบบ Turbo C++ ได้เลย คื่อมีค่าตั้ง แต่ –32768 ถึง 32767 แต่ตัวแปร อินทิเจอร์ ใน บางภาษา เช่น Visual basic เราไม่สามารถใช้ unsigned หรือ long หรือ short ร่วมได้

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 ตัวแปรประเภท float เป็นตัวแปรประเภทจำนวนจริงสามารถเก็บจำนวน ทศนิยมได้

ตัวแปร char

 ตัวแปร char เป็นตัวแปรที่สามารถเก็บอักขระได้ทีละตัวอักษร

ตัวแปร double

 ตัวแปร double สามารถเก็บจำนวนทศนิยมได้ เหมาะกับในกรณีที่ต้องการความละเอียดมากๆเนื่องจากตัวแปรประเภท double สามารถเก็บจำนวนทศนิยมได้มากกว่า float

unsigned

นอกจากนี้แล้วC++ ยังมีการใช้ singed และ unsigned ประกอบกับการประกาศตัวแปรประเภทจำนวนเต็มเช่น

int ,double ได้ด้วย

เช่นถ้าหากเราต้องการเก็บเลขจำนวนเต็ม ที่มีค่า ประมาณ0-60000 เราอาจใช้ตัวแปร

 unsigned int ได้

 โดย unsigned int หมายถึง เป็นตัวแปร int ประเภทไม่คิดเครื่องหมาย

 “ไม่คิดเครื่องหมาย” ในที่นี้มีความหมายว่าตัวแปร นี้จะไม่สามารถเก็บค่าที่ เป็นจำนวนเต็มลบได้จะเก็บค่าที่เป็นจำนวนเต็มบวกและ 0 ได้เท่านั้น เนื่องจากว่า เราไม่จำเป็นต้องเก็บจำนวนเต็มลบทำให้ เราเอาหน่วยความจำที่ใช้เก็บจำนวนเต็มลบมาใช้ได้

 ตัวแปร int ปกติ จะเก็บค่าได้มากสุด 32767

พอเป็น unsigned int ก็จะเก็บค่าได้มากสุดถึง 65535 แต่ไม่สามารถเก็บจำนนวนเต็มลบได้

 ตัวแปรแบบที่คิดเครื่องหมายเช่น int แบบปกติเราจะถือว่าเป็น signed (คิดเครื่องหมาย)โดยตอนประกาศตัวแปรเราไม่ต้องกำหนดว่าเป็น signed แต่ถ้าเป็น unsignedเราต้องกำหนดให้มีคำว่า unsigned นำหน้า

shot และ long

 นอกจาก unsigned แล้ว ยังมี short และ long ประกอบกับการประกาศตัวแปรประเภท จำนวนเต็ม short และ long เป็นส่วนประกอบที่จะทำการกำหนด ขนาดและความกว้างของตัวแปร โดยการใช้ shot และ long

 ถ้าใช้ กับ int

 short int มีความหมายว่า เป็นตัวแปร int มีขนาด 16 บิท

 long int มีความหมายว่า เป็นตัวแปร int มีขนาด 32 บิท

 ส่วนการใช้ int โดยที่ไม่มี short หรือ long นำหน้า int นั้นจะเป็นขนาด 16 หรือ 32 บิท ขึ้นอยู่กับ Compiler

unsigned short int  2 bytes  0 to 65,535

short int  2 bytes  -32,768 to 32,767

unsigned long int  4 bytes  0 to 4,294,967,295

long int  4 bytes  -2,147,483,648 to 2,147,483,647

int (16 bit)  2 bytes  -32,768 to 32,767

int (32 bit)  4 bytes  -2,147,483,648 to 2,147,483,647

unsigned int (16 bit)  2 bytes  0 to 65,535

unsigned int (32 bit)  4 bytes  0 to 4,294,967,295

char  1 byte  256 character values

float  4 bytes  1.2e-38 to 3.4e38

double  8 bytes  2.2e-308 to 1.8e308

ขนาดของตัวแปร

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

 sizeof(ตัวแปรหรือ ประเภทของตัวแปร)

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

ขนาดของ ตัวแปร int ใน Compiler แต่ละชนิดจะมีขนาดไม่เท่ากัน และขนาดของตัวแปรlong double จะขึ้นอยู่กับ Compiler ที่ใช้ ถ้าหากใช้ Borland C++ กับ Visual C++  จะมีขนาดไม่เท่ากัน

ตัวอย่างการใช้ คีย์เวิร์ด sizeof

 int i;

cout << sizeof(i);

cout << sizeof(int);

โปรแกรมที่ 4-4 ตัวอย่างการใช้ คีย์เวิร์ด sizeof

โปรแกรมนี้จะทดสอบ 3 ครั้งใน Compiler ที่แตกต่างกัน

 1. Turbo C++ 4.5 For win ของ Borland

 2. Borland C++ 5.0 For win ของ Borland

 3. Visual C++ 6.0 For win ของ Microsoft

Source code

1:#include”iostream.h”

2:int main()

3:{

4: cout << “sizeof char = “ << sizeof(char);

5: cout << “ byte” << endl;

6:

7: cout << “sizeof unsigned char = “ << sizeof(unsigned char);

8: cout << “ byte” <<endl;

9:

10: cout << “sizeof int = “ << sizeof(int);

11: cout << “ bytes” << endl;

12:

13: cout << “sizeof short int = “ << sizeof(short int);

14: cout << “ bytes” << endl;

15:

16: cout << “sizeof long int = “ << sizeof(long int);

17: cout << “ bytes” << endl;

18:

19: cout << “sizeof unsigned int  = “ << sizeof(unsigned int);

20: cout << “ bytes” << endl;

21:

22: cout << “sizeof unsigned short int = “ << sizeof(unsigned short int);

23: cout << “ bytes” << endl;

24:

25: cout << “sizeof unsigned long int = “ << sizeof(unsigned long int);

26: cout << “ bytes” << endl;

27:

28: cout << “sizeof float = “ << sizeof(float);

29: cout << “ bytes” << endl;

30:

31: cout << “sizeof double = “ << sizeof(double);

32: cout << “ bytes” << endl;

33:

34: cout << “sizeof long double = “ << sizeof(long double);

35: cout << “ bytes” << endl;

36:

37: return 0;

38:}

Output โดยใช้ Compiler Turbo C++4.5 for win

sizeof char  = 1 byte

sizeof unsigned char = 1 byte

sizeof int  = 2 byte

sizeof short int  = 2 byte

sizeof long int = 4 byte

sizeof unsigned int = 2 byte

sizeof unsigned short int = 2 byte

sizeof unsigned long int = 4 byte

sizeof float = 4 byte

sizeof double = 8 byte

sizeof longdouble =10 byte

Output โดยใช้ Compiler Borland C++5.0 for win

sizeof char  = 1 byte

sizeof unsigned char = 1 byte

sizeof int  = 4 byte

sizeof short int  = 2 byte

sizeof long int = 4 byte

sizeof unsigned int = 4 byte

sizeof unsigned short int = 2 byte

sizeof unsigned long int = 4 byte

sizeof float = 4 byte

sizeof double = 8 byte

sizeof longdouble =10 byte

Output โดยใช้ Compiler Visual C++6.0 for win

sizeof char  = 1 byte

sizeof unsigned char = 1 byte

sizeof int  = 4 byte

sizeof short int  = 2 byte

sizeof long int = 4 byte

sizeof unsigned int = 4 byte

sizeof unsigned short int = 2 byte

sizeof unsigned long int = 4 byte

sizeof float = 4 byte

sizeof double = 8 byte

sizeof longdouble = 8 byte

อธิบาย Source code

บรรทัดที่ 4,7,10,13,16,19,22,25,28 :เป็นการสั่งให้พิมพ์ขนาดของหน่วยความจำที่ใช้กับตัวแปรในแต่ละประเภท โดยใช้ sizeof

จะเห็นได้ว่า ในแต่ละ Compiler จะไม่เหมือนกัน

int ใน Compiler อย่าง Turbo C++ จะมีขนาด 2 bytes และ short int จะมีขนาดเท่ากับint ในและ long int จะมีขนาด 4 bytes

ในขณะที่ int ใน อย่าง Borland C++,Visual C++ int จะมีขนาด 4 bytes และ short intจะมีขนาด2 bytes โดยที่ long int จะมีขนาดเท่ากับ int

และนอกจากนั้น อย่าง Borland C++,Visual C++ ขนาดของ long double จะมีขนาดไม่เท่ากันด้วย โดยที่ Borland C++ long double จะมีขนาด 10 bytes

แต่ Visual C++ long double จะมีขนาด 8 bytes

ในขณะที่ Compiler อย่าง Turbo C++ long double ก็มีขนาด 10 bytes เท่ากับ Borland C++

ขนาดของตัวแปร int และ unsigned int ใน Compiler ที่ใช้ขนาด 16 บิท และ 32บิท

ตัวแปร int ที่ใช้ขนาด 16 บิท

 ตัวแปร int ในCompiler ที่ใช้หน่วยความจำ16 บิท มีค่าความกว้าง เท่ากับ 2¹⁶ หรือเท่ากับ65,536

ถ้าเป็น int จะมีค่าตั้งแต่ –32,768 ถึง 32,767 ถ้าเรากำหนดให้ตัวแปร int มีค่าเท่ากับ40,000 จะไม่สามารถกำหนดได้ เนื่องจากว่าค่าที่มากที่สุดของ int คือ 32767 และ เราก็ไม่สามารถกำหนดให้ตัวแปร int มีค่า –50,000 ได้ เนื่องจากค่าที่น้อยที่สุดคือ -32768

จำนวนเต็มลบจะได้ตั้งแต่ –1 ถึง –32,768 คือกว้าง 32,768 จำนวน จำนวนเต็มบวกมีค่าตังแต่ 1 ถึง 32,767 คือกว้าง 32,767 ถ้าเราเอาจำนวนความกว้างของจำนวนเต็มบวกที่สามารถกำหนดได้ บวกกับความกว้างของจำนวนเต็มลบที่กำหนดได้จะได้เท่ากับ32,767 + 32,768 จะได้เท่ากับ 65,535 และถ้าเรารวมจำนวนเต็มศูนย์คือ 0 ด้วยอีกตัว เราก็จะได้ 65,536

ถ้าเป็น unsigned int จะมีค่าตั้งแต่ 0 ถึง 65,535 คือมีความกว้าง 65,536 สาเหตุที่unsigned int มีค่าได้ถึง 65,535 แต่ในขณะที่ int มีค่าได้มากสุด 32,767 ทั้งที่ใช้หน่วยความจำเท่ากันเนื่องมาจากว่า unsigned int มีค่าน้อยสุดคือ 0 ไม่สามารถเก็บจำนวนเต็มลบได้ แต่ int เก็บจำนวนเต็มลบได้ถึง –32,768 ทั้ง 2 แบบนี้มีค่าความกว้าง 65,536 เท่ากัน

ตัวแปร int ที่ใช้ใน Compiler ที่ใช้หน่วยความจำ 32  บิท

ตัวแปร int ในCompiler ที่ใช้หน่วยความจำ 32  บิท มีค่าความกว้าง เท่ากับ 2³²หรือเท่ากับ 4,294,967,296 ถ้าเป็น int จะมีค่าตั้งแต่ -2,147,483,648 ถึง 2,147,483,647จำนวนเต็มลบจะได้ตั้งแต่ –1 ถึง

-2,147,483,648 คือกว้าง 2,147,483,648 จำนวนเต็มบวกมีค่าตังแต่ 1 ถึง 2,147,483,647คือกว้าง 2,147,483,647 ถ้าเราเอา 2,147,483,648 +2,147,483,648 จะได้เท่ากับ4,294,967,295 และถ้าเรารวมจำนวนเต็มศูนย์คือ 0 ด้วยอีกตัว เราก็จะได้ 4,294,967,296

ส่วน unsigned int ใน Compiler ที่ใช้หน่วยความจำ 32 บิทนั้นมีค่าตังแต่ 0 ถึง4,294,967,295 จะเห็นได้ว่าหลักการของ int และ unsigned int ใน Compiler ที่ใช้หน่วยความจำ32 บิทนั้นมีหลักการเดียวกันกับ int และ unsigned int ใน Compiler 16 ที่ใช้หน่วยความจำบิท จะต่างกันก็ตรงที่ ใน

Compiler  ที่ใช้หน่วยความจำ16 บิท int หรือ unsigned int มีความกว้าง เท่ากับ 2¹⁶ = 65536

Compiler ที่ใช้หน่วยความจำ 32 บิท int หรือ unsigned int มีความกว้าง เท่ากับ 2³² = 4,294,967,296  

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

การกำหนดค่าที่มากกว่าที่ตัวแปรกำหนดได้

สำหรับ int(16 บิท) คือ

การกำหนดค่าที่มากกว่าที่ตัวแปรกำหนดได้ คือการกำหนดค่าให้ตัวแปร intมากกว่าค่ามากที่สุดที่กำหนดได้คือ 32767

ถ้าหากเราเขียน Source code ว่า

int i;

i=32768;

แบบนี้ถือว่าเป็นการกำหนดค่ามากกว่าค่าที่มากที่สุดอยู่ 1

หรือถ้าเราเขียนว่า

i = 32868

แบบนี้ถือว่าเป็นการกำหนดค่ามากกว่าค่าที่มากที่สุดอยู่ 100

ถ้ากำหนดค่ามากกว่า 32767 อยู่ 1 จะกลับไปเริ่มที่ค่าที่น้อยที่สุดคือ –32768 หรือ

ถ้ากำหนดค่ามากกว่า 32767 อยู่ 10 ก็จะได้ค่าเท่ากับ –32768 + 9  = -32759

ถ้ากำหนดค่ามากกว่า 32767 อยู่ 200 ก็จะได้ค่าเท่ากับ –32768 + 199 = -32569

 การกำหนดค่าที่น้อยกว่าที่ตัวแปรกำหนดได้ คือการกำหนดค่าให้ตัวแปร int น้อยกว่าค่าน้อยที่สุดที่กำหนดได้คือ -32768

ถ้าหากเราเขียน Source code ว่า

int i;

i=-32769;

แบบนี้ถือว่าเป็นการกำหนดค่าน้อยกว่าค่าที่น้อยที่สุดอยู่ 1

หรือถ้าเราเขียนว่า

i = -32868

แบบนี้ถือว่าเป็นการกำหนดค่าน้อยกว่าค่าที่น้อยที่สุดอยู่ 100

ถ้ากำหนดค่าน้อยกว่า –32768 อยู่ 1 จะกลับไปเริ่มที่ค่าที่มากที่สุดคือ 32767 หรือ

ถ้ากำหนดค่า น้อยกว่า -32768 อยู่ 10 ก็จะได้ค่าเท่ากับ 32767 - 9  = 32758

ถ้ากำหนดค่า น้อยกว่า -32768 อยู่ 200 ก็จะได้ค่าเท่ากับ 32767 - 199 = 32568

สำหรับ unsigned int(16 บิท) คือ มีรูปแบบเดียวกันกับ int จะแตกต่างกันก็ตรงที่ ถ้ากำหนดค่ามากกว่าค่าที่มากที่สุดคือ 65535 จะกลับไปเริ่มที่ 0 หรือ กำหนดค่าน้อยกว่า 0 จะกลับไปเริ่มที่ 65535 

โปรแกรมที่ 4-5 ตัวอย่างความกว้างของตัวแปร int และการกลับไปเริ่มค่าใหม่

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int i;

5: i = -3000;

6: cout << "i =-3000 : " << i << endl;

7:

8: i = 32767;

9: cout << "i =32767 : " << i << endl;

10:

11: i = i + 1;

12: cout << "i = i + 1 : " << i << endl;

13:

14: i = i + 3;

15: cout << "i = i + 3 : " << i << endl;

16:

17: i = i - 10;

18: cout << "i = i -10 : " << i << endl;

19:

20: return 0;

21:}

Output

i = -3000 :-3000

i =32767 :32767

i = i + 1 :-32768

i = i + 3 :-32765

i = i - 10 :32761

อธิบาย Source code

โปรแกรมนี้เป็นโปรแกรมที่แสดงให้เห็นถึงความกว้างของตัวแปร int ใน Compiler ที่ใช้หน่วยความจำ16 บิท

บรรทัดที่ 5:เป็นการกำหนดให้ตัวแปร i มีค่า –3000 และ บรรทัดที่ 6 เป็นการสั่งให้แสดงผลค่าตัวแปร i ซึ่งได้ –3000

บรรทัดที่ 8:เป็นการกำหนดให้ตัวแปร i มีค่า32767 และบรรทัดที่ 9 สั่งให้แสดงผลออกมา ซึ่งก็ได้ 32767

บรรทัดที่ 11: i=i+1 เป็นการกำหนดให้ตัวแปร i มีค่าเท่ากับ ตัว แปร i ที่บวก 1 ด้วย ซึ่งมันก็คือการเพิ่มค่าให้กับตัวแปร i อีกหนึ่ง แล้วบรรทัดที่ 12 ก็เป็นการสั่งให้แสดงผลค่าตัวแปร iซึ่งได้ –32768 ทำไมถึงเป็น –32768 ทำไมไม่เป็น 32768 สาเหตุเพราะว่าตัวแปร i เป็นประเภท integer ซึ่งสามารถมีค่าได้มากสุด 32767 ถ้าเราเพิ่มเข้าไปอีก 1 ค่าก็จะกลับไปเริ่มต้นใหม่ที่ค่าที่น้อยที่สุดคือ –32768

บรรทัดที่ 14:เป็นการสั่งให้เพิ่มค่า i อีก 3 ซึ่งตอนนี้ iเป็น –32768 ก็จะ ได้ –32765

บรรทัดที่ 17:เป็นการสั่งให้ลดค่า i ไป 10 ซึ่ง i ตอนนี้เป็น –32765 เมื่อลบไปอีก 10 ก็ควรจะเป็น –32775 แต่ ตัวแปร int ใน C++ สามารถเก็บค่าได้น้อยที่สุดคือ –32768 เท่านั้น

จำนวน -32775 น้อยกว่า

 -32768 อยู่ 7

เพราะฉะนั้นค่า i จึงไปเริ่มต้นใหม่ที่ค่าที่มากที่สุดคือ 32767 เปนจำนวนแรก และยังต้อง – 6อีกด้วย(จำนวนแรกรวมกับ 6 จึงได้ 7) จึงได้ 32761

ความละเอียดของตัวแปร float

 ในความเป็นจริงแล้วตัวแปร float เราควรใช้เก็บข้อมูลตัวเลขประมาณ 7 ตำแหน่งเท่านั้น เช่นถ้าเราเขียน Source code แบบนี้

 float F;

 F = 111111111; // จำนวนเต็มความกว้าง 9 หลัก

 ค่า F จะเท่ากับ 1.11111e+08

1.11111e+08 จะเท่ากับ 1.11111 * 10⁸ หรือเท่ากับ

1.11111 * 100000000

ซึ่ง จำนวน 1.11111 * 100000000

จะมีค่าเท่ากับ 111111000

เรากำหนดค่า F ให้เท่ากับ 111111111 แต่ค่า F จะเก็บแค่ 111111000 ซึ่งจะเห็นได้ว่า ตัวแปร Float ในบางครั้ง จะเก็บข้อมูลตัวเลขได้แค่ 6 ตำแหน่งเท่านั้น(ขึ้นอยู่กับCompiler หรือเครื่อง คอมที่ใช้ด้วย)ถ้ามีมากกว่านั้นจะแปลงเป็น 0

เราสามารถใช้ cout.precision ในการกำหนดตำแหน่งของ จำนวนทำศนิยมของตัวแปร float ที่จะใช้ในการแสดงข้อความได้ โดยมีรูปแบบดังนี้

 cout.precision(จำนวนตำแหน่งทศนิยมที่ต้องการให้แสดงผล)

เช่น cout.precision(5);

มีความหมายว่ากำหนดให้แสดงตำแหน่งทศนิยม 5 ตำแหน่ง

เมื่อเรากำหนดไป 1 ครั้งแล้ว โปรแกรมก็จะทำงาน โดยที่เวลาเราสั่งให้แสดงผลตัวแปร float โปรแกรมก็จะแสดงผล โดยมีทศนิยม 5 ตำแหน่งไปตลอดทั้งโปรแกรม โดยที่เราไม่ต้องกำหนดอีกเวลาเราสั่งให้แสดงผลในแต่ละครั้ง อย่างไรก็ตามถ้าเรากำหนดค่า เกิน7 ตำแหน่ง โปรแกรมอาจจะมีการแสดงผลที่ได้ไม่ตรงตามต้องการ

(ขึ้นอยู่กับ Compiler หรือเครื่อง คอมที่ใช้)

โปรแกรมที่ 4-6 แสดงตัวอย่างความละเอียดของตัวแปร float

Source code

1:#include"iostream.h"

2:int main()

3:{

4: float i;

5: cout.precision(30);

6:

7: i = 0.1234567;

8: cout << i << endl;

9:

10: i = 0.123456789012;

11: cout << i << endl;

12:

13: i = 0.12345678901234567890;

14: cout << i;

15:

16: return 0;

17:}

Output

โปรแกรมนี้จะลองใช้ 2 Compilerใน การ Runคือ

 1.Compiler  Visual C++6.0

0.1234567

0.1234567

0.1234567

 2. Compiler Turbo C++ 4.5

0.123456701636314392

0.123456710432810555

0.123456710432810555

Output ของเครื่องคอมของผู้อ่านอาจได้ผลไม่เหมือนกัน

ทั้ง 2 Compiler ได้ผลลัพธ์ไม่ เหมือนกัน คือ แต่ใน Visual C++ ในหน้าต่างที่แสดงผลการCompiler  และแสดงผลถ้าหากมี Error (ใน Visual C++ เรียกว หน้าต่างที่ทำหน้าที่คล้ายๆ หน้าต่าง Message ใน Turbo C++ ว่า Output ทั้งๆที่ไม่ได้แสดงผลการทำงานของโปรแกรมสักหน่อย) จะมีข้อความว่า

C:\Test.cpp(7) : warning C4305: '=' : truncation from 'const double' to 'float'

อย่างนี้ประมาณ 3 ครั้ง โดยที่ ในแต่ละครั้ง ตัวเลขในวงเล็บ C:\Test.cpp()จะไม่เหมือนกันจะประกอบไปด้วย 7 10 13 นั่นเป็นข้อความเตือนของ Compiler ว่าข้อมูลที่เรากำหนดให้ตัวแปร float ในบรรทัดที่ 7 10 13 นั้นเป็นการเกินขนาดของตัวแปร float  Compiler จะเข้าใจว่าข้อมูลที่เรากำหนดให้คือ double เนื่องจากตัวแปร double สามารถกำหนดข้อมูลได้มากกว่าตัวแปร float

อธิบาย Source code

บรรทัดที่ 5: cout.precision(30); มีความหมายว่าเป็นการกำหนดตำแหน่งทศนิยมเวลาแสดงผลให้เท่ากับ 30 จากนั้นเราก็กำหนดค่าให้กับตัวแปร i ในบรรทัดที่ 7,10,13 และก็แสดงผลออกมาในบรรทัดที่ 8,11,14 ซึ่งค่าที่ได้ก็จะขึ้นกับ Compiler หรือเครื่องคอมที่ใช้

การปัดค่าตัวแปรทศนิยมของตัว แปร float

โปรแกรมที่ 4-7 แสดงตัวอย่างของการปัดค่าทศนิยมโดยตัวแปร float

Source code

1:#include"iostream.h"

2:int main()

3:{

4: float i;

5: i=111111.008;

6: cout << i << endl;

7:

8: i=111.490;

9: cout << i << endl;

10:

11: i=111.495;

12: cout << i << endl;

13:

14: i=111.499;

15: cout << i << endl;

16:

16: i=111111.495;

17: cout << i << endl;

18:

19: i=111111.499;

20: cout << i << endl;

21:

22: i=111111.500;

23: cout << i << endl;

24:

25: i=111111.701;

26: cout << i << endl;

27:

28: i=111111.991;

29: cout << i << endl;

30:

31: return 0;

32:}

Output

111111

111.49

111.495

111.499

111111

111111

111112

111112

111112

อธิบาย Source code

บรรทัดที่ 5:เป็นการกำหนดให้ตัวแปร i = 111111.008 บรรทัดที่ 6:เป็นการสั่งให้แสดงค่า iซึ่งได้ 111111

จะเห็นได้ว่าถ้ามีจำนวนเต็มครบ 6 หลักแล้ว เลขทศนิยมตัวต่อไปไม่มีค่ามากพอที่จะปัดขึ้น ตัวแปร float ก็จะตัดทิ้งเลย

บรรทัดที่ 7,11,14: เป็นการกำหนดให้ตัวแปร i มีค่า 111.49,111.495,111.499 ตามลำดับ ซึ่งเลขทั้ง 3 ตัวนี้รวมทศนิยมแล้วไม่เกิน 6 หลัก เมื่อสั่งให้แสดงผล จึงได้เท่ากับตอนที่กำหนด คือ ถ้าตัวแปร float ถูกกำหนดค่าไม่เกิน 6 หลัก ก็จะเก็บค่านั้นไว้โดยไม่ปัดทศนิยมขึ้นหรือลง

บรรทัดที่ 16,19:เป็นการกำหนดค่าให้ตัวแปร i เท่ากับ 111111.495 และ 111111.499 คือมีตัวแลขรวมทศนิยมแล้วมากกว่า 6 หลัก เมื่อสั่งให้แสดงผลแล้วจะได้ 111111 ทั้ง 2 ครั้ง นั่นแสดงให้เห็นว่าถ้าตัวที่เกินทศนิยมตำแหน่งแรกมีค่าไม่ถึงที่จะปัดขึ้น Compiler จะไม่สนใจและก็จะไม่นับ

บรรทัดที่ 22,25,28;เป็นการกำหนดค่าให้ตัวแปร i เท่ากับ111111.500,111111.701,111111.991 ตามลำดับ แล้วเมื่อสั่งให้แสดงผล ก็จะได้ 111112ทั้ง 3 ครั้ง จะเห็นได้ว่าในกรณีที่ตัวเลขทั้งหมดเกิน 6 หลัก แล้วถ้าตัวเลขตัวแรกของทศนิยมมีค่ามากกว่าหรือเท่ากับ 5 Compiler จะปัดขึ้นให้

C++ ไม่สนับสนุนการประกาศตัวแปรโดยไม่กำหนดค่าเริ่มต้น

ถ้าหากตัวแปรที่เราประกาศเราไม่กำหนดค่าให้ตั้งแต่แรก เช่น

 int i = 5;

หรือ

 int i;

 i = 5;

โปรแกรมอาจจะไม่มีปัญหาอะไรหรือ ถ้าหากว่าโปรแกรมนั้นมีการรับค่าจากคีย์บอร์ดมากำหนดให้ตัวแปรเช่น

#include"iostream.h"

int main()

{

 int Salary;

 cout << "Please enter salary ";

 cin >> Salary;

cout << "Your salary = " << Salary;

return 0;

}

โปรแกรมนี้เป็นการให้ผู้ใช้ ป้อนข้อมูลเงินเดือน ผ่านทางคีย์บอร์ด จากนั้นก็พิมพ์ค่าออกมาทางจอภาพ

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

โปรแกรมที่ 4-8

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int A,B,C,D,E;

5:

6: cout << A << endl;

7: cout << B << endl;

8: cout << C << endl;

9: cout << D << endl;

10: cout << E << endl;

11:

12: return 0;

13:}

Output  เครื่องของผู้อ่านอาจแสดงผลได้ไม่ตรงกับ Output

18125

25375

8653

-1

3456

อธิบาย Source code

บรรทัดที่ 4:เป็นการประกาศตัวแปรประเภท int ชื่อ A,B,C,D,E โดยที่ยังไม่ได้กำหนดค่าให้

บรรทัดที่ 6 ถึง 10: เป็นการสั่งให้แสดงผลค่าตัวแปร A,B,C,D,E ตามลำดับซึ่งค่าที่ได้ก็อย่างที่แสดงผลให้เห็นอย่างใน Output เรายังไม่ได้กำหนดค่าให้ตัวแปรเลยซักตัว แต่ทำไมค่าที่ได้ถึงเป็น 18125,25375 … นั่นแสดงให้เห็นว่า เมื่อเราประกาศตัวแปรขึ้นมา Compiler จะกำหนดค่าให้กับตัวแปรขึ้นมาก่อนซึ่งเราไม่อาจรู้ได้เลยว่าค่าที่ Compiler กำหนดขึ้นมาให้นั้นมีค่าเป็นเท่าใน เพราะฉะนั้นเวลาเราจะนำตัวแปรไปใช้โดยที่ตัวแปรนั้นไม่มีการรับค่าจากทาง คีย์บอร์ดหรือเราไม่ได้กำหนดค่าใน ตอนประกาศ เราควรกำหนดค่าให้กับตัวแปรก่อน

ตัวแปร char

 ใน C++ ไม่มีตัวแปรประเภท String มีแต่ตัวแปรประเภท char โดยที่ตัวแปร charจะสามารถกำหนดค่าได้ 1 ตัวอักษร โดยวิธีกำหนดค่าให้กับตัวแปร char มีรูปแบบดังนี้

 ตัวแปรChar  = ข้อความ1ตัวอักษรโดยที่ต้องอยู่ในเครื่อง หมาย ‘ ‘

 char Code;

 Code = ‘Z’;

โปรแกรมที่ 4-9 แสดงตัวอย่างวิธีใช้ตัวแปร char

Source code

1:#include"iostream.h"

2:int main()

3:{

4: char A,B,C;

5: A='H';

6: B='7';

7: C='!';

8:

9:

10: cout << A << endl;

11: cout << B << endl;

12: cout << C << endl;

13: return 0;

14:}

Output

H

7

!

อธิบาย Source code

บรรทัดที่ 4 :เป็นการประกาศตัวแปรประเภท char 3 ตัวชื่อ A,B,C

บรรทัดที่ 5,6,7 :เป็นการกำหนดข้อมูลให้กับตัวแปร char ทั้ง 3 ตัวคือ A,B,C ข้อมูลที่กำหนดให้คือ H,7,! ตามลำดับจะเห็นได้ว่าข้อมูลที่กำหนดให้ต้องอยู่ในเครื่องหมาย ‘ ‘ และยังต้องมีแค่ 1 ตัวอักษร 1ตัวอักษรในที่นี้จะเป็นตัวเลขหรือเครื่องหมายก็ได้

บรรทัดที่ 10,11,12 :เป็นการสั่งให้พิมพ์ค่าตัวแปร char ทั้ง 3 ตัวออกมา

การใช้ตัวแปร char ที่สามารถเก็บได้หลายตัวอักษร เราสามารถใช้ตัวแปร char ที่สามารถเก็บได้หลายตัวอักษรหรือเก็บเป็นข้อความได้ โดยต้องประกาศตัวแปร char เป็น arrayสำหรับรายละเอียดเรื่องนี้จะกล่าวในบที่ 7 array and String

คอนสแตนต์

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

Defined คอนสแตนต์

 define ความหมายตามพจนานุกรมแปลว่า กำหนด,นิยาม

define คอนสแตนต์เป็น เป็น คอนสแตนต์ที่จะใช้ preprocessor directiveทำการกำหนด ไอเด็นทิฟายเออร์ ที่เราต้องการให้เป็นค่าคงที่ preprocessor directive จะทำงานก่อน Compile โดยจะทำการแทนที่สิ่งที่เรากำหนดก่อน ที่จะทำการ Compile defineคอนสแตนต์ จะไม่เสียเนื้อที่ในหน่วยความจำเท่ากับตัวแแปร

define คอนสแตนต์ มีรูปแบบดังนี้

#define ชื่อของคอนสแตนต์ ค่าที่ต้องการให้เป็นค่าคง

เช่นถ้าเรา

#define Pi 3.141

หมายความว่าเราได้กำหนด(define)ค่าคงที่ที่ชื่อ Pi ให้มีค่าเท่ากับ 3.14159265

เมื่อเราเขียนโปรแกรมหากใน Source code เรามี ไอเด็นทิฟายเออร์ที่ชื่อ Pi Compiler จะทำการแทนที่ ไอเด็นทิฟายเออร์นั้น ให้เป็นค่า 3.141

โปรแกรมที่ 4-10 ตัวอย่างการใช้ define คอนสแตนต์

Source code

1:#include"iostream.h"

2:#define Pi 3.141

3:int main()

4:{

5: cout << Pi * 10;

6:

7: return 0;

8:}

Output

31.41

อธิบาย Source code

บรรทัดที่ 2:เป็น define คอนสแตนต์ ชื่อ Pi มีค่าเท่ากับ 3.141

บรรทัดที่ 5:มี Source code ว่า

 cout << Pi * 10;

จะมีการทำงานเหมือน

 cout << 3.141 * 10;

เนื่องจากเราได้ define คอนสแตนต์ที่ชื่อ Pi ให้มีค่า 3.141 เมื่อเราสั่ง Compile Compilerจำทำการหา ไอเด็นทิฟายเออร์ ชื่อ Pi ถ้าหาเจอจะทำการแทนค่า 3.141 ให้

Variable คอนสแตนต์

 Variable คอนสแตนต์ เป็น คอนสแตนต์ ที่คล้ายตัวแปรเพียงแต่ต้องทำการกำหนดค่าตั้งแต่ตอนประกาศและจะไม่สามารถกำหนดค่าใหม่ได้

Variable คอนสแตนต์ มีรูปแบบดังนี้

 const ประเภทตัวแปร ชื่อตัวแปร = ค่า;

เช่น

 const float Pi = 3.141;

หมายความว่า Pi เป็น คอนสแตนต์ ประเภท float มีค่าเท่ากับ 3.141

โปรแกรมที่ 4-11 ตัวอย่างการใช้ Varible คอนสแตนต์

Source code

1:#include"iostream.h"

2:int main()

3:{

4: const  float Pi = 3.141;

5: cout << Pi * 10;

6:

7: return 0;

8:}

Output

31.41

อธิบาย Source code

บรรทัดที่ 4 :เป็นการประกาศ Varible คอนสแตนต์ ชื่อ Pi เป็นประเภท float มีค่า 3.141

บรรทัดที่ 5 : เป็นการสั่งให้พิมพ์ค่า Pi * 10 จะมีความหมายเท่ากับ 3.141 * 10

escape code คอนสแตนต์

 escape code คอนสแตนต์ เป็นคอนสแตนต์ชนิดตัวอักษรที่ต้องมีเครื่องหมาย \ นำหน้าและต้องอยู่ในเครื่องหมาย ‘ ‘ หรือในเครื่อง หมาย “ “ คอนสแตนต์ประเภทนี้ประกอบไปด้วย

escape code ชื่อ ลักษณะการทำงาน

\n  newline  ขึ้นบรรทัดใหม่

\r  carriage return  เหมือนการกด enter

\t  tabulation  เหมือนการกด tab

\b  backspace  เหมือนการกด backspace

\f  page feed  ขึ้นหน้าใหม่

\a  alert (beep)  ส่งเสียง beep

\'  single quotes (')  แสดงเครื่องหมาย ‘

\"  double quotes (")  แสดงเครื่องหมาย “”

\  question (?)  แสดงเครื่องหมาย ?

\\  inverted slash (\)  แสดงเครื่องหมาย \

เราสามารถใช้ escape code โดยใช้ร่วมกับ cout ได้เช่น

 cout << “\n”;

แบบนี้จะเป็นการขึ้นบรรทัดใหม่

escape code จะใช้ระหว่างข้อความหรือก่อนข้อความหรือหลังข้อความก็ได้โดยจะมีการทำงานต่างกัน

เช่น escape code \n จะมีการทำงานเหมือนกับ endl

ถ้าเราเขียน Code แบบนี้

 cout << “\nC++ is easy”;

จะมีการทำงานเหมือนกับ

 cout << endl << “C++ is easy”;

ถ้าเราเขียน code แบบนี้

 cout << “C++ is easy\n”;

จะมีการทำงานเหมือนกับ

 cout << “C++ is easy” << endl;

เราสามารถเขียน escape code ได้หลายแบบเช่น

 cout << "Hello" << '\n';

 cout << "Hello\n";

 cout << "Hello" << "\n";

ทั้ง 3 แบบนี้จะมีการทำงานเหมือนกัน

การเปลี่ยนแปลงชนิดข้อมูล

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

#include"iostream.h"

int main()

{

 int a,b;

 a = 13;

 b = 2;

 cout << a / b;

 return 0;

}

Output จะได้ 6 ซึ่งจริงๆแล้ว 13/2 ในทางคณิตศาสตร์ ควรได้ 6.5 ต่างหาก

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

โปรแกรมที่ 4-12 ตัวอย่างการเปลี่ยนแปลงประเภทตัวแปร

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int a,b;

5: a = 13;

6: b = 2;

7: cout << a / float(b);

8: return 0;

9:}

Output

6.5

อธิบาย Source code

บรรทัดที่ 7:เป็นการสั่งให้ แสดงข้อมูล ตัวแปร a หาร ตัวแปร b โดยที่ ให้แปลงประเภทของตัวแปร b เป็น float ก่อนคำตอบที่ได้เลยสามารถเป็น ทศนิยมได้

สาเหตุที่ทำไมเราแปลงแค่ตัวแปร b ตัวเดียวทำไมเราไม่ต้องแปลงตัวแปล a ด้วย

เพราะว่าใน  C++ ถ้าหาก ตัวแปรคนละประเภทมาทำการ โอเปอเรเตอร์กัน Compiler จะทำการแปลงให้เอง

โดยรายละเอียดของการแปลงประเภทของตัวแปรจะกล่าวต่อไปในบทนี้

การแปลงประเภทของตัวแปรโดย Compiler

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

เช่น

 int A = 10;

 float B = 7.5;

 cout << A * B;

คำตอบจะได้ 70.5

เมื่อเราสั่งให้ A * B โดยที่ A เป็น int  และ B เป็น float

Compiler จะทำการแปลงประเภทของตัวแปร A ให้เป็น float ชั่วคราวเนื่องจากว่าตัวแปร Aเป็นตัวแปร int ซึ่งใช้ขนาดหน่วยความจำน้อยกว่าตัวแปร B ซึ่งเป็นประเภท float

โอเปอเรเตอร์เพิ่มค่าและลดค่าเลขคณิต

 ถ้าหากเราเขียนโปรแกรมว่า

 int A=5;

 A = A+1;

 แบบนี้ค่า A ก็จะเป็น 6 นี่เป็นตัวอย่างการเพิ่มค่าให้กับตัวแปรอีก 1 แบบธรรมดา

ถ้าหากเราจะเพิ่มค่าให้กับตัวแปรอีก 1 เราสามารถใช้ โอเปอเรเตอร์ เพิ่มค่าได้โดยใช้ โอเปอเรเตอร์เพิ่มค่าเลขคณิต

 เช่น

 ++A;

 ถ้าเขียนแบบนี้ค่า A ก็จะเพิ่มขึ้นอีกหนึ่ง เหมือน Statement A = A+1;

 นอกจากโอเปอเรเตอร์เพิ่มค่าแล้วยังมีโอเปอเรเตอร์ลดค่าอีกโดยใช้เครื่องหมาย—

 เช่นเราเขียนว่า

 --A ค่า A ก็จะลบไป 1 เหมือน Statement A = A-1ว

 โอเปอเรเตอร์เพิ่มค่าและลดค่าเลขคณิตมีวิธีใช้ 2 แบบคือ

 1.prefix ใช้โอเปอเรเตอร์เพิ่มค่าหรือลดค่าอยู่ข้างหน้าตัวแปรเช่น ตัวแปรชื่อ A ต้องการใช้ โอเปอเรเตอร์เพิ่มค่าก็ให้เขียนว่า ++A ถ้าต้องการใช้ โอเปอเรเตอร์ลดค่าก็ให้เขียนว่า –A;

 2.postfix ใช้โอเปอเรเตอร์เพิ่มค่าหรือลดค่าอยู่ข้างหลังตัวแปรเช่น ตัวแปรชื่อ A ต้องการใช้ โอเปอเรเตอร์เพิ่มค่าก็ให้เขียนว่า A++ ถ้าต้องการใช้ โอเปอเรเตอร์ลดค่าก็ให้เขียนว่า A--;

 ความแตกต่างของการใช้โอเปอเรเตอร์เพิ่มค่าลดค่าแบบ prefix กับ แบบ postfixคือ

 แบบ prefix โอเปอเรเตอร์จะทำงานเป็นอันดับแรกก่อนที่การทำงานอื่นใน Statement จะทำงาน

 เช่น

 int A=5,B=0;

 B = ++A ;

 ค่า B จะได้ 6 ค่า A ก็จะได้ 6 เนื่องจากว่า ++A มีความหมายว่าให้เพิ่มค่า A เข้าไปอีก 1ก่อนที่จะทำงานอย่างอื่น ในเมื่อค่า A ทำการเพิ่มอีก 1 จนได้เท่ากับ 6 แล้ว จึงกำหนดค่าตัวแปร B ให้เท่ากับ A ซึ่งจะได้

6 ทั้งคู่

 แบบ postfix โอเปอเรเตอร์จำทำงานหลังจากที่การทำงานทุกอย่างใน Statement นั้นจบลงแล้ว

 เช่น

 int A=5,B=0;

 B = A++;

 ค่า B จะได้ 5 ไม่ได้ 6 แต่ค่า A จะเป็น 6 สาเหตุที่เป็นแบบนี้เนื่องจาก A++ มีความหมายว่าให้เพิ่มค่า A ไปอีก 1 หลังจากที่ทำงานทุกอย่างใน Statement นี้หมดแล้ว ซึ่งในกรณีนี้

 B = A++;

 จะเท่ากับ

 B = 5;

 เนื่องจากค่า A ในตอนนั้นเป็น 5 แต่พอหลังจากจบการทำงานใน Statement นี้แล้ว ค่า A ก็จะค่อยไปทำงาน โอเปอเรเตอร์ ++ คือเพิ่มค่าอีก 1 เป็น 6

โปรแกรมที่ 4-13 แสดงตัวอย่างการใช้โอเปอเรเตอร์เพิ่มค่าลดค่าแบบ prefix และ postfix

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int A=5,B=6;

5: int C=0;

6:

7: cout << "A = " << A << endl;

8: cout << "B = " << B << endl;

9: cout << endl;

10:

11: C = A++;

12: cout << "C = A++" << endl;

13: cout << "A = " << A << endl;

14: cout << "C = " << C << endl;

15: cout << endl;

16:

17: C = ++A;

18: cout << "C = ++A" << endl;

19: cout << "A = " << A << endl;

20: cout << "C = " << C << endl;

21: cout << endl;

22:

23: C =++B + A++;

24: cout << "C = ++B + A++" << endl;

25: cout << "A = " << A << endl;

26: cout << "B = " << B << endl;

27: cout << "C = " << C << endl;

28: cout << endl;

29:

30: C =--A + --B;

31: cout << "C =--A + --B" << endl;

32: cout << "A = " << A << endl;

33: cout << "B = " << B << endl;

34: cout << "C = " << C << endl;

35: cout << endl;

36:

37: return 0;

38:

39:}

Output 

A = 5

B = 6

C = A++

A = 6;

C = 5;

C = ++A

A = 7

C = 7

C = ++B + A++

A =8

B =7

C =14

C =--A + --B

A =7

B =6

C =13

อธิบาย Source code

บรรทัดที่ 4,5:เป็นการประกาศตัวแปร ประเภท int ชื่อ A,B,C โดยกำหนดให้ A=5,B =6,C=0

บรรทัดที่ 11:C = A++ เป็นการกำหนดค่าตัวแปร C ให้เท่ากับตัวแปร A แล้วหลังจากที่จบStatement นี้แล้วค่า A จะเพิ่มอีกหนึ่ง ซึ่งบรรทัดที่ 12,13 เป็นการสั่งให้พิมพ์ค่าตัวแปร Aและ C ตามลำดับ ซึ่งค่า ตัวแปร C จะได้ 5

ส่วนค่าตัวแปร A จะได้ 6

บรรทัดที่ 17:C = ++A เป็นการกำหนดให้ค่าตัวแปร A เพิ่มขึ้นอีก 1 แล้วหลังจากนั้นจึง กำหนดค่าให้กับ ตัวแปร C ซึ่งก่อนที่จะมาถึง Statement นี้ ค่าตัวแปร A จะเป็น 6 แล้วหลังจากที่เพิ่มขึ้นอีก 1 จึงเป็น 7 หลังจากนั้นค่อยกำหนดค่าตัวแปร C ให้เท่ากับ ตัวแปร A ซึ่งค่าตัวแปรทั้ง 2 ตัวจะได้ค่าเท่ากันคือ 7

บรรทัดที่ 23: C =++B + A++

 ก่อนที่จะมาถึง Statement นี้ตัวแปร A ,มีค่า 7 B มีค่า 6

 ซึ่ง Statement นี้เป็นการกำหนดให้ตั้วแปร B เพิ่มขึ้นอีก 1 คือเป็น 7 หลังจากนั้น จะเป็นการกำหนดค่า ตัวแปร C ให้เท่ากับ B + A ซึ่งจะได้ 14 แล้วค่อยเพิ่มค่าตัวแปร A อีก 1คือเป็นค่า 8

 ซึ่งหลังจากจบ Statement นี้แล้วค่าตัวแปร

 A จะเท่ากับ 8

 B จะเท่ากับ 7

 C จะเท่ากับ 14

สาเหตุที่เราทำการกำหนดค่าให้ตัวแปร C แล้วค่อยเพิ่มค่าตัวแปร A อีก 1 เนื่องจาก โอเปอเรเตอร์เพิ่มค่าเป็น แบบ postfix คืออยู่ข้างหลังตัวแปร และจะทำที่หลัง

บรรทัดที่ 30: C =--A + --B จะมีความหมายเท่ากับให้ ลดค่า A ไป1 และลดค่า B ไป 1 คือเป็น 7 กับ 6 ตามลำดับและหลังจากนั้นจึงกำหนดค่าให้กับ ตัวแปร C ซึ่งหลังจากการทำงานStatement นี้แล้วค่าตัวแปร

 A จะเท่ากับ 7

 B จะเท่ากับ 6

 C จะเท่ากับ 13

การใช้โอเปอเรเตอร์เพิ่มค่าหรือลดค่าแบบกับตัวแปรเดียวกันภายใน 1 Statement

 เราได้รู้แล้วว่า ถ้าเราเขียน Code

 int A = 5;

 ++A;

 ค่า A ก็จะได้ 6

แล้วถ้าใน Statement มีการใช้ โอเปอเรเตอร์เพิ่มค่าหรือ ลดค่า แบบ prefix มากกว่าหนึ่งครั้งกับตัวแปรเดียวกันล่ะเช่น

 int A =5,B =0;

 B = ++A + ++A

 ค่า B ควรจะเป็นเท่าไหร่

โปรแกรมที่ 4-14 ตัวอย่างการใช้ โอเปอเรเตอร์เพิ่มค่าหรือ ลดค่า แบบ prefix มากกว่าหนึ่งครั้งกับตัวแปรเดียวกัน

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int A=5,B=0;

5: B =++A + ++A;

6: cout << A << endl;

7: cout << B;

8: return 0;

9:}

Output

7

14

อธิบาย Source code

บรรทัดที่ 4:ประกาศตัวแปร A และ B เป็นประเภท int โดยให้ A = 5,B = 0

บรรทัดที่ 5: เป็นการกำหนดค่าให้ตัวแปร B เท่ากับ ตัวแปร

Aที่ใช้โอเปอเรเตอร์เพิ่มค่า บวกกับ ตัวแปร Aที่ใช้โอเปอเรเตอร์เพิ่มค่า ซึ่งค่าของตัวแปร Aและ B จะถูกพิมพ์ออกมาในบรรทัดที่ 6และ 7 โดยที่ A ได้ 7 และ B ได้ 14

สาเหตุที่ B =++A + ++A;

แล้ว B ได้ 14 และ A ได้ 7 นั้น เป็นเพราะว่าเราได้กำหนดค่าเริ่มต้นตัวแปร A ให้เท่ากับ 5และเมื่อ ใน Statement มีการใช้ โอเปอเรเตอร์เพิ่มค่า 2 ครั้งกับตัวแปร A ตัวแปร จากการใช้ครั้งแรก ตัวแปร A จะเป็น 6

แล้วจากการใช้ครั้งที่ 2 ตัวแปร A จะเป็น 7 หลังจากนั้นจึงได้ทำการบวกกันจึงมีความหมายเท่ากับ

B = 7 + 7;

ไม่ใช่

B =6 + 7;

จะเห็นได้ว่า โอเปอเรเตอร์เพิ่มค่าแบบ prefix จะทำงานให้เสร็จหมดทุกตัวก่อนและก็จะค่อยทำงานอย่างอื่นโดยที่ใน Statement นั้นถ้าหากมีตัวแปรอะไรที่ใช้ โอเปอเรเตอร์ เพิ่มค่าหรือลดค่าตัวแปรนั้นก็จะต้องทำให้เสร็จก่อนและใน Statement นั้นค่าตัวแปรก็ต้องเป็นค่าเดียวกัน เช่น A ก็ต้องเท่ากับ 7 จะให้ A ตัวแรก เป็น 6 A ตัวที่ 2 เป็น 7 ไม่ได้

การใช้ โอเปอเรเตอร์เพิ่มค่าหรือ ลดค่า แบบ postfix มากกว่าหนึ่งครั้งกับตัวแปรเดียวกันใน 1 Statement

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

โปรแกรมที่ 4-15 ตัวอย่างการใช้ โอเปอเรเตอร์เพิ่มค่าหรือ ลดค่า แบบ postfix มากกว่าหนึ่งครั้งกับตัวแปรเดียวกัน

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int A=5,B=0;

5: B =A++ + A++;

6: cout << A << endl;

7: cout << B;

8: return 0;

9:}

Output

7

10

อธิบาย Source code

บรรทัดที่ 4:ประกาศตัวแปร A และ B เป็นประเภท int โดยให้ A = 5,B = 0

บรรทัดที่ 5: เป็นการกำหนดค่าให้ตัวแปร B เท่ากับ ตัวแปร

Aที่ใช้โอเปอเรเตอร์เพิ่มค่าแบบpostfix บวกกับ ตัวแปร A ที่ใช้โอเปอเรเตอร์เพิ่มค่าแบบpostfix ซึ่งค่าของตัวแปร A และ B จะถูกพิมพ์ออกมาในบรรทัดที่ 6และ 7 โดยที่ A ได้7 และ B ได้ 10

สาเหตุที่ B มีค่า 10 ก็เพราะว่า B=A++ + A++;

จะมีค่าเท่ากับ

B = 5 + 5;

เนื่องจาก โอเปอเรเตอร์แบบ postfix จะทำงานหลังจากที่การทำงานทุกอย่างใน Statementนั้นหมดแล้ว

แล้วสาเหตุที่ค่า A มีค่าเท่ากับ 7 ก็เพราะ ว่ามีโอเปอเรเตอร์เพิ่มค่า 2 ครั้ง โดยเมื่อครั้งแรกทำงานค่า A จะเป็น 6 แล้วเมื่อ ครั้ง ที่ 2 ทำงานค่า A ก็จะเป็น 7 แต่การทำงานทั้ง 2 ครั้งนั้นทำงานหลังจากที่กำหนดค่าบวกกัน(5+5)ให้กับตัวแปร B

โอเปอเรเตอร์กำหนดค่าเลขคณิต

 เราสามารถกำหนดค่าเลขคณิตได้โดยใช้เครื่องหมาย =

เช่น

 int A;

 A = 5;

หรือถ้าเราเขียน Code ว่า

 int A=5,B =3;

 A = A+B;

 ตัวแปร A จะมีค่า 8 ได้มาจากค่าตัวแปร A + B ซีงเท่ากับ 5+3

ถ้าหากเราจะเขียน Statement แบบนี้เราสามารถเขียนได้อีกแบบว่า

 A += B;

ถ้าเขียนแบบนี้จะเหมือนกับ

 A = A + B;

นี่คือการใช้ โอเปอเรเตอร์กำหนดค่าเลขคณิต

โอเปอเรเตอร์กำหนดค่าเลขคณิตมีดังนี้

+= , -=, *=, /=, %=

การทำงานมีดังนี้ เช่น A = 10

โอเปอเรเตอร์ ตัวอย่างการใช้ จะเหมือนกับ Statement ค่าของ A

+=  A+=3; A = A+3; 13

-=  A-=5; A = A –5;    8

*=  A*=2; A = A*2; 20

/=  A/=2 A = A / 2;    5

%=  A%=2 A = A %2;   0

โปรแกรมที่ 4-16 แสดงตัวอย่างการใช้ โอเปอเรเตอร์กำหนดค่าเลขคณิต

Source code

1:#include"iostream.h"

2:int main()

3:{

4: int A=5,B=7,C=0;

5: cout << "A = " << A << endl;

6: cout << "B = " << B << endl;

7: cout << "C = " << C << endl;

8: cout << endl;

9:

10: C += A;

11: cout << "C += A" << endl;

12: cout << "C = " << C << endl;

13: cout << endl;

14:

15: C += B;

16: cout << "C += B" << endl;

17: cout << "C = " << C << endl;

18: cout << endl;

19:

20: C *= B-A;

21: cout << "C *= B-A" << endl;

22: cout << "C = " << C << endl;

23: cout << endl;

24:

25: C /= A+1;

26: cout << "C /= A" << endl;

27: cout << "C = " << C << endl;

28: cout << endl;

29:

30: C %= 2;

31: cout << "C %= 2" << endl;

32: cout << "C = " << C << endl;

33: cout << endl;

34: return 0;

35:}

Output

A = 5

B = 7

C = 0

C += A

C = 5

C += B

C =12

C *= B-A

C =24

C /= A

C = 4

C %=2

C = 0

อธิบาย Source code

บรรทัดที่ 4:เป็นการประกาศตัวแปรชื่อ A,B,C โดยกำหนดค่าให้ A = 5,B = 7,C = 0 แล้วบรรทัดที่ 5,6,7 เป็นการสั่งให้พิมพ์ค่า A,B,C

บรรทัดที่ 10: C+=A เป็นการใช้โอเปอเรเตอร์กำหนดค่า โดย Statement นี้จะมีการทำงานเหมือนกับ

C = C + A

ซึ่งถ้าเราเปรียบเทียบเป็นค่าของตัวแปรจะเท่ากับ

C = 0 + 5

ซึ่งตัวแปร C จะได้ 5 และจะแสดงผลออกมาในบรรทัดที่ 12

บรรทัดที่ 15:C+=B Statement นี้จะมีการทำงานเหมือนกับ

C = C + B

ซึ่งถ้าเราเปรียบเทียบเป็นค่าของตัวแปรจะเท่ากับ

C = 5 + 7

ตัวแปร C จะได้ 12 และจะแสดงออกมาในบรรทัดที่ 17 

บรรทัดที่ 20: C*=B-A Statement นี้จะมีการทำงานเหมือนกับ

 C = C * (B-A)

ซึ่งถ้าเราเปรียบเทียบเป็นค่าของตัวแปรจะเท่ากับ

C = 12 *(7-5)

ตัวแปร C จะได้ 24 สาเหตุที่ทำไมการใช้ โอเปอเรเตอร์กำหนดค่าถึงไม่ทำงานแบบ Statement นี้

C = C * B – A

ซึ่งถ้า โอเปอเรเตอร์กำหนดค่าทำงานตามรูปแบบนี้ ตัวแปร C จะได้ 79 โดยที่ได้จาก

C = 12 * 7 – 5

เนื่องจาก โอเปอเรเตอร์กำหนดค่าจะทำงาน หลังจากค่าที่กำหนดได้ทำการ โอเปอเรเตอร์กันหมดก่อน เช่น ให้ B – A ให้เสร็จก่อน จากนั้น โอเปอเรเตอร์กำหนดค่าจึงกำหนดให้ C = C *(ค่าที่ได้จาก B-A)

บรรทัดที่ 25: C /= A+1 จะมีการทำงานเหมือน Statement

 C = C / (A+1)

ซึ่งถ้าเราเปรียบเทียบเป็นค่าของตัวแปรจะเท่ากับ

 C = 24 / (5+1)

 ซึ่งค่า C จะได้ 4 จะเห็นได้ว่า โอเปอเรเตอร์กำหนดค่า จะทำการ หลังจากที่สิ่งที่เรากำหนด ทำการโอเปอเรเตอร์กันหมดเเล้ว

บรรทัดที่ 30: C %= 2 จะมีการทำงานเหมือนกับ Statement

 C = C % 2

ซึ่งถ้าเราเปรียบเทียบเป็นค่าของตัวแปรจะเท่ากับ

C = 4 % 2

ค่า C จะได้ 0