ตัวแปรประเภท float ใน c ประเภทจุดลอยตัว (ลอย, คู่และคู่ยาว)

อัพเดทล่าสุด: 17.09.2017

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

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

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: หมายถึงอักขระหนึ่งตัวใน การเข้ารหัสแบบยูนิโค้ด- ใช้พื้นที่ 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

สั้นที่ไม่ได้ลงนาม: แทนจำนวนเต็มในช่วง 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="ค";

ตัวแปร พิมพ์ถ่านใช้อักขระหนึ่งตัวเป็นค่า คำพูดเดียว: ถ่าน 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;

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

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

ชนิดข้อมูลจำนวนเต็ม

ชนิดข้อมูลจำนวนเต็มเป็นประเภทที่ตัวแปรมีได้เฉพาะจำนวนเต็มเท่านั้น (ไม่มีเศษส่วน เช่น -2, -1, 0, 1, 2) ใน C++ มีจำนวนเต็มพื้นฐานห้าประเภทที่พร้อมใช้งาน:

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

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

การกำหนดตัวแปรจำนวนเต็ม

มันเกิดขึ้นดังนี้:

ถ่านค; สั้น int si; // สั้นที่ถูกต้อง s; // ที่ต้องการ int i; ยาว int li; // ถูกต้อง l ยาว; // โดยเฉพาะอย่างยิ่ง long long int lli; // ถูกต้อง ยาว ยาว ll; // ดีกว่า

แม้ว่าจะสามารถใช้ชื่อเต็ม short int , long int และ long long int ได้ แต่ควรใช้ชื่อเต็มแบบสั้น (ไม่มี int) นอกจากนี้ การเพิ่ม ints อย่างต่อเนื่องทำให้โค้ดอ่านยาก (สับสนกับตัวแปรได้ง่าย)

ช่วงค่าและเครื่องหมายของชนิดข้อมูลจำนวนเต็ม

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

ลงนาม(ลงนาม) หมายความว่าตัวแปรสามารถมีทั้งตัวเลขบวกและลบ หากต้องการประกาศตัวแปรตามที่เซ็นชื่อ ให้ใช้คีย์เวิร์ด ลงนาม:

ลงนามถ่าน c; ลงนามสั้นs; ลงนามในฉัน; เซ็นยาว l; ลงนามยาวยาว ll;

ลงนามถ่าน c ;

ลงนามสั้นs ;

ลงชื่อ int ฉัน ;

เซ็นยาว l ;

ลงชื่อ ยาว ยาว ll ;

ตามค่าเริ่มต้น คำสำคัญที่เซ็นชื่อจะถูกเขียนก่อนชนิดข้อมูล

ตัวแปรจำนวนเต็มแบบเซ็นชื่อ 1 ไบต์มีช่วงค่าตั้งแต่ -128 ถึง 127 ค่าใด ๆ ตั้งแต่ -128 ถึง 127 (รวม) สามารถเก็บไว้ได้อย่างปลอดภัย

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

ถ่านที่ไม่ได้ลงนาม c; สั้นที่ไม่ได้ลงนาม s; ไม่ได้ลงนาม int i; ยาวที่ไม่ได้ลงนาม l; ไม่ได้ลงนาม ยาว ยาว ll;

ถ่านที่ไม่ได้ลงนาม c ;

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

ไม่ได้ลงนาม int ฉัน ;

ยาวไม่ได้ลงนาม l ;

ไม่ได้ลงนาม ยาว ยาว ll;

ตัวแปรจำนวนเต็มที่ไม่ได้ลงนามขนาด 1 ไบต์มีช่วงค่าตั้งแต่ 0 ถึง 255

โปรดทราบว่าการประกาศตัวแปรเป็น unsigned หมายความว่าตัวแปรนั้นไม่สามารถมีจำนวนลบได้ (เฉพาะค่าบวกเท่านั้น)

ตอนนี้คุณเข้าใจความแตกต่างระหว่างการลงนามและไม่ได้ลงนามแล้ว มาดูช่วงค่าของประเภทข้อมูลต่างๆ กัน:

ขนาด/ประเภท	ช่วงของค่า
ลงนามแล้ว 1 ไบต์	-128 ถึง 127
1 ไบต์ที่ไม่ได้ลงนาม	จาก 0 ถึง 255
ลงนาม 2 ไบต์	จาก -32,768 ถึง 32,767
2 ไบต์ไม่ได้ลงนาม	ตั้งแต่ 0 ถึง 65 535
เซ็นชื่อขนาด 4 ไบต์	จาก -2 147 483 648 ถึง 2 147 483 647
4 ไบต์ไม่ได้ลงนาม	จาก 0 ถึง 4 294 967 295
ลงนาม 8 ไบต์	จาก -9 223 372 036 854 775 808 ถึง 9 223 372 036 854 775 807
8 ไบต์ไม่ได้ลงนาม	ตั้งแต่ 0 ถึง 18 446 744 073 709 551 615

