ขนาดแบบสั้นไม่มีลายเซ็นc. ประเภทข้อมูล

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

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

ประเภทบิวท์อินดั้งเดิม

C++ มอบชุดข้อมูลในตัวและประเภทข้อมูลที่ผู้ใช้กำหนดให้กับโปรแกรมเมอร์ ตารางต่อไปนี้แสดงรายการประเภทข้อมูล C++ หลักเจ็ดประเภท:

พิมพ์	คำสำคัญ
บูลีน	บูล
อักขระ	ถ่าน
จำนวนเต็ม	ภายใน
จุดลอยตัว	ลอย
จุดลอยตัวคู่	สองเท่า
ไร้ค่า	เป็นโมฆะ
ตัวละครกว้าง	wchar_t

ประเภทพื้นฐานบางประเภทสามารถแก้ไขได้โดยใช้ตัวแก้ไขประเภทนี้ตั้งแต่หนึ่งรายการขึ้นไป:

ลงนาม
ไม่ได้ลงนาม
สั้น

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

พิมพ์	ความกว้างบิตทั่วไป	ช่วงทั่วไป
ถ่าน	1 ไบต์	-127 ถึง 127 หรือ 0 ถึง 255
ถ่านที่ไม่ได้ลงนาม	1 ไบต์	0 ถึง 255
ถ่านที่ลงนาม	1 ไบต์	-127 ถึง 127
ภายใน	4ไบต์	-2147483648 ถึง 2147483647
int ที่ไม่ได้ลงนาม	4ไบต์	0 ถึง 4294967295
ลงนามใน	4ไบต์	-2147483648 ถึง 2147483647
สั้น ๆ	2 ไบต์	-32768 ถึง 32767
int สั้นที่ไม่ได้ลงนาม	พิสัย	0 ถึง 65,535
ลงนามสั้น int	พิสัย	-32768 ถึง 32767
ยาว	4ไบต์	-2,147,483,648 ถึง 2,147,483,647
ลงนาม int ยาว	4ไบต์	เช่นเดียวกับ long int
int ยาวที่ไม่ได้ลงนาม	4ไบต์	0 ถึง 4,294,967,295
ลอย	4ไบต์	+/- 3.4e +/- 38 (~7 หลัก)
สองเท่า	8 ไบต์
ยาวสองเท่า	8 ไบต์	+/- 1.7e +/- 308 (~15 หลัก)
wchar_t	2 หรือ 4 ไบต์	1 ตัวอักษรกว้าง

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

#รวม ใช้เนมสเปซมาตรฐาน; int main() ( cout<< "Size of char: " << sizeof(char) << endl; cout << "Size of int: " << sizeof(int) << endl; cout << "Size of short int: " << sizeof(short int) << endl; cout << "Size of long int: " << sizeof(long int) << endl; cout << "Size of float: " << sizeof(float) << endl; cout << "Size of double: " << sizeof(double) << endl; cout << "Size of wchar_t: " << sizeof(wchar_t) << endl; return 0; }

ตัวอย่างนี้ใช้ สิ้นสุดซึ่งแนะนำอักขระขึ้นบรรทัดใหม่หลังแต่ละบรรทัดและตัวดำเนินการ<< используется для передачи нескольких значений на экран. Мы также используем оператор ขนาดของ()เพื่อให้ได้ขนาดของข้อมูลประเภทต่างๆ

เมื่อโค้ดด้านบนถูกคอมไพล์และดำเนินการ มันจะสร้างผลลัพธ์ต่อไปนี้ ซึ่งอาจแตกต่างกันไปในแต่ละเครื่อง:

ขนาดของถ่าน: 1 ขนาดของ int: 4 ขนาดของ int สั้น: 2 ขนาดของ int ยาว: 4 ขนาดของลอย: 4 ขนาดของ double: 8 ขนาดของ wchar_t: 4

ประกาศ Typedef

คุณสามารถสร้างชื่อใหม่สำหรับประเภทที่มีอยู่โดยใช้ typedef ด้านล่างนี้เป็นไวยากรณ์ง่ายๆ ในการกำหนดประเภทใหม่โดยใช้ typedef:

Typedef พิมพ์ชื่อใหม่;

ตัวอย่างเช่น ข้อมูลต่อไปนี้จะบอกคอมไพเลอร์ว่า ขา เป็นอีกชื่อหนึ่งของ int:

Typedef int ฟุต;

ตอนนี้การประกาศต่อไปนี้ถูกต้องตามกฎหมายอย่างสมบูรณ์และสร้างตัวแปรจำนวนเต็มที่เรียกว่าระยะทาง:

เว้นระยะห่างฟุต

ประเภทที่ระบุไว้

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

Enum enum-name ( รายชื่อ ) var-list;

ในที่นี้ enum-name คือชื่อของประเภท enum รายชื่อคั่นด้วยเครื่องหมายจุลภาค ตัวอย่างเช่น รหัสต่อไปนี้กำหนดการแจงนับของสีที่เรียกว่าสี และตัวแปร c ของประเภทสี ในที่สุด c จะถูกกำหนดค่าเป็น "สีน้ำเงิน"

สี Enum ( แดง เขียว น้ำเงิน ) c; ค = สีน้ำเงิน;

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

สี Enum(แดง, เขียว = 5, น้ำเงิน);

สีน้ำเงินที่นี่จะมีค่าเป็น 6 เพราะแต่ละชื่อจะมากกว่าชื่อก่อนหน้า

อัปเดตครั้งล่าสุด: 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 เป็นคลาสของข้อมูลที่มีค่ามีลักษณะคล้ายกัน ประเภทนี้จะกำหนดการเป็นตัวแทนภายในของข้อมูลในหน่วยความจำ ประเภทข้อมูลพื้นฐานที่สุด: ตรรกะ จำนวนเต็ม ตัวเลขทศนิยม สตริง พอยน์เตอร์

