C++ ตัวแปรและประเภท: Int, Char, Float, Double, สตริงและบูล

C++ ประเภทข้อมูลตัวแปร

C++ กำหนดประเภทดั้งเดิมทั้งชุด

เค้ก ถือเป็นโมฆะ type ไม่มีค่าที่เกี่ยวข้องและสามารถใช้ได้ในบางกรณีเท่านั้น โดยทั่วไปแล้วจะเป็นประเภทฟังก์ชันส่งคืนที่ไม่ส่งคืนค่า

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

1. ประเภทจุดลอยตัวตัวเลข float (หรือชนิด floating) แสดงตัวเลขทศนิยม มาตรฐาน IEEE ระบุจำนวนหลักที่มีนัยสำคัญขั้นต่ำ คอมไพเลอร์ส่วนใหญ่ให้ความแม่นยำมากกว่าจำนวนขั้นต่ำที่ระบุไว้ โดยทั่วไป ตัวเลข float จะแสดงเป็น 32 บิต ตัวเลข double จะแสดงเป็น 64 บิต และตัวเลข long double จะแสดงเป็น 96 หรือ 128 บิต
2. ประเภทอินทิกรัล (ซึ่งรวมถึงอักขระ จำนวนเต็ม และประเภทบูลีน) ที่ บูลีน type มีค่าเพียงสองประเภท: จริงหรือเท็จ มีหลายอย่าง ถัง ประเภทต่างๆ ซึ่งส่วนใหญ่มีอยู่เพื่อรองรับความเป็นสากล ประเภทอักขระพื้นฐานที่สุดคืออักขระ ถ่านมีขนาดเท่ากับไบต์ของเครื่องเดียวซึ่งหมายถึงไบต์เดียว

เค้ก ประเภทอินทิกรัล อาจจะลงนามหรือไม่ได้ลงนาม

ประเภทลงนาม: แทนค่าตัวเลขลบหรือบวก (รวมถึงศูนย์) ในประเภทที่มีเครื่องหมาย ช่วงจะต้องถูกแบ่งอย่างเท่าเทียมกันระหว่างค่า +ve และ -ve ดังนั้น อักขระที่มีเครื่องหมายขนาด 8 บิตจะเก็บค่าตั้งแต่ –127 ถึง 127

ประเภทที่ไม่ได้ลงนาม: ในประเภทที่ไม่ได้ลงนาม ค่าทั้งหมดจะเป็น >= 0 อักขระที่ไม่ได้ลงนามขนาด 8 บิตสามารถมีตั้งแต่ 0 ถึง 255 (รวมทั้งคู่)

ชื่อตัวแปรหรือตัวระบุ

ตัวระบุอาจประกอบด้วยตัวอักษร ตัวเลข และอักขระขีดล่างหรือผสมกัน ไม่มีการจำกัดความยาวของชื่อ

ตัวระบุจะต้อง

• ขึ้นต้นด้วยตัวอักษรหรือขีดล่าง ('_')
• และคำนึงถึงขนาดตัวพิมพ์ ตัวอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กมีความแตกต่างกัน:

// กำหนดตัวแปร int ที่แตกต่างกันสี่ตัวแปร

int guru99, gurU99, GuRu99, GURU99;

เค้ก C++ ภาษาได้สงวนชื่อไว้สำหรับการใช้งาน

มีหลักเกณฑ์ที่เป็นที่ยอมรับมากมายสำหรับการตั้งชื่อตัวแปร ภาษาโปรแกรมที่แตกต่างกันการปฏิบัติตามข้อตกลงเหล่านี้สามารถปรับปรุงการอ่านโปรแกรมได้

• ตัวระบุควรให้ตัวบ่งชี้ความหมายของมันอย่างน้อย
• ชื่อตัวแปรมักจะเป็นตัวพิมพ์เล็ก — guru99 ไม่ใช่ Guru99 หรือ GURU99
• คลาสที่เรากำหนดมักจะเริ่มต้นด้วยอักษรตัวพิมพ์ใหญ่
• ตัวระบุที่ประกอบด้วยคำหลายคำควรแยกความแตกต่างทุกคำด้วยสายตา ตัวอย่างเช่น guru99_website ไม่ใช่ guru99website

C++ การประกาศตัวแปรและคำจำกัดความ

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

int a=5;
int b;
char c='A'; 

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

Const รอบคัดเลือกใน C++

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

ในกรณีเช่นนี้ ให้ใช้คีย์เวิร์ด const