สำหรับนักคณิตศาสตร์: ตัวแปรที่มีเครื่องหมายซึ่งมีจำนวนบิตที่ n มีช่วงตั้งแต่ -(2 n-1) ถึง 2 n-1 -1 ตัวแปรที่ไม่ได้ลงนามซึ่งมีจำนวนบิตที่ n มีช่วงตั้งแต่ 0 ถึง (2n) -1 สำหรับผู้ที่ไม่ใช่นักคณิตศาสตร์: ใช้ตาราง :)

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

ค่าเริ่มต้นคืออะไร: ลงนามหรือไม่ได้ลงนาม?

แล้วจะเกิดอะไรขึ้นถ้าเราประกาศตัวแปรโดยไม่เซ็นชื่อหรือไม่ได้ลงนาม?

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

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

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

กฎ: ใช้ประเภทจำนวนเต็มที่ลงนาม แทน ไม่ได้ลงนาม.

ล้น

คำถาม: “จะเกิดอะไรขึ้นหากเราพยายามใช้ค่าที่อยู่นอกช่วงค่าของข้อมูลบางประเภท” คำตอบ: ล้น ล้น(ภาษาอังกฤษ) "ล้น") เกิดขึ้นเมื่อบิตสูญหายเนื่องจากตัวแปรไม่ได้รับการจัดสรรหน่วยความจำเพียงพอที่จะจัดเก็บ

ตัวอย่างล้น

พิจารณาตัวแปรที่ไม่ได้ลงนามซึ่งประกอบด้วย 4 บิต เลขฐานสองใดๆ ที่ระบุไว้ในตารางด้านบนจะพอดีกับตัวแปรนี้

“แต่จะเกิดอะไรขึ้นถ้าเราพยายามกำหนดค่าที่กินพื้นที่มากกว่า 4 บิต?” ขวา! ล้น. ตัวแปรของเราจะเก็บเฉพาะบิตที่มีนัยสำคัญน้อยที่สุด 4 บิต (ทางด้านขวา) เท่านั้น ส่วนที่เหลือทั้งหมดจะสูญหายไป

ตัวอย่างเช่น ถ้าเราพยายามใส่ตัวเลข 21 ลงในตัวแปร 4 บิต:

ระบบทศนิยม	ระบบไบนารี่
21	10101

หมายเลข 21 ใช้เวลา 5 บิต (10101) 4 บิตทางด้านขวา (0101) จะพอดีกับตัวแปร และบิตซ้ายสุด (1) จะหายไป เหล่านั้น. ตัวแปรของเราจะมี 0101 ซึ่งเท่ากับ 101 (ไม่นับศูนย์หน้า) และนี่คือเลข 5 อยู่แล้ว ไม่ใช่ 21

บันทึก: จะมีบทเรียนแยกต่างหากเกี่ยวกับการแปลงตัวเลขจากระบบไบนารี่เป็นระบบทศนิยมและในทางกลับกันซึ่งเราจะพิจารณาและอภิปรายทุกอย่างโดยละเอียด

ตอนนี้เรามาดูตัวอย่างในโค้ด (ประเภทสั้นใช้เวลา 16 บิต):

#รวม int main() ( unsigned short x = 65535; // ค่าที่ใหญ่ที่สุดที่ตัวแปร std::cout ที่ไม่ได้ลงชื่อแบบ 16 บิตสามารถจัดเก็บได้<< "x was: " << x << std::endl; x = x + 1; // 65536 - это число больше максимально допустимого числа из диапазона допустимых значений. Следовательно, произойдёт переполнение, так как переменнная x не может хранить 17 бит std::cout << "x is now: " << x << std::endl; return 0; }

#รวม

int หลัก()

ไม่ได้ลงนามสั้น x = 65535 ; // ค่าที่ใหญ่ที่สุดที่ตัวแปรที่ไม่ได้ลงนามขนาด 16 บิตสามารถจัดเก็บได้

มาตรฐาน::cout<< "x was: " << x << std :: endl ;

x = x + 1 ; // 65536 คือตัวเลขที่มากกว่าจำนวนสูงสุดที่อนุญาตจากช่วงของค่าที่ถูกต้อง ดังนั้นโอเวอร์โฟลว์จะเกิดขึ้นเนื่องจากตัวแปร x ไม่สามารถเก็บ 17 บิตได้

