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

• การแปลงที่ชัดเจนตรงกันข้ามกับโดยปริยาย โปรแกรมเมอร์เป็นผู้ดำเนินการ มีหลายวิธีในการแปลงนี้:

1. การแปลงเป็นรูปแบบ ค: (ลอย)
2. การแปลงเป็นรูปแบบ ซี++: ลอย()

การหล่อแบบสามารถทำได้โดยใช้การดำเนินการต่อไปนี้:

static_cast<>() con_cast<>() ตีความ_cast ใหม่<>() ไดนามิก_แคสต์<> ()

static_cas- แปลงประเภทข้อมูลที่เกี่ยวข้อง ตัวดำเนินการนี้แปลงประเภทตามกฎปกติ ซึ่งอาจจำเป็นเมื่อคอมไพเลอร์ไม่ทำการแปลงอัตโนมัติ ไวยากรณ์จะมีลักษณะดังนี้:

พิมพ์ static_cast<Тип>(วัตถุ);

เมื่อใช้ static_cast คุณจะไม่สามารถลบค่าคงที่ออกจากตัวแปรได้ แต่ตัวดำเนินการต่อไปนี้สามารถทำได้ const_cast- ใช้เฉพาะเมื่อจำเป็นต้องลบความมั่นคงออกจากวัตถุเท่านั้น ไวยากรณ์จะมีลักษณะดังนี้:

พิมพ์const_cast< พิมพ์> (วัตถุ);

ตีความใหม่_cast- ใช้ในการแปลงประเภทต่างๆ จำนวนเต็มเป็นตัวชี้ และในทางกลับกัน หากเห็นคำศัพท์ใหม่ “ดัชนี” - ไม่ต้องตกใจ! นี่เป็นประเภทข้อมูลด้วย แต่เราจะไม่ดำเนินการในเร็วๆ นี้ ไวยากรณ์ที่นี่เหมือนกับของตัวดำเนินการที่กล่าวถึงก่อนหน้านี้:

พิมพ์ตีความใหม่_หล่อ< พิมพ์> (วัตถุ);

dynamic_cast- ใช้สำหรับการแปลงประเภทไดนามิก ใช้ตัวชี้หรือการอ้างอิง ไวยากรณ์:

พิมพ์พลวัต _หล่อ< พิมพ์> (วัตถุ);

อักขระควบคุม

คุณคุ้นเคยกับ "อักขระควบคุม" เหล่านี้บางส่วนแล้ว (เช่น ด้วย \n). ทั้งหมดเริ่มต้นด้วยแบ็กสแลชและล้อมรอบด้วยเครื่องหมายคำพูดคู่ด้วย

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

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

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

ชนิดข้อมูลในภาษา C สำหรับคอมไพเลอร์ AVR-GCC

บันทึก

ประเภทการใช้งาน สองเท่า AVR-GCC เบี่ยงเบนไปจากมาตรฐาน ตามมาตรฐาน สองเท่าครอบครอง 64 บิต ใน AVR-GCC ตัวแปรประเภทนี้จะใช้พื้นที่ 32 บิต ดังนั้น จึงเทียบเท่ากับตัวแปรที่มีประเภท ลอย!

นอกจากนี้ ไลบรารี AVR-GCC ยังแนะนำอนุพันธ์ประเภทมาตรฐานหลายประเภทอีกด้วย มีอธิบายไว้ในไฟล์ stdint.h - อาจทำเพื่อปรับปรุงความชัดเจนและลดข้อความของโปรแกรม (เร่งการเขียน :)) นี่คือแผ่นมาตรฐาน:

ประเภทที่ได้มาจากประเภทมาตรฐานในภาษา C สำหรับคอมไพเลอร์ AVR-GCC

ประเภทโมฆะ

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

อัปเดตครั้งล่าสุด: 17/09/2017

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

boole : ประเภทบูลีน สามารถรับค่าใดค่าหนึ่งจากสองค่าได้: จริงและเท็จ รอยเท้าหน่วยความจำสำหรับประเภทนี้ไม่ได้กำหนดไว้อย่างแม่นยำ

char : แสดงถึงอักขระ ASCII ตัวเดียว ใช้พื้นที่ 1 ไบต์ (8 บิต) ในหน่วยความจำ สามารถเก็บค่าใดๆ ได้ตั้งแต่ -128 ถึง 127 หรือตั้งแต่ 0 ถึง 255