const int bufSize = 512;    // input buffer size

สิ่งนี้กำหนด bufSize เป็นค่าคงที่ ความพยายามในการกำหนดหรือเปลี่ยนแปลง bufSize จะทำให้เกิดข้อผิดพลาด

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

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci 

ขอบเขตของตัวแปรใน C++

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

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}	 

โปรแกรมนี้กำหนดชื่อ 3 ชื่อ ได้แก่ main, sum และ val โดยใช้ชื่อเนมสเปซ std พร้อมกับชื่ออื่นอีก XNUMX ชื่อจากเนมสเปซนั้น ได้แก่ cout และ endl

• ชื่อฟังก์ชัน “main” ถูกกำหนดไว้ภายนอกเครื่องหมายปีกกา ชื่อฟังก์ชัน main—เหมือนกับชื่ออื่นๆ ส่วนใหญ่ที่กำหนดไว้ภายนอกฟังก์ชัน—มีขอบเขตส่วนกลาง ซึ่งหมายถึงเมื่อมีการประกาศชื่อซึ่งอยู่ที่ ขอบเขตทั่วโลก สามารถเข้าถึงได้ตลอดทั้งโปรแกรม
• ผลรวมของตัวแปรถูกกำหนดไว้ภายในขอบเขตของบล็อกซึ่งเป็นส่วนเนื้อหาของฟังก์ชันหลัก สามารถเข้าถึงได้จากจุดประกาศและทั่วทั้งส่วนที่เหลือของเนื้อหาของฟังก์ชันหลัก อย่างไรก็ตามไม่ใช่นอกนั้น ซึ่งหมายความว่าผลรวมของตัวแปรมี ขอบเขตบล็อก.
• ตัวแปร val ถูกกำหนดไว้ในขอบเขตของ "สำหรับคำสั่ง" สามารถใช้ได้อย่างง่ายดายในคำสั่งนั้น แต่ไม่สามารถใช้ที่อื่นในฟังก์ชันหลักได้ มันมี ขอบเขตท้องถิ่น.

ขอบเขตที่ซ้อนกัน

ขอบเขตสามารถมีขอบเขตอื่นได้ ขอบเขตที่มีอยู่ (หรือซ้อนกัน) เรียกว่าขอบเขตภายใน ขอบเขตที่มีคือขอบเขตภายนอก

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}	 

เอาท์พุต #1 ปรากฏก่อนคำจำกัดความในท้องถิ่นของการใช้ซ้ำ ดังนั้นผลลัพธ์นี้

คำสั่งคือชื่อที่ใช้ชื่อที่ใช้ซ้ำซึ่งกำหนดไว้ในขอบเขตส่วนกลาง คำสั่งนี้จะส่งออก

42 0

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

0 0

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

42 0

การแปลงประเภทตัวแปร

ตัวแปรประเภทหนึ่งสามารถแปลงเป็นอีกประเภทหนึ่งได้ เรียกว่า “การแปลงประเภท” เรามาดูกฎสำหรับการแปลงที่แตกต่างกัน C++ ประเภทตัวแปร:

การกำหนดค่าที่ไม่ใช่แบบบูลีนให้กับตัวแปรบูลีนจะให้ผลลัพธ์เป็นเท็จหากค่าเป็น 0 และให้ผลลัพธ์เป็นความจริงหากไม่เป็นเช่นนั้น

bool b = 42;            // b is true

การกำหนดบูลให้กับประเภทเลขคณิตประเภทใดประเภทหนึ่งจะให้ผล 1 ถ้าบูลเป็นจริง และ 0 ถ้าบูลเป็นเท็จ

bool b = true;
int i = b;              // i has value 1

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

int i = 3.14;               // i has value 3

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

Int i=3;
double pi = i;          // pi has value 3.0

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

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

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

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

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

คอมไพเลอร์ใช้การแปลงประเภทเดียวกันนี้เมื่อเราใช้ค่าประเภทหนึ่งโดยที่คาดว่าจะมีค่าประเภทอื่น

int i = 42;
if (i) // condition will evaluate as true
i = 0; 

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

ข้อควรระวัง: อย่าผสมประเภทที่ลงนามและไม่ได้ลงนาม

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

ตัวอย่างเช่น ในนิพจน์ทางคณิตศาสตร์ เช่น

x* y

ถ้า x เป็น -1 และ y เป็น 1 และถ้าทั้ง x และ y เป็น int ค่าจะเป็น -1 ตามที่คาดไว้