มาตรฐาน::cout<< "x is now: " << x << std :: endl ;

กลับ 0 ;

x คือ: 65535
x ตอนนี้: 0

เกิดอะไรขึ้น? เกิดการโอเวอร์โฟลว์เนื่องจากเราพยายามยัดเยียดบางสิ่งที่ไม่สามารถผลักเข้าไปในตัวแปร x

สำหรับผู้ที่ต้องการทราบข้อมูลเพิ่มเติม:หมายเลข 65535 ในไบนารี่จะแสดงเป็น 1111 1111 1111 1111 65535 เป็นตัวเลขที่ใหญ่ที่สุดที่ตัวแปรจำนวนเต็มขนาด 2 ไบต์ (16 บิต) ที่ไม่ได้ลงนามสามารถจัดเก็บได้เนื่องจากใช้ทั้ง 16 บิต เมื่อเราบวก 1 เราจะได้ตัวเลข 65536 หมายเลข 65536 จะแสดงในรูปแบบไบนารีเป็น 1 0000 0000 0000 0000 และใช้ถึง 17 บิต! ดังนั้นบิตที่สำคัญที่สุด (ซึ่งก็คือ 1) จะหายไป และบิตทั้งหมด 16 บิตทางด้านขวาจะยังคงอยู่ ชุดค่าผสม 0000 0000 0000 0000 สอดคล้องกับเลขทศนิยม 0 ซึ่งเป็นผลลัพธ์ของเรา

ในทำนองเดียวกัน เราจะได้ค่าล้นโดยใช้ตัวเลขที่น้อยกว่าค่าต่ำสุดของช่วงค่าที่ถูกต้อง:

#รวม int main() ( unsigned short x = 0; // ค่าน้อยที่สุดที่ตัวแปร unsigned ขนาด 2 ไบต์สามารถเก็บ std::cout<< "x was: " << x << std::endl; x = x - 1; // переполнение! std::cout << "x is now: " << x << std::endl; return 0; }

#รวม

int หลัก()

ไม่ได้ลงนามสั้น x = 0 ; // ค่าที่น้อยที่สุดที่ตัวแปรที่ไม่ได้ลงนามขนาด 2 ไบต์สามารถจัดเก็บได้

มาตรฐาน::cout<< "x was: " << x << std :: endl ;

x = x - 1 ; //ล้น!

มาตรฐาน::cout<< "x is now: " << x << std :: endl ;

กลับ 0 ;

ผลลัพธ์ของการรันโปรแกรมด้านบน:

x คือ: 0
x ตอนนี้: 65535

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

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

ตารางที่ 1 - ชนิดข้อมูล C++

พิมพ์	ไบต์	ช่วงของค่าที่ยอมรับ
ชนิดข้อมูลจำนวนเต็ม (บูลีน)
บูล	1	0 / 255
ชนิดข้อมูลจำนวนเต็ม (อักขระ)
ถ่าน	1	0 / 255
ชนิดข้อมูลจำนวนเต็ม
สั้น ๆ	2	-32 768 / 32 767
int สั้นที่ไม่ได้ลงนาม	2	0 / 65 535
ภายใน	4
int ที่ไม่ได้ลงนาม	4	0 / 4 294 967 295
ยาว	4	-2 147 483 648 / 2 147 483 647
int ยาวที่ไม่ได้ลงนาม	4	0 / 4 294 967 295
ชนิดข้อมูลจุดลอยตัว
ลอย	4	-2 147 483 648.0 / 2 147 483 647.0
ลอยยาว	8
สองเท่า	8	-9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

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

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

รายการแรกในตารางคือประเภทข้อมูลบูล — ประเภทข้อมูลจำนวนเต็มเนื่องจากช่วงของค่าที่ถูกต้องคือจำนวนเต็มตั้งแต่ 0 ถึง 255 แต่อย่างที่คุณสังเกตเห็นแล้วในวงเล็บมันบอกว่าประเภทข้อมูลเชิงตรรกะและนี่ก็เป็นจริงเช่นกัน เพราะ บูลใช้เพื่อจัดเก็บผลลัพธ์ของนิพจน์บูลีนเท่านั้น นิพจน์บูลีนสามารถมีผลลัพธ์อย่างใดอย่างหนึ่งจากสองรายการ: จริงหรือเท็จ จริง - หากนิพจน์เชิงตรรกะเป็นจริง เท็จ - หากนิพจน์เชิงตรรกะเป็นเท็จ

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

// data_type.cpp: กำหนดจุดเริ่มต้นสำหรับแอปพลิเคชันคอนโซล #รวม "stdafx.h" #รวม ใช้เนมสเปซมาตรฐาน; int main(int argc, char* argv) ( bool boolean = 25; // ตัวแปรประเภท bool ชื่อ boolean if (boolean) // เงื่อนไขของตัวดำเนินการ if cout<< "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