ถ่านที่ลงนาม : แสดงถึงอักขระตัวเดียว ใช้พื้นที่ 1 ไบต์ (8 บิต) ในหน่วยความจำ สามารถเก็บค่าได้ตั้งแต่ -128 ถึง 127

ถ่านที่ไม่ได้ลงนาม : แสดงถึงอักขระตัวเดียว ใช้พื้นที่ 1 ไบต์ (8 บิต) ในหน่วยความจำ สามารถเก็บค่าได้ตั้งแต่ 0 ถึง 255

wchar_t : แสดงถึงอักขระแบบกว้าง บน Windows จะใช้หน่วยความจำ 2 ไบต์ (16 บิต) บน Linux จะใช้ 4 ไบต์ (32 บิต) สามารถเก็บค่าใดๆ ได้ตั้งแต่ 0 ถึง 65,535 (สำหรับ 2 ไบต์) หรือตั้งแต่ 0 ถึง 4,294,967,295 (สำหรับ 4 ไบต์)

char16_t : แสดงถึงอักขระ Unicode ตัวเดียว ใช้พื้นที่ 2 ไบต์ (16 บิต) ในหน่วยความจำ สามารถเก็บค่าใดๆ ได้ตั้งแต่ 0 ถึง 65,535

char32_t : แสดงถึงอักขระ Unicode ตัวเดียว ครอบครองหน่วยความจำ 4 ไบต์ (32 บิต) สามารถเก็บค่าใดๆ ได้ตั้งแต่ 0 ถึง 4,294,967,295

short : แทนจำนวนเต็มในช่วง –32768 ถึง 32767 ใช้หน่วยความจำ 2 ไบต์ (16 บิต)

ประเภทนี้ยังมีคำพ้องความหมาย short int, signed short int, signed short

unsigned short: แทนจำนวนเต็มในช่วง 0 ถึง 65535 ใช้หน่วยความจำ 2 ไบต์ (16 บิต)

ประเภทนี้มีคำพ้องความหมาย unsigned short int

int: หมายถึงจำนวนเต็ม ขึ้นอยู่กับสถาปัตยกรรมโปรเซสเซอร์ อาจมีขนาด 2 ไบต์ (16 บิต) หรือ 4 ไบต์ (32 บิต) ช่วงของค่าขีดจำกัดอาจแตกต่างกันตั้งแต่ –32768 ถึง 32767 (มี 2 ไบต์) หรือตั้งแต่ −2,147,483,648 ถึง 2,147,483,647 (มี 4 ไบต์) แต่ทั้งนี้ขนาดต้องมากกว่าหรือเท่ากับขนาดของแบบสั้นและน้อยกว่าหรือเท่ากับขนาดของแบบยาว

ประเภทนี้มีคำพ้องความหมาย signed int และ signed

unsigned int : แสดงถึงจำนวนเต็มบวก ขึ้นอยู่กับสถาปัตยกรรมโปรเซสเซอร์ อาจใช้พื้นที่ 2 ไบต์ (16 บิต) หรือ 4 ไบต์ (32 บิต) และด้วยเหตุนี้ ช่วงของค่าขีดจำกัดอาจแตกต่างกันไป: ตั้งแต่ 0 ถึง 65535 (สำหรับ 2 ไบต์) หรือจาก 0 ถึง 4,294,967,295 (สำหรับ 4 ไบต์)

unsigned สามารถใช้เป็นคำพ้องสำหรับประเภทนี้ได้

long : แสดงถึงจำนวนเต็มในช่วง −2,147,483,648 ถึง 2,147,483,647 ใช้พื้นที่หน่วยความจำ 4 ไบต์ (32 บิต)

ประเภทนี้มีคำพ้องความหมาย long int , signed long int และ signed long

unsigned long: แทนจำนวนเต็มในช่วง 0 ถึง 4,294,967,295 ใช้พื้นที่หน่วยความจำ 4 ไบต์ (32 บิต)

มีคำพ้องความหมาย long int ที่ไม่ได้ลงนาม

long long: แสดงถึงจำนวนเต็มในช่วง −9,223,372,036,854,775,808 ถึง +9,223,372,036,854,775,807 โดยทั่วไปจะใช้หน่วยความจำ 8 ไบต์ (64 บิต)