ถ้า x เป็น int และ y ไม่ได้ลงนาม ค่าของนิพจน์นี้จะขึ้นอยู่กับจำนวนจำนวนเต็มที่มีอยู่ในเครื่องคอมไพล์ บนเครื่องของเรา นิพจน์นี้ให้ผลลัพธ์ 4294967295

ลงทะเบียนตัวแปร

ตัวแปรรีจิสเตอร์เข้าถึงได้เร็วกว่าเมื่อเปรียบเทียบกับตัวแปรหน่วยความจำ ดังนั้นตัวแปรที่มักใช้ใน C++ สามารถลงทะเบียนโปรแกรมโดยใช้ ทะเบียน คำหลัก คีย์เวิร์ด register บอกให้คอมไพเลอร์จัดเก็บตัวแปรที่กำหนดในรีจิสเตอร์ เป็นทางเลือกของคอมไพเลอร์ว่าจะใส่ไว้ในรีจิสเตอร์หรือไม่ โดยทั่วไป คอมไพเลอร์เองจะทำการเพิ่มประสิทธิภาพต่างๆ ซึ่งรวมถึงการวางตัวแปรบางตัวลงในรีจิสเตอร์ ไม่มีการจำกัดจำนวนตัวแปรรีจิสเตอร์ใน a C++ โปรแกรม แต่คอมไพลเลอร์อาจไม่เก็บตัวแปรไว้ในรีจิสเตอร์ เนื่องจากหน่วยความจำรีจิสเตอร์มีจำกัดมากและระบบปฏิบัติการส่วนใหญ่ใช้งานโดยทั่วไป

เพื่อกำหนด:

register int i;

ความคิดเห็น

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

• ความคิดเห็นบรรทัดเดียว คืออันที่ขึ้นต้นด้วย // และต่อไปจนถึงท้ายบรรทัด หากอักขระตัวสุดท้ายในบรรทัดความคิดเห็นคือ \ ความคิดเห็นนั้นจะดำเนินต่อไปในบรรทัดถัดไป
• ความคิดเห็นหลายบรรทัด คือรายการที่ขึ้นต้นด้วย /* และลงท้ายด้วย */

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

ลำดับการหลบหนี

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

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

เค้ก C++ ภาษาโปรแกรม กำหนดลำดับการหลีกเลี่ยงหลายรายการ:

มันทำอะไรได้บ้าง	คาแรคเตอร์
นิวไลน์	\n
แท็บแนวตั้ง	\v
ทับขวา	\\
การกลับรถ	\r
แท็บแนวนอน	\t
Backspace	\b
เครื่องหมายคำถาม	\?
ฟีดรูปแบบ	\f
การแจ้งเตือน (ระฆัง)	\a
Double หุ้น	-
คำพูดเดียว	\ '

เราใช้ลำดับหลีกราวกับว่ามันเป็นอักขระตัวเดียว:

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline 

นอกจากนี้เรายังสามารถเขียนลำดับหลีกทั่วไป \x ตามด้วยเลขฐานสิบหกหนึ่งหลักขึ้นไป หรือเราใช้ \ ตามด้วยเลขฐานแปดหนึ่งหรือสองหรือสามหลัก ลำดับหลีกทั่วไปแสดงถึงค่าตัวเลขของอักขระ ตัวอย่างบางส่วน (สมมติว่าชุดอักขระ Latin-1):

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M') 

เราสามารถใช้ลำดับหลีกที่กำหนดไว้ล่วงหน้าได้ เนื่องจากเราใช้อักขระอื่น

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline 

สรุป

• A C++ ตัวแปรทำให้เรามีความสามารถในการจัดเก็บข้อมูลที่มีชื่อ
• C++ ประเภทตัวแปร: int, double, ถัง, float, string, bool ฯลฯ
• ขอบเขตที่มีอยู่ (หรือซ้อนกัน) เรียกว่าขอบเขตภายใน และขอบเขตที่มีคือขอบเขตภายนอก
• ตัวแปรประเภทหนึ่งสามารถแปลงเป็นอีกประเภทหนึ่งได้ เรียกว่า “การแปลงประเภท”
• ตัวแปรรีจิสเตอร์เข้าถึงได้เร็วกว่าเมื่อเปรียบเทียบกับตัวแปรหน่วยความจำ
• ความคิดเห็นคือส่วนของโค้ดที่คอมไพเลอร์ละเว้น
• อักขระบางตัว เช่น Backspace และอักขระควบคุม จะไม่มีรูปภาพที่มองเห็นได้