ใน บรรทัดที่ 9ประกาศตัวแปรประเภทบูล ซึ่งเริ่มต้นเป็น 25 ตามทฤษฎีแล้วหลังจากนั้นบรรทัดที่ 9ในตัวแปรบูลีน ควรมีเลข 25 แต่จริงๆ แล้วตัวแปรนี้มีเลข 1 อย่างที่บอกไปแล้วว่าเลข 0 เป็นค่าเท็จ เลข 1 เป็นค่าจริง ประเด็นก็คือในตัวแปรเช่นบูล สามารถมีสองค่า - 0 (เท็จ) หรือ 1 (จริง) ในขณะที่ประเภทข้อมูลบูล มีการจัดสรรไบต์ทั้งหมดซึ่งหมายความว่าตัวแปรประเภทบูล สามารถมีตัวเลขได้ตั้งแต่ 0 ถึง 255 ในการกำหนดค่าเท็จและค่าจริงจำเป็นต้องใช้เพียงสองค่า 0 และ 1 คำถามเกิดขึ้น: "ค่าอีก 253 ค่ามีไว้เพื่ออะไร"

จากสถานการณ์นี้ เราตกลงที่จะใช้ตัวเลขตั้งแต่ 2 ถึง 255 เทียบเท่ากับเลข 1 ซึ่งก็คือความจริง นี่เป็นเหตุผลว่าทำไมตัวแปรบูลีนจึงมีตัวเลข 25 ไม่ใช่ 1. In บรรทัดที่ 10 -13ประกาศซึ่งโอนการควบคุมไปยังผู้ปฏิบัติงานใน บรรทัดที่ 11หากเงื่อนไขเป็นจริงและผู้ดำเนินการจะเข้ามา บรรทัดที่ 13ถ้าเงื่อนไขเป็นเท็จ ผลลัพธ์ของโปรแกรมแสดงในรูปที่ 1

True = 1 กดปุ่มใดก็ได้เพื่อดำเนินการต่อ - -

รูปที่ 1 - ประเภทข้อมูลบูล

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

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

ASCII (จากรหัสมาตรฐานภาษาอังกฤษสำหรับการแลกเปลี่ยนข้อมูล) - รหัสมาตรฐานอเมริกันสำหรับการแลกเปลี่ยนข้อมูล

พิจารณาโปรแกรมที่ใช้ชนิดข้อมูลถ่าน

// symbols.cpp: กำหนดจุดเริ่มต้นสำหรับแอปพลิเคชันคอนโซล #รวม "stdafx.h" #รวม ใช้เนมสเปซมาตรฐาน; int main(int argc, char* argv) ( char symbol = "a"; // ประกาศตัวแปรประเภท char และเริ่มต้นด้วยสัญลักษณ์ "a" cout<< "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