มีคำพ้องความหมาย long long int , ลงนาม long long int และลงนาม long long

unsigned long long : แทนจำนวนเต็มในช่วง 0 ถึง 18,446,744,073,709,551,615 โดยทั่วไป 8 ไบต์ (64 บิต) ในหน่วยความจำ

มีคำพ้องความหมายที่ไม่ได้ลงนาม long long int

float : แสดงถึงจำนวนจริงจุดลอยตัวที่มีความแม่นยำเดียวในช่วง +/- 3.4E-38 ถึง 3.4E+38 ครอบครองหน่วยความจำ 4 ไบต์ (32 บิต)

double : แทนจำนวนจริงจุดลอยตัวที่มีความแม่นยำสองเท่าในช่วง +/- 1.7E-308 ถึง 1.7E+308 ครอบครองหน่วยความจำ 8 ไบต์ (64 บิต)

long double : แสดงถึงจำนวนจริงจุดลอยตัวที่มีความแม่นยำสองเท่าอย่างน้อย 8 ไบต์ (64 บิต) ช่วงของค่าที่ถูกต้องอาจแตกต่างกันไปขึ้นอยู่กับขนาดของหน่วยความจำที่ถูกครอบครอง

void : พิมพ์โดยไม่มีค่า

ดังนั้น ชนิดข้อมูลทั้งหมดยกเว้นโมฆะสามารถแบ่งออกเป็นสามกลุ่ม: อักขระ (char, wchar_t, char16_t, char32_t), จำนวนเต็ม (short, int, long, long long) และประเภทตัวเลขทศนิยม (float, double, long double)

ประเภทตัวละคร

ประเภทที่ใช้แทนอักขระในแอปพลิเคชัน ได้แก่ char, wchar_t, char16_t และ char32_t

มากำหนดตัวแปรหลายตัวกัน:

ถ่าน c = "d"; wchar_t d="ค";

ตัวแปรถ่านจะใช้ค่าเป็นอักขระหนึ่งตัวในเครื่องหมายคำพูดเดี่ยว: char c ="d" คุณยังสามารถกำหนดตัวเลขจากช่วงที่ระบุด้านบนในรายการ: char c = 120 ในกรณีนี้ ค่าของตัวแปร c จะเป็นอักขระที่มีรหัส 120 ในตารางอักขระ ASCII

ควรพิจารณาว่าหากต้องการส่งออกอักขระ wchar_t ไปยังคอนโซล คุณควรใช้ไม่ใช่ std::cout แต่เป็นสตรีม std::wcout:

#รวม int main() ( char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

ในกรณีนี้ สตรีม std::wcout สามารถทำงานกับทั้ง char และ wchar_t และสตรีม std::cout สำหรับตัวแปร wchar_t จะส่งออกรหัสตัวเลขแทนที่จะเป็นอักขระ

มาตรฐาน C++11 ได้เพิ่มประเภท char16_t และ char32_t ซึ่งเน้นไปที่การใช้ Unicode อย่างไรก็ตาม เธรดสำหรับการทำงานกับประเภทเหล่านี้ยังไม่ได้ถูกนำมาใช้ในระดับระบบปฏิบัติการ ดังนั้น หากคุณต้องการแสดงค่าของตัวแปรประเภทเหล่านี้บนคอนโซล คุณจะต้องแปลงตัวแปรเป็นประเภท char หรือ wchar_t:

#รวม int main() ( char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

ในกรณีนี้เมื่อส่งออกตัวแปรจะนำหน้าด้วยการดำเนินการแบบคาสต์เป็นประเภทถ่าน - (ถ่าน) เนื่องจากค่าของตัวแปร b, c และ d จะถูกแปลงเป็นประเภทถ่านและสามารถส่งออกเป็น คอนโซลโดยใช้ std::cout stream

ประเภทจำนวนเต็ม

ประเภทจำนวนเต็มจะแสดงตามประเภทต่อไปนี้: short, unsigned short, int, unsigned int, long, unsigned long, long long และ unsigned long long:

สั้น = -10; สั้นที่ไม่ได้ลงนาม b= 10; อินท์ค = -30; int d = 60 ที่ไม่ได้ลงนาม; ยาว e = -170; ยาวที่ไม่ได้ลงนาม f = 45; ยาวยาว g = 89;