ด้วยการพิมพ์แบบไดนามิก ตัวแปรจะเชื่อมโยงกับประเภท ณ เวลาที่เริ่มต้น ปรากฎว่าตัวแปรในส่วนต่าง ๆ ของโค้ดสามารถมีประเภทต่างกันได้ การพิมพ์แบบไดนามิกรองรับ Java Script, Python, Ruby, PHP

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

ภาษาแบ่งอย่างไม่เป็นทางการออกเป็นประเภทที่รุนแรงและประเภทที่ไม่รุนแรง การพิมพ์ที่รัดกุมหมายความว่าคอมไพเลอร์จะส่งข้อผิดพลาดหากประเภทที่คาดไว้และประเภทจริงไม่ตรงกัน

x = 1 + “2”; //ข้อผิดพลาด - คุณไม่สามารถเพิ่มสัญลักษณ์ให้กับตัวเลขได้

ตัวอย่างการพิมพ์ที่อ่อนแอ

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

คลาสหน่วยความจำ

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

คลาสหน่วยความจำ:

อัตโนมัติ;
คงที่;
ภายนอก;
ลงทะเบียน.

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

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

ตัวแปรภายนอกเป็นแบบโกลบอล มีอยู่ในส่วนใดก็ได้ของโค้ดและแม้แต่ในไฟล์อื่น

ตัวระบุชนิดข้อมูลในภาษา C อาจไม่สามารถระบุได้ในกรณีต่อไปนี้:

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

หากต้องการระบุประเภทอย่างง่าย ให้ใช้ตัวระบุ int, char, float หรือ double โมดิฟายเออร์ที่ไม่ได้ลงนาม, ลงนาม, สั้น, ยาว, ยาว สามารถทดแทนตัวแปรได้

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

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

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

การแปลงตัวแปรที่ไม่ได้ลงนามอย่างชัดเจนมีการระบุดังนี้:

โดยนัยหนึ่งมีลักษณะเช่นนี้:

ลอยและกำหนดตัวเลขด้วยจุดสองเท่า ตัวเลขทศนิยมจะแสดงเป็น -2.3 หรือ 3.34 มีการใช้ double เพื่อความแม่นยำยิ่งขึ้น - มีการระบุตัวเลขมากขึ้นหลังตัวคั่นจำนวนเต็มและตัวคั่นเศษส่วน ประเภทนี้ใช้พื้นที่หน่วยความจำมากกว่าโฟลต

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

ประเภทบูลีน บูล

ใช้ในการทดสอบและลูปตามเงื่อนไข มีเพียงสองความหมาย:

จริง;
โกหก.

ค่าบูลีนสามารถแปลงเป็นค่า int ได้ จริงเท่ากับหนึ่ง เท็จเท่ากับศูนย์ การแปลงประเภทสามารถทำได้ระหว่าง bool และ int เท่านั้น มิฉะนั้นคอมไพเลอร์จะเกิดข้อผิดพลาด

if (x) ( //ข้อผิดพลาด: "ไม่สามารถแปลงประเภท 'int' เป็น 'bool' โดยปริยายได้"

if (x != 0) // วิธี C#

สตริงและอาร์เรย์

อาร์เรย์เป็นชนิดข้อมูลที่ซับซ้อนในภาษาซี PL ไม่ทำงานกับสตริงในลักษณะเดียวกับ Javascript หรือ Ruby ในภาษา C สตริงทั้งหมดเป็นอาร์เรย์ขององค์ประกอบที่มีค่าอักขระ บรรทัดลงท้ายด้วยไบต์ว่าง “

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

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

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

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

ในการใช้งานภาษาโปรแกรมสากลสมัยใหม่ มักจะมีจำนวนเต็มหลายจำนวนและประเภทจริงหลายประเภท ซึ่งแต่ละประเภทมีลักษณะเฉพาะด้วยขนาดหน่วยความจำของตัวเองที่จัดสรรสำหรับค่าเดียว และตามด้วยช่วงของค่าตัวเลข และสำหรับประเภทจริง - และ ความแม่นยำ (จำนวนหลักของแมนทิสซา)

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

C มี 4 ประเภทพื้นฐาน:

ถ่าน- ประเภทตัวละคร;

ภายใน- ทั้งประเภท

ลอย- ประเภทจริงที่มีความแม่นยำเดียว

สองเท่า- ประเภทจริงที่มีความแม่นยำสองเท่า

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

ตารางที่ 1. ชนิดข้อมูลจำนวนเต็ม C มาตรฐาน

ชนิดข้อมูล		ช่วงของค่า

ถ่าน, ถ่านที่ลงนาม
int ที่ไม่ได้ลงนาม, ไม่ได้ลงนาม
int, int ที่ลงนาม, int สั้น, สั้น

		2147483648...2147483647

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

ตารางที่ 2. ชนิดข้อมูลจริงมาตรฐาน C

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

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

โดยทั่วไปภาษาการเขียนโปรแกรมจะมีชุดของประเภทข้อมูลดั้งเดิม ซึ่งเป็นประเภทที่ภาษาการเขียนโปรแกรมจัดให้เป็นหน่วยพื้นฐานที่มีอยู่แล้วภายใน ในภาษา 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 จากนั้น:

ถ่านไบนารีตัวอย่าง = 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), || (ตรรกะหรือ) ผลลัพธ์ของการดำเนินการแต่ละครั้งสามารถพบได้ในตารางความจริงที่เกี่ยวข้อง ตัวอย่างเช่น:

XY XOR0 0 0 0 1 1 1 0 1 1 1 0

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;