ดังนั้นใน บรรทัดที่ 9ตัวแปรชื่อเครื่องหมาย จะได้รับการกำหนดค่าสัญลักษณ์"เป็น" ( รหัส ASCII- ใน บรรทัดที่ 10ผู้ดำเนินการศาล พิมพ์อักขระที่มีอยู่ในตัวแปรเครื่องหมาย ใน บรรทัดที่ 11อาร์เรย์สตริงชื่อเชือก และขนาดของอาร์เรย์จะถูกระบุโดยปริยาย สตริงถูกเก็บไว้ในอาร์เรย์สตริง"เว็บไซต์" - โปรดทราบว่าเมื่อเราบันทึกสัญลักษณ์ลงในตัวแปรเช่นถ่าน จากนั้นหลังจากเครื่องหมายเท่ากับเราใส่เครื่องหมายคำพูดเดี่ยวที่เราเขียนสัญลักษณ์ เมื่อเริ่มต้นอาร์เรย์สตริงด้วยสตริงบางตัว เครื่องหมายคำพูดคู่จะถูกวางไว้หลังเครื่องหมายเท่ากับ ซึ่งมีการเขียนสตริงบางตัว เช่นเดียวกับอักขระทั่วไป สตริงจะถูกส่งออกโดยใช้ตัวดำเนินการศาล บรรทัดที่ 12- ผลลัพธ์ของโปรแกรมแสดงในรูปที่ 2

สัญลักษณ์ = a string = site หากต้องการดำเนินการต่อ ให้กดปุ่มใดก็ได้ - -

รูปที่ 2 - ประเภทข้อมูลถ่าน

ชนิดข้อมูลจำนวนเต็ม

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

คำนำหน้าประเภทข้อมูลจำนวนเต็ม:

สั้น — คำนำหน้าจะย่อประเภทข้อมูลที่ใช้ให้สั้นลงโดยการลดขนาดของหน่วยความจำที่ใช้

ยาว — คำนำหน้าจะขยายประเภทข้อมูลที่ใช้โดยการเพิ่มขนาดของหน่วยความจำที่ใช้

ไม่ได้ลงนาม - คำนำหน้าจะเพิ่มช่วงของค่าบวกเป็นสองเท่า ในขณะที่ไม่สามารถจัดเก็บช่วงของค่าลบในประเภทข้อมูลนี้ได้

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

ประเภทข้อมูลจุดลอยตัว

ข้อมูลจุดลอยตัวในภาษา C++ มีสองประเภท: float และ double ชนิดข้อมูลจุดลอยตัวได้รับการออกแบบมาเพื่อจัดเก็บหมายเลขจุดลอยตัว ชนิดข้อมูลทศนิยมและสองเท่าสามารถเก็บตัวเลขทศนิยมทั้งเชิงบวกและเชิงลบ ประเภทข้อมูลโฟลตมีพื้นที่หน่วยความจำครึ่งหนึ่งของประเภทข้อมูลคู่ ซึ่งหมายความว่าช่วงของค่าที่ยอมรับก็จะน้อยกว่าเช่นกัน หากมีการประกาศประเภทข้อมูล float ด้วยคำนำหน้าแบบยาว ช่วงของค่าที่ยอมรับจะเท่ากับช่วงของค่าที่ยอมรับของประเภทข้อมูลคู่ โดยพื้นฐานแล้ว ประเภทข้อมูลจุดลอยตัวจำเป็นสำหรับการแก้ปัญหาที่มีความแม่นยำในการคำนวณสูง เช่น ธุรกรรมทางการเงิน

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

// data_types.cpp: กำหนดจุดเริ่มต้นสำหรับแอปพลิเคชันคอนโซล #รวม "stdafx.h" #รวม // ไลบรารีการจัดการ I/O #include // ไฟล์ส่วนหัวของฟังก์ชันทางคณิตศาสตร์ #include ใช้เนมสเปซมาตรฐาน; int main(int argc, char* argv) ( cout<< " data type " << "byte" << " " << " max value "<< endl // ส่วนหัวของคอลัมน์ <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

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

Max_val_type = 2^(ข * 8 - 1) - 1; // สำหรับประเภทข้อมูลที่มีจำนวนลบและบวก // โดยที่ b คือจำนวนไบต์ที่จัดสรรในหน่วยความจำสำหรับตัวแปรที่มีประเภทข้อมูลนี้ // คูณด้วย 8 เนื่องจากมี 8 บิตในหนึ่งไบต์ // ลบ 1 ในวงเล็บ เนื่องจากตัวเลขช่วงจะต้องแบ่งออกเป็นสองส่วนสำหรับค่าบวกและลบ // ลบ 1 ที่ท้ายเนื่องจากช่วงของตัวเลขเริ่มต้นจากศูนย์ // ประเภทข้อมูลที่มีคำนำหน้าไม่ได้ลงนาม max_val_type = 2^(b * 8) - 1; // สำหรับชนิดข้อมูลที่มีจำนวนบวกเท่านั้น // คำอธิบายสูตรจะคล้ายกันเฉพาะหน่วยเท่านั้นที่ไม่ถูกลบออกจากวงเล็บ

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

ประเภทข้อมูลไบต์ค่าสูงสุดบูล = 1 255.00 ถ่าน = 1 255.00 int สั้น = 2 32767.00 int สั้นที่ไม่ได้ลงนาม = 2 65535.00 int = 4 2147483647.00 int ที่ไม่ได้ลงนาม = 4 4294967295.00 ยาว int = 4 2147483647.0 0 int ยาวที่ไม่ได้ลงนาม = 4 4294967295.00 float = 4 2147483647.00 สองเท่า = 8 9223372036854775808.00 หากต้องการดำเนินการต่อ ให้กดปุ่มใดก็ได้ - -

รูปที่ 3 - ชนิดข้อมูล C++

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

// ชวเลขสำหรับประเภทข้อมูล int short a1; // เช่นเดียวกับ short int long a1; // เช่นเดียวกับ long int a1 ที่ไม่ได้ลงนาม; // เหมือนกับ a1 แบบสั้นที่ไม่ได้ลงนาม int ที่ไม่ได้ลงนาม; // เช่นเดียวกับ int แบบสั้นที่ไม่ได้ลงนาม

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

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

คำตอบ:

ประเภทข้อมูลจำนวนเต็ม:

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

ประเภทข้อมูลจุดลอยตัว (สอดคล้องกับประเภทจริง):

ลอย, สองเท่า, สองเท่ายาว.

ประเภทข้อมูลตัวละคร:

ถ่าน (ถ่านที่ลงนาม), ถ่านที่ไม่ได้ลงนาม, wchar_t

ประเภทข้อมูลบูลีน:

บูล

ประเภทข้อมูลที่แจกแจง (แนะนำใน Visual C++):

แจกแจง

2. การใช้ชนิดข้อมูลจำนวนเต็มมีคุณลักษณะอย่างไร

ในภาษา C++ ประเภทข้อมูลจำนวนเต็มหลักคือ: short int, int short int ที่ไม่ได้ลงนาม, int, int ที่ไม่ได้ลงนาม, long (int ยาว), unsigned long (int ยาวที่ไม่ได้ลงนาม)

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

2 -100 398

ชนิดข้อมูลที่ขึ้นต้นด้วยคำนำหน้าที่ไม่ได้ลงนามสามารถมีได้เฉพาะตัวเลขที่เป็นบวกเท่านั้น

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

ข้อมูลประเภท long, unsigned long ใช้พื้นที่หน่วยความจำเป็นสองเท่าของข้อมูลประเภท int, unsigned int

3. จะอธิบายตัวแปรชื่อ x ชนิดจำนวนเต็มในโปรแกรมได้อย่างไร?

คำตอบ:

อินท์ x; // เซ็นจำนวนเต็ม

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

4. จะเขียนตัวเลข 239 ลงในตัวแปรประเภทจำนวนเต็มได้อย่างไร?

เมื่อต้องการทำเช่นนี้ ให้ใช้โอเปอเรเตอร์ที่ได้รับมอบหมาย ซึ่งแสดงด้วยสัญลักษณ์ '='

คำตอบ 1.การป้อนตัวเลขลงในตัวแปรหลังคำอธิบาย

อินท์ x; x = 239;

ตอบ 2.การป้อนตัวเลขลงในตัวแปรระหว่างคำอธิบาย (การกำหนดค่าเริ่มต้น)

อินท์ x = 239;

5. คุณลักษณะของประเภทข้อมูลจุดลอยตัวมีอะไรบ้าง?

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

8.35 -990.399 239.0.

C++ มีประเภทข้อมูลจุดลอยตัวพื้นฐานดังต่อไปนี้:

ลอย, สองเท่า, สองเท่ายาว.

ตัวแปรชนิด double ใช้พื้นที่ในหน่วยความจำคอมพิวเตอร์มากกว่าตัวแปรชนิด float ถึง 2 เท่า

นอกจากนี้ ตัวแปรชนิด double ยาวยังใช้พื้นที่ในหน่วยความจำคอมพิวเตอร์มากกว่าตัวแปรชนิด double ถึง 2 เท่า

6. จะอธิบายตัวแปรที่รับค่าจุดลอยตัวได้อย่างไร?

ตัวอย่างการอธิบายตัวแปรประเภท float, double, long double:

ลอยฉ; ดับเบิลดี; ld ยาวสองเท่า;

7. จะเขียนค่าตัวเลขลงในตัวแปรจุดลอยตัวได้อย่างไร?

ตัวอย่างการป้อนข้อมูลตัวเลขลงในตัวแปรจุดลอยตัว:

ลอย f = -9928.45; // การเริ่มต้นเบื้องต้น ดับเบิลดี; ld ยาวสองเท่า; ง = 0.445332; // ตัวดำเนินการที่ได้รับมอบหมาย ld = 3892923898239.030903; // ตัวดำเนินการที่ได้รับมอบหมาย

8. จะแปลงตัวแปร float เป็นประเภท int ได้อย่างไร?

เมื่อต้องการทำเช่นนี้ จะใช้การดำเนินการหล่อแบบ ในวงเล็บ คุณต้องระบุชื่อประเภทการร่ายที่จะร่าย

ลอย; อินท์ข; ก = 8.457; ข = (int ) ก; // ข = 8

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

ตัวอย่างเช่น ตัวแปรประเภท short int สามารถแสดงช่วงตัวเลขที่น้อยกว่าตัวแปรประเภท float หรือ double รายการต่อไปนี้ล้นค่าในตัวแปรประเภท short int :

สั้น int ฉัน; ลอยฉ; ฉ = 3990099.8; ฉัน = (int )f; // i = -7597 - ล้น

9. จะแปลงตัวแปรจาก type int เป็น type double ได้อย่างไร?

ตัวอย่างการส่งจาก int เป็นสองเท่า:

ฉัน; ดับเบิลดี; ผม = 982; d = (สองเท่า)i; // ง = 982.0

10. คุณสมบัติของการใช้ข้อมูลถ่าน (ข้อมูลตัวอักษร) ในโปรแกรมมีอะไรบ้าง?

ข้อมูลประเภทอักขระแสดงถึงค่าอักขระของโค้ดที่ป้อนจากแป้นพิมพ์ รหัสสัญลักษณ์เป็นจำนวนเต็ม

ตัวอย่างเช่น รหัสสำหรับอักขระ 'f' คือ 102

ส่วนของโค้ดที่คำนวณโค้ดอักขระ:

รหัส int; สัญลักษณ์ถ่าน สัญลักษณ์ = "ฉ" ; รหัส = (int ) สัญลักษณ์; // รหัส = 102

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

ความสัมพันธ์ระหว่างอักขระกับโค้ดจะอยู่ในตารางสัญลักษณ์ Windows อักขระที่มีรหัสตั้งแต่ 0 ถึง 127 เป็นอักขระ BIOS ที่สงวนไว้ ประกอบด้วยสัญลักษณ์ สัญลักษณ์ตัวเลข และสัญลักษณ์ละตินที่ใช้บ่อยที่สุด อักขระเหล่านี้ไม่สามารถเปลี่ยนแปลงได้

อักขระที่มีรหัสตั้งแต่ 128 ถึง 255 คืออักขระภูมิภาคที่เชื่อมโยงกับตัวอักษรเฉพาะของคอมพิวเตอร์ที่ติดตั้งระบบปฏิบัติการ Windows

11. อะไรคือคุณสมบัติของการใช้บูลชนิดข้อมูล (ชนิดลอจิคัล)?

ตัวแปรประเภทบูลสามารถรับได้เพียงสองค่าเท่านั้น:

จริง - ความจริง

เท็จ - เท็จ

ตัวแปรเหล่านี้ใช้เพื่อทดสอบนิพจน์บูลีน ค่าตัวเลขของจริงคือ 1 ค่าตัวเลขของเท็จคือ 0

ข้อมูลโค้ดที่กำหนดค่าตัวเลข true และ false :

ผลลัพธ์ภายใน; บูลข; ผลลัพธ์ = (int) จริง; // ผลลัพธ์ = 1 ข = เท็จ ; ผลลัพธ์ = (int )b; // ผลลัพธ์ = 0

ข้อมูลโค้ดที่แปลงประเภท int และ float เป็นบูล:

ฉัน; ลอยฉ; บูลข; ฉัน = 6; b = (บูล )i; // ข = จริง ฉ = 0.0; b = (บูล)f; // ข = เท็จ

12. จะกำหนดขนาดของหน่วยความจำที่ตัวแปรประเภทที่กำหนดได้อย่างไร?

การดำเนินการ sizeof() ใช้สำหรับสิ่งนี้

ข้อมูลโค้ดที่กำหนดขนาดของข้อมูลบางประเภท:

อินท์ดี; d = ขนาดของ (ถ่าน); // ง = 1 d = ขนาดของ (int ที่ไม่ได้ลงนาม); // ง = 4 d = ขนาดของ (ลอย); // ง = 4 d = ขนาดของ (สองเท่า); // ง = 8

13. ตัวแปรประเภทต่างๆ มีการกำหนดค่าเริ่มต้นอย่างไร?

อินท์ d = 28; ลอย z = (ลอย )2.85; ถ่าน c = "k" ; สตริง ^s = "สวัสดี!" - สองเท่า r = -8.559;

14. จะกำหนดค่าสูงสุดที่อนุญาต (ขั้นต่ำที่อนุญาต) ของตัวแปรบางประเภทได้อย่างไร?

เมื่อต้องการกำหนดค่าสูงสุดหรือต่ำสุดสำหรับตัวแปรบางชนิด ไลบรารี .NET Framework จะใช้คุณสมบัติ MaxValue และ MinValue

ตัวอย่างการกำหนดค่าขีดจำกัดของตัวแปรประเภทต่างๆ

สำหรับตัวแปรประเภท int :

// พิมพ์ int ฉัน; MaxInt ยาว; MinInt ยาว; MaxInt = (ยาว )i.MaxValue; // MaxInt = 2147483647 MinInt = (ยาว) i.MinValue; // MinInt = -2147483648

สำหรับตัวแปรประเภท short int :

// พิมพ์ int สั้น ๆ สั้น int si; อินท์ แม็กซ์อินท์; int MinInt; MaxInt = (int )si.MaxValue; // MaxInt = 32767 MinInt = (int )si.MinValue; // MinInt = -32768

สำหรับตัวแปรประเภท unsigned int :

// พิมพ์ int ที่ไม่ได้ลงนาม int ui ที่ไม่ได้ลงนาม; int MaxInt ที่ไม่ได้ลงนาม; int MinInt ที่ไม่ได้ลงนาม; MaxInt = ui.MaxValue; // MaxInt = 4294967295 MinInt = ui.MinValue; // MinInt = 0

สำหรับตัวแปรทศนิยม:

//แบบลอย ลอยฉ; ลอย MaxF; ลอย MinF; MaxF = f.MaxValue; // MaxF = 3.402823E+38 MinF = f.MinValue; // MinF = -3.402823E+38

สำหรับตัวแปรประเภท double:

// ประเภทคู่ ดับเบิลดี; MaxD สองเท่า; MinD สองเท่า; สูงสุด = d.MaxValue; // สูงสุด = 1.79769313486232E+308 Min = d.MinValue; // ต่ำสุด = -1.79769313486232E+308

สำหรับตัวแปรประเภท char :

// พิมพ์ char ถ่านค; อินท์ แม็กซ์ซี; อินท์มินซี; สูงสุด = (int )c.MaxValue; // สูงสุด = 127 ต่ำสุด = (int )c.MinValue; // ต่ำสุด = -128

15. การใช้ประเภทแจงนับมีคุณสมบัติอะไรบ้าง?

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

ตัวอย่างการใช้ประเภทแจงนับเพื่อแสดงเดือนของปี:

เดือนแจกแจง (มกราคม, กุมภาพันธ์, มีนาคม, เมษายน, พฤษภาคม, มิถุนายน, กรกฎาคม, สิงหาคม กันยายน ตุลาคม พฤศจิกายน ธันวาคม) นาที; นาที = มกราคม; // นาที = 0 นาที = มีนาคม; // นาที = 2 นาที = กันยายน; // นาที = 8

ตัวอย่างด้านล่างอธิบายตัวแปรชื่อ mn ประเภทเดือนแจงนับ ค่าช่วยในการจำสำหรับเดือน (มกราคม, กุมภาพันธ์, …) เริ่มต้นจาก 0 (0, 1, 2, …) ค่าช่วยในการจำ มกราคม คือค่าจำนวนเต็ม 0 ค่าช่วยในการจำ กุมภาพันธ์ คือค่าจำนวนเต็ม 1 และอื่นๆ

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

คุณยังสามารถเขียนได้ดังนี้:

mn = (เดือนแจงนับ)2; // นาที = มีนาคม mn = (ระบุเดือน)11; // นาที = ธันวาคม

16. ชนิดมีคุณลักษณะอะไรบ้างเป็นโมฆะ ในโปรแกรมบนค++ ?

ชนิดข้อมูลเป็นโมฆะจะใช้ในกรณีต่อไปนี้:

หากคุณต้องการอธิบายฟังก์ชันที่ไม่ส่งคืนค่าใด ๆ (ดูตัวอย่าง)
หากคุณต้องการอธิบายฟังก์ชันที่ไม่ได้รับพารามิเตอร์ (ดูตัวอย่าง)

ตัวอย่าง- MyFun() เป็นฟังก์ชันที่ไม่มีพารามิเตอร์ที่ไม่ส่งคืนค่า (ส่งคืนประเภท void ) และไม่รับพารามิเตอร์

สาธารณะ : โมฆะ MyFun(โมฆะ) { // ส่วนฟังก์ชั่น // ... กลับ; // คืนค่าจากฟังก์ชันที่ไม่คืนค่า } // เรียกใช้ฟังก์ชันจากโปรแกรม ... MyFun(); ...

17. เป็นไปได้หรือไม่ที่จะประกาศตัวแปรประเภทเป็นโมฆะ ในโปรแกรมเหรอ?

สิ่งนี้เป็นไปไม่ได้เนื่องจากประเภทโมฆะไม่เกี่ยวข้องกับค่า

การประกาศตัวแปรประเภท void ส่งผลให้เกิดข้อผิดพลาดในการคอมไพล์โดยมีข้อความต่อไปนี้:

“การใช้ประเภทโมฆะอย่างผิดกฎหมาย”

18. ชนิดมีคุณลักษณะอะไรบ้างwchar_ ที วีภาพ ค++ ?

ตัวแปรประเภทถ่าน (ดูย่อหน้าก่อนหน้า) ใช้เพื่อจัดเก็บอักขระ ASCII 8 บิต

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

ตัวอย่างโดยใช้ประเภท wchar_t

... wchar_t เสื้อ; // หน่วยความจำ 2 ไบต์ถูกจัดสรรให้กับตัวแปร t เสื้อ = "ส"; ...