ประเภทของจำนวนจุดลอยตัว

ประเภทจำนวนจุดลอยตัวและเศษส่วนจะแสดงด้วยจำนวนทศนิยม สอง และคู่ยาว:

ลอยตัว = -10.45; ดับเบิ้ล ข = 0.00105; ยาวสองเท่า c = 30.890045;

ขนาดชนิดข้อมูล

รายการด้านบนแสดงขนาดที่ใช้ในหน่วยความจำแต่ละประเภท อย่างไรก็ตาม เป็นที่น่าสังเกตว่านักพัฒนาคอมไพเลอร์สามารถเลือกขนาดจำกัดสำหรับประเภทได้อย่างอิสระ โดยขึ้นอยู่กับความสามารถด้านฮาร์ดแวร์ของคอมพิวเตอร์ มาตรฐานจะกำหนดเฉพาะค่าขั้นต่ำที่ควรจะเป็นเท่านั้น ตัวอย่างเช่น สำหรับประเภท int และ short ค่าต่ำสุดคือ 16 บิต สำหรับประเภทยาว - 32 บิต สำหรับประเภท long double ในกรณีนี้ขนาดของประเภทยาวจะต้องไม่น้อยกว่าขนาดของประเภท int และขนาดของประเภท int จะต้องไม่น้อยกว่าขนาดของประเภทสั้นและขนาดของประเภทคู่ยาวจะต้อง จะมากกว่าสองเท่า ตัวอย่างเช่น คอมไพเลอร์ g++ สำหรับ Windows ใช้ 12 ไบต์สำหรับ long doubles และคอมไพเลอร์ที่สร้างไว้ใน Visual Studio และยังทำงานภายใต้ Windows จะใช้ 8 ไบต์สำหรับ long doubles นั่นคือแม้จะอยู่ในแพลตฟอร์มเดียวกัน คอมไพเลอร์ที่แตกต่างกันอาจมีแนวทางที่แตกต่างกันในการกำหนดขนาดของข้อมูลบางประเภท แต่โดยทั่วไป จะใช้ขนาดที่ระบุไว้ข้างต้นเมื่ออธิบายชนิดข้อมูล

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

#รวม int main() ( เลขคู่ยาว = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

เอาต์พุตคอนโซลเมื่อคอมไพล์ใน g++:

ขนาดของ(จำนวน) = 12

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

หมายเลขสั้นที่ไม่ได้ลงนาม = -65535;

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

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

ตัวระบุอัตโนมัติ

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

หมายเลขอัตโนมัติ = 5;

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

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

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

• บูลีน(บูล);
• ตัวละคร (เช่น ถ่าน);
• int (เช่น int);
• จุดลอยตัว (เช่น ลอย);
• การแจงนับ (กำหนดโดยโปรแกรมเมอร์);
• เป็นโมฆะ

นอกเหนือจากรายการดังกล่าวแล้ว ยังมีการสร้างประเภทต่อไปนี้:

• สาธิต (เช่น int*);
• อาร์เรย์ (เช่น ถ่าน);
• การอ้างอิง (เช่น double&);
• โครงสร้างอื่นๆ

เรามาดูแนวคิดของตัวอักษรกันดีกว่า (เช่น 1, 2.4F, 25e-4, 'a' ฯลฯ): ตัวอักษรคือรายการในซอร์สโค้ดของโปรแกรมที่แสดงถึงค่าคงที่ กล่าวอีกนัยหนึ่ง ตัวอักษรเป็นเพียงการแสดงวัตถุ (ค่า) บางประเภทในโค้ดโปรแกรม C++ มีความสามารถในการเขียนค่าจำนวนเต็ม จุดลอยตัว อักขระ บูลีน และค่าสตริง

ตัวอักษรชนิดจำนวนเต็มสามารถเขียนได้เป็น:

• ระบบตัวเลขที่ 10 เช่น 1205 ;
• ระบบตัวเลขที่ 8 ในรูปแบบ 0 + หมายเลข ตัวอย่างเช่น 0142;
• ระบบตัวเลขที่ 16 ในรูปแบบ 0x + ตัวเลข ตัวอย่างเช่น 0x2F

24, 030, 0x18 - ทั้งหมดนี้เป็นบันทึกที่มีหมายเลขเดียวกันในระบบตัวเลขที่ต่างกัน
หากต้องการเขียนตัวเลขทศนิยม ให้ใช้เครื่องหมายจุด: 0.1, .5, 4 - อย่างใดอย่างหนึ่ง
สัญกรณ์เลขชี้กำลัง - 25e-100 ไม่ควรมีช่องว่างในบันทึกดังกล่าว

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

ตัวอย่าง int Const = 3; // ในที่นี้ const คือตัวระบุ // int คือประเภทฐาน // ตัวอย่างคือชื่อของตัวแปร // = 3 - ตัวเริ่มต้น

ชื่อตัวแปรคือลำดับอักขระที่ประกอบด้วยตัวอักษรละติน (ตัวพิมพ์เล็กและตัวพิมพ์ใหญ่) ตัวเลข และ/หรือขีดล่าง แต่อักขระตัวแรกไม่สามารถเป็นตัวเลขได้ ควรเลือกชื่อตัวแปรเพื่อให้เดาได้ง่ายเสมอว่าเก็บอะไรไว้ เช่น "monthPayment" ในบันทึกย่อและในทางปฏิบัติ เราจะใช้สัญลักษณ์ CamelCase เป็นกฎสำหรับการบันทึกตัวแปร ชื่อตัวแปรต้องไม่ตรงกับคำที่สงวนไว้ในภาษา ตัวอย่างของคำดังกล่าว ได้แก่ if, while, function, goto, switch เป็นต้น

นอกจากชื่อตัวแปรแล้ว ผู้ประกาศยังสามารถมีอักขระเพิ่มเติมได้:

• * - ตัวชี้; ก่อนชื่อ;
• *const - ตัวชี้คงที่; ก่อนชื่อ;
• & - ลิงค์; ก่อนชื่อ;
• - อาร์เรย์; หลังชื่อ;
• () - การทำงาน; หลังชื่อ

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

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

การประกาศค่าคงที่โดยไม่กำหนดค่าเริ่มต้นจะไม่ทำงานด้วยเหตุผลเชิงตรรกะ:

ค่าคงที่ EMPTY_CONST; // ข้อผิดพลาด ตัวแปรคงที่ไม่ได้เตรียมใช้งาน const int ตัวอย่าง = 2; // ค่าคงที่ด้วยค่า 2 ตัวอย่าง = 3; // ข้อผิดพลาด พยายามกำหนดค่าให้กับตัวแปรคงที่

เมื่อตั้งชื่อค่าคงที่ เป็นเรื่องปกติที่จะใช้เฉพาะตัวพิมพ์ใหญ่เท่านั้น โดยแยกคำด้วยอักขระขีดล่าง

ชนิดข้อมูลพื้นฐานในภาษา C++

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

1. ประเภทจำนวนเต็ม (char, short (int), int, long (int), long long)

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

• 2 8N = 2 8 * 1 = 256 โดยที่ N คือขนาดของหน่วยความจำเป็นไบต์เพื่อเก็บค่า

ในกรณีนี้ ช่วงของจำนวนเต็มที่ใช้ได้จะเป็นดังนี้:

• - สำหรับถ่านที่ไม่ได้ลงนาม
• [-128..127] - สำหรับถ่านที่ลงนามแล้ว

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

ค่ายาวที่ไม่ได้ลงนาม // ระบุประเภทที่ไม่ได้ลงนามจำนวนเต็ม (ยาว)

ประเภทที่ระบุไว้จะแตกต่างกันเพียงขนาดของหน่วยความจำที่จำเป็นสำหรับการจัดเก็บเท่านั้น เนื่องจากภาษา C++ ค่อนข้างขึ้นอยู่กับเครื่อง มาตรฐานภาษาจึงรับประกันเงื่อนไขต่อไปนี้เท่านั้น:

• 1 = ขนาดตัวอักษร ≤ ขนาดสั้น ≤ ขนาด int ≤ ขนาดยาว

โดยทั่วไปขนาดของประเภทจะเป็นดังนี้: char - 1, short - 2, int - 4, long -8, long long - 8 ไบต์

คุณสามารถดำเนินการทางคณิตศาสตร์ด้วยค่าประเภทจำนวนเต็ม: +, -, *, /, %; การดำเนินการเปรียบเทียบ: ==, !=,<=, <, >- การดำเนินการบิต: &, |, xor,<<, >>.
การดำเนินการส่วนใหญ่ เช่น การบวก การคูณ การลบ และการเปรียบเทียบ นั้นง่ายต่อการเข้าใจ บางครั้ง หลังจากดำเนินการทางคณิตศาสตร์แล้ว ผลลัพธ์อาจอยู่นอกช่วงของค่า ในกรณีนี้โปรแกรมจะสร้างข้อผิดพลาด
การหารจำนวนเต็ม (/) ค้นหาส่วนของจำนวนเต็มของจำนวนเต็มหนึ่งหารด้วยอีกจำนวนหนึ่ง ตัวอย่างเช่น:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

สัญลักษณ์เปอร์เซ็นต์ (%) แสดงถึงการดำเนินการหาเศษที่เหลือของการหารจำนวนเต็มสองตัว:

• 6 % 4 = 2;
• 10 % 3 = 1.

การดำเนินการที่เข้าใจยากกว่านั้นคือการดำเนินการแบบบิต: & (AND), | (OR), xor (เฉพาะ OR)<< (побитовый сдвиг влево), >> (เลื่อนไปทางขวาระดับบิต)

การดำเนินการบิต AND, OR และ XOR ใช้การดำเนินการเชิงตรรกะที่สอดคล้องกันกับข้อมูลแต่ละบิต:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 x หรือ 3 10 = 01 2 x หรือ 11 2 = 10 2

ในการประมวลผลภาพ จะใช้ 3 แชนเนลสำหรับสี: แดง น้ำเงิน และเขียว - บวกกับความโปร่งใสซึ่งถูกเก็บไว้ในตัวแปร int เนื่องจาก แต่ละช่องมีช่วงค่าตั้งแต่ 0 ถึง 255 ในระบบเลขฐานสิบหกค่าบางอย่างจะถูกเขียนดังนี้ 0x180013FF; จากนั้นค่า 18 16 จะสอดคล้องกับช่องสีแดง 00 16 - สีน้ำเงิน 13 16 - สีเขียว FF - ช่องอัลฟ่า (โปร่งใส) ในการเลือกช่องสัญญาณเฉพาะจากจำนวนเต็ม จะใช้ช่องที่เรียกว่า หน้ากาก โดยที่ตำแหน่งที่เราสนใจคือ F 16 หรือ 1 2 นั่นคือเพื่อเน้นค่าของช่องสีน้ำเงิน คุณต้องใช้มาสก์ เช่น ระดับบิตและ:

Int blue_channel = 0x180013FF & 0x00FF0000;

หลังจากนั้นค่าผลลัพธ์จะถูกเลื่อนไปทางขวาตามจำนวนบิตที่ต้องการ

การเลื่อนบิตจะเลื่อนตัวเลขไปทางซ้ายหรือขวาตามเลขฐานสองตามที่ระบุไว้ทางด้านขวาของการดำเนินการ ตัวอย่างเช่น หมายเลข 39 สำหรับประเภทอักขระจะเขียนในรูปแบบไบนารีดังนี้ 00100111 จากนั้น:

Char ไบนารีตัวอย่าง = 39; // 00100111 ผลลัพธ์ถ่าน = binaryExample<< 2; // сдвигаем 2 бита влево, результат: 10011100

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

2. ประเภทจุดลอยตัว (ลอย, ดับเบิ้ล (ลอย))

ชุดของค่าทศนิยมเป็นเซตย่อยของจำนวนจริง แต่ไม่ใช่ทุกจำนวนจริงที่สามารถแทนค่าได้ในไบนารี่ ซึ่งบางครั้งก็นำไปสู่ข้อผิดพลาดโง่ ๆ:

ค่าลอยตัว = 0.2; ค่า == 0.2; // เกิดข้อผิดพลาด ค่าที่นี่จะไม่เท่ากับ 0.2

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

ความคุ้มค่า - 0.2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

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

3. ประเภทบูลีน (ตรรกะ) (บูล)

ประกอบด้วยสองค่าเท่านั้น: จริง (จริง) และเท็จ (เท็จ) ในการทำงานกับตัวแปรประเภทนี้ จะใช้การดำเนินการเชิงตรรกะ: ! (NOT), == (ความเท่าเทียมกัน), != (ความไม่เท่าเทียมกัน), && (ตรรกะ AND), || (ตรรกะหรือ) ผลลัพธ์ของการดำเนินการแต่ละครั้งสามารถพบได้ในตารางความจริงที่เกี่ยวข้อง ตัวอย่างเช่น:

4. ประเภทอักขระ (char, wchar_t)

ประเภทอักขระไม่ได้เป็นเพียงประเภทจำนวนเต็ม (โดยปกติประเภทนี้จะเรียกว่าไบต์) แต่ยังเป็นประเภทอักขระด้วย โดยจัดเก็บหมายเลขอักขระจากตารางเป็นอักขระ ASCII ตัวอย่างเช่น รหัส 0x41 สอดคล้องกับอักขระ 'A' และ 0x71 - 't'

บางครั้งจำเป็นต้องใช้อักขระที่ไม่ได้รับการแก้ไขในตาราง ASCII ดังนั้นจึงต้องใช้พื้นที่จัดเก็บมากกว่า 1 ไบต์ มีอักขระกว้างสำหรับพวกเขา (wchar_t)

5.1. อาร์เรย์

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

Int myArray; // อาร์เรย์ของ 5 องค์ประกอบประเภทจำนวนเต็ม

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

อัตราต่อรอง = (1, 3, 7, 9, 11); // อาร์เรย์เริ่มต้นด้วยค่า 5 ค่า

ในการเข้าถึงค่าเฉพาะในอาร์เรย์ (องค์ประกอบอาร์เรย์) ให้ใช้การดำเนินการเข้าถึงดัชนี () ระบุหมายเลของค์ประกอบ (ตัวเลขเริ่มต้นจาก 0) ตัวอย่างเช่น:

ราคาต่อรอง; // เข้าถึงองค์ประกอบแรกของอาร์เรย์ ส่งกลับค่า 1 อัตราต่อรอง; // เข้าถึงองค์ประกอบที่สาม ส่งกลับค่า 7 อัตราต่อรอง = 13; // กำหนดค่าใหม่ให้กับองค์ประกอบที่ 5 ของอัตราต่อรองอาร์เรย์ // ข้อผิดพลาดในการเข้าถึง

5.3. สตริง

ในการเขียนสตริง โปรแกรมเมอร์ใช้แนวคิดที่ว่าสตริงนั้นเป็นชุดอักขระ (อาร์เรย์) ตามลำดับ หากต้องการระบุจุดสิ้นสุดของบรรทัด ให้ใช้อักขระพิเศษที่ปลายบรรทัด: '\0' อักขระพิเศษเหล่านี้ ซึ่งประกอบด้วยแบ็กสแลชและอักขระระบุ เรียกว่าอักขระควบคุมหรืออักขระหลีก นอกจากนี้ยังมี '\n' - จุดเริ่มต้นของบรรทัดใหม่ '\t' - การจัดตาราง ในการเขียนแบ็กสแลชในสตริง จะใช้ Escape - วางสแลชอีกอันไว้หน้าเครื่องหมาย: '\' นอกจากนี้ การ Escape ยังใช้ในการเขียนเครื่องหมายคำพูดอีกด้วย

มาสร้างตัวแปรสตริงกัน:

ตัวอักษร textExample = ('T', 'e', ​​​​'s', 't', '\0'); // เขียนสตริง "ทดสอบ"

มีสัญกรณ์แบบง่ายสำหรับการเริ่มต้นสตริง:

Char textExample = “ทดสอบ”; // ตัวอักษรตัวสุดท้ายไม่ได้เขียน แต่ขนาดยังคงเป็น 5

นี่คือประเภทข้อมูลที่มีประโยชน์อีกประเภทหนึ่ง - สตริง โดยไม่ต้องลงรายละเอียด สตริง
ประเภทนี้สามารถเพิ่มได้ เช่น:

สตริงสวัสดี = "สวัสดี"; ชื่อสตริง = "สูงสุด!"; สตริง hello_name = สวัสดี + ชื่อ; // รับสตริง "Hello, Max!"

6. ลิงค์

Int = 2; // ตัวแปร "a" ชี้ไปที่ค่า 2 int &b = a; // ตัวแปร “b” ชี้ไปที่ตำแหน่งเดียวกับ “a” b = 4; // โดยการเปลี่ยนค่า b โปรแกรมเมอร์จะเปลี่ยนค่าของ a ตอนนี้ a = 4 int &c = 4; // ข้อผิดพลาด คุณไม่สามารถทำเช่นนี้ได้เพราะว่า การอ้างอิงไม่สามารถกำหนดค่าได้

7. ดัชนี

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

ที่อยู่ 0x0 หมายความว่าตัวชี้ว่างเปล่า เช่น ไม่ได้ชี้ไปที่ข้อมูลใดๆ ที่อยู่นี้มีตัวอักษรของตัวเอง - NULL:

Int *nullPtr = โมฆะ; // ตัวชี้ null

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

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

ค่า IntInMemory = 2; // ตั้งค่าตัวแปรประเภทจำนวนเต็ม int *somePtr = // คัดลอกที่อยู่ของตัวแปรที่นี่ & - ส่งคืนที่อยู่ของตัวแปร somePtr; // ที่อยู่ของเซลล์หน่วยความจำ เช่น 0x2F *somePtr; // ค่าจะถูกเก็บไว้ใน 4 เซลล์: 0x2F, 0x30, 0x31 และ 0x32

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

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

8. การโอน

การแจงนับเป็นประเภทพื้นฐานเดียวที่กำหนดโดยโปรแกรมเมอร์ โดยทั่วไปแล้ว การแจงนับคือชุดลำดับของค่าคงที่จำนวนเต็มที่มีชื่อ โดยชื่อของการแจงนับจะเป็นประเภทฐาน

สีอีนัม (แดง, น้ำเงิน, เขียว);

ตามค่าเริ่มต้น RED = 0, BLUE = 1, GREEN = 2 ดังนั้นจึงสามารถเปรียบเทียบค่าระหว่างกันได้ เช่น สีแดง< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

การเข้าถึง Enum (อ่าน = 1, เขียน = 2, EXEC = 4);

มักจะสะดวกในการใช้การแจงนับที่มีค่าเป็นกำลังสองเพราะว่า ในการแทนค่าไบนารี่ ตัวเลขที่เป็นกำลังของ 2 จะประกอบด้วย 1 และศูนย์ ตัวอย่างเช่น:

8 10 = 00001000 2

ผลลัพธ์ของการบวกตัวเลขเหล่านี้เข้าด้วยกันจะระบุอย่างชัดเจนเสมอว่าตัวเลขใดที่ถูกบวก:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

เป็นโมฆะ

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

วัตถุเป็นโมฆะ; // ข้อผิดพลาด ไม่มีวัตถุประเภท void void // ข้อผิดพลาด ไม่มีการอ้างอิงถึง void void *ptr; // ตกลง เก็บตัวชี้ไปยังประเภทที่ไม่รู้จัก

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

หล่อ

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

จำนวนเต็ม = 2; ลอย ลอย = จำนวนเต็ม; // ลอยตัว = 2.0

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

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

ค่า Int = (int) 2.5;

การดำเนินการเอกนารีและไบนารี

การดำเนินการที่เราทำก่อนหน้านี้เรียกว่าไบนารี: ทางซ้ายและขวาของสัญลักษณ์การดำเนินการคือค่าหรือตัวแปร เช่น 2 + 3 นอกเหนือจากการดำเนินการแบบไบนารีแล้ว ภาษาโปรแกรมยังใช้การดำเนินการแบบเอกภาคที่ใช้กับตัวแปรด้วย . สามารถอยู่ทางซ้ายหรือทางขวาของตัวแปรได้ เคยพบการดำเนินการดังกล่าวหลายครั้ง - การดำเนินการยกเลิกการอ้างอิง (*) และการรับที่อยู่ของตัวแปร (&) เป็นแบบเอกเทศ ตัวดำเนินการ “++” และ “—” จะเพิ่มและลดค่าของตัวแปรจำนวนเต็ม 1 ตามลำดับ และสามารถเขียนไปทางซ้ายหรือทางขวาของตัวแปรได้

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

ก += 2; // เช่นเดียวกับ a = a + 2; ข /= 5; // เช่นเดียวกับ b = b / 5; ค &= 3; // เช่นเดียวกับ c = c & 3;