Apabila menulis program dalam mana-mana bahasa, anda perlu menggunakan pembolehubah yang berbeza untuk menyimpan maklumat yang berbeza. Pembolehubah hanyalah lokasi memori terpelihara untuk menyimpan nilai. Ini bermakna apabila anda mencipta pembolehubah, anda menjimatkan sedikit ruang dalam ingatan.

Anda boleh menyimpan maklumat pelbagai jenis data seperti aksara, aksara lebar, integer, titik terapung, titik terapung berganda, boolean, dll. Berdasarkan jenis data pembolehubah, sistem pengendalian memperuntukkan memori dan memutuskan perkara yang boleh disimpan dalam ingatan terpelihara.

Jenis terbina dalam primitif

C++ menawarkan kepada pengaturcara satu set kaya dengan jenis data terbina dalam serta yang ditentukan pengguna. Jadual berikut menyenaraikan tujuh jenis data C++ utama:

taip	Kata kunci
Boolean	bool
Perwatakan	char
Integer	int
Titik terapung	terapung
Titik terapung berganda	berganda
Tidak bernilai	batal
Watak yang luas	wchar_t

Beberapa jenis asas boleh diubah suai menggunakan satu atau lebih pengubah jenis ini:

• ditandatangani
• tidak ditandatangani
• pendek

Jadual berikut menunjukkan jenis pembolehubah, jumlah memori yang diperlukan untuk menyimpan nilai dalam ingatan, dan apakah nilai maksimum dan minimum yang boleh disimpan dalam pembolehubah tersebut.

taip	Lebar Bit Biasa	Julat Biasa
char	1bait	-127 hingga 127 atau 0 hingga 255
char yang tidak ditandatangani	1bait	0 hingga 255
char yang ditandatangani	1bait	-127 hingga 127
int	4bait	-2147483648 hingga 2147483647
int yang tidak ditandatangani	4bait	0 hingga 4294967295
ditandatangani int	4bait	-2147483648 hingga 2147483647
int pendek	2bait	-32768 hingga 32767
int pendek tidak ditandatangani	Julat	0 hingga 65,535
int pendek yang ditandatangani	Julat	-32768 hingga 32767
int panjang	4bait	-2,147,483,648 kepada 2,147,483,647
ditandatangani int panjang	4bait	sama seperti long int
int panjang yang tidak ditandatangani	4bait	0 kepada 4,294,967,295
terapung	4bait	+/- 3.4e +/- 38 (~7 digit)
berganda	8bait
berganda panjang	8bait	+/- 1.7e +/- 308 (~15 digit)
wchar_t	2 atau 4 bait	1 aksara lebar

Saiz pembolehubah mungkin berbeza daripada saiz yang ditunjukkan dalam jadual di atas, bergantung pada pengkompil dan komputer yang anda gunakan. Di bawah ialah contoh yang akan memberikan saiz yang betul bagi jenis data yang berbeza pada komputer anda.

#termasuk menggunakan ruang nama std; 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; }

Contoh ini menggunakan endl yang memperkenalkan watak baris baharu selepas setiap baris, dan pengendali<< используется для передачи нескольких значений на экран. Мы также используем оператор saiz() untuk mendapatkan saiz pelbagai jenis data.

Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan output berikut, yang mungkin berbeza dari mesin ke mesin:

Saiz char: 1 Saiz int: 4 Saiz int pendek: 2 Saiz int panjang: 4 Saiz apungan: 4 Saiz double: 8 Saiz wchar_t: 4

Pengisytiharan Typedef

Anda boleh mencipta nama baharu untuk jenis sedia ada menggunakan typedef. Di bawah ialah sintaks mudah untuk menentukan jenis baharu menggunakan typedef:

Typedef taip nama baharu;

Sebagai contoh, yang berikut memberitahu pengkompil bahawa kaki ialah nama lain untuk int:

Typedef int kaki;

Sekarang pengisytiharan berikut adalah sah dengan sempurna dan mencipta pembolehubah integer yang dipanggil jarak:

Jarak kaki

Jenis yang disenaraikan

Jenis terhitung mengisytiharkan nama jenis pilihan dan satu set sifar atau lebih pengecam yang boleh digunakan sebagai nilai jenis. Setiap enumerator adalah pemalar yang jenisnya adalah enumeration. Membuat penghitungan memerlukan penggunaan kata kunci enum. Pandangan umum jenis penghitungan:

Enum enum-name ( senarai nama ) var-list;

Di sini enum-name ialah nama jenis enum. Senarai nama dipisahkan dengan koma. Sebagai contoh, kod berikut mentakrifkan penghitungan warna yang dipanggil warna dan pembolehubah c bagi warna jenis. Akhirnya, c diberikan nilai "biru".

Warna enum ( merah, hijau, biru ) c; c = biru;

Secara lalai, nama pertama mempunyai nilai 0, nama kedua mempunyai nilai 1, dan nama ketiga mempunyai nilai 2, dsb. Tetapi anda boleh menjadikan nama sebagai nilai tertentu dengan menambah pemula. Sebagai contoh, dalam penghitungan berikut, hijau akan mempunyai nilai 5.

Warna enum(merah, hijau = 5, biru);

Di sini biru akan mempunyai nilai 6 kerana setiap nama akan lebih besar daripada yang sebelumnya.

Kemas kini terakhir: 17/09/2017

Setiap pembolehubah mempunyai jenis tertentu. Dan jenis ini menentukan nilai yang boleh dimiliki oleh pembolehubah, operasi yang boleh dilakukan padanya, dan berapa banyak bait dalam memori yang akan didudukinya. Jenis data asas berikut ditakrifkan dalam bahasa C++:

bool : jenis boolean. Boleh mengambil satu daripada dua nilai: benar dan salah. Jejak ingatan untuk jenis ini tidak ditakrifkan dengan tepat.

char : Mewakili satu aksara ASCII. Menduduki 1 bait (8 bit) dalam ingatan. Boleh menyimpan sebarang nilai dari -128 hingga 127, atau dari 0 hingga 255

signed char : Mewakili satu aksara. Menduduki 1 bait (8 bit) dalam ingatan. Boleh menyimpan sebarang nilai dari -128 hingga 127

unsigned char : Mewakili satu aksara. Menduduki 1 bait (8 bit) dalam ingatan. Boleh menyimpan sebarang nilai dari 0 hingga 255

wchar_t : Mewakili watak yang luas. Pada Windows ia memerlukan 2 bait (16 bit) memori, di Linux ia memerlukan 4 bait (32 bit). Boleh menyimpan sebarang nilai daripada julat dari 0 hingga 65,535 (untuk 2 bait), atau dari 0 hingga 4,294,967,295 (untuk 4 bait)

char16_t : Mewakili satu aksara Unicode. Menduduki 2 bait (16 bit) dalam ingatan. Boleh menyimpan sebarang nilai dari 0 hingga 65,535

char32_t : Mewakili satu aksara Unicode. Menduduki 4 bait (32 bit) dalam ingatan. Boleh menyimpan sebarang nilai dari 0 hingga 4,294,967,295

pendek : Mewakili integer dalam julat –32768 hingga 32767. Menduduki 2 bait (16 bit) memori.

Jenis ini juga mempunyai sinonim short int, signed short int, signed short.

unsigned short: Mewakili integer dalam julat 0 hingga 65535. Menduduki 2 bait (16 bit) memori.

Jenis ini juga mempunyai sinonim unsigned short int .

int: mewakili integer. Bergantung pada seni bina pemproses, ia boleh menduduki 2 bait (16 bit) atau 4 bait (32 bit). Julat nilai had juga boleh berbeza dari –32768 hingga 32767 (dengan 2 bait) atau dari -2,147,483,648 hingga 2,147,483,647 (dengan 4 bait). Tetapi dalam apa jua keadaan, saiz mestilah lebih besar daripada atau sama dengan saiz jenis pendek dan kurang daripada atau sama dengan saiz jenis panjang

Jenis ini mempunyai sinonim signed int dan signed .

unsigned int : Mewakili integer positif. Bergantung pada seni bina pemproses, ia mungkin menduduki 2 bait (16 bit) atau 4 bait (32 bit), dan kerana ini, julat nilai had mungkin berbeza: dari 0 hingga 65535 (untuk 2 bait), atau dari 0 hingga 4,294,967,295 (untuk 4 bait).

unsigned boleh digunakan sebagai sinonim untuk jenis ini

panjang : Mewakili integer dalam julat −2,147,483,648 hingga 2,147,483,647. Menduduki 4 bait (32 bit) memori.

Jenis ini juga mempunyai sinonim long int , signed long int dan signed long

panjang tidak ditandatangani: Mewakili integer dalam julat 0 hingga 4,294,967,295. Menduduki 4 bait (32 bit) memori.

Mempunyai sinonim unsigned long int .

panjang panjang: Mewakili integer dalam julat −9,223,372,036,854,775,808 hingga +9,223,372,036,854,775,807. Menduduki biasanya 8 bait (64 bit) memori.

Mempunyai sinonim long long int , ditandatangani long long int dan ditandatangani long long .

unsigned long long : Mewakili integer dalam julat 0 hingga 18,446,744,073,709,551,615. Biasanya menduduki 8 bait (64 bit) memori.

Mempunyai sinonim unsigned long long int .

apungan : Mewakili nombor nyata titik terapung ketepatan tunggal dalam julat +/- 3.4E-38 hingga 3.4E+38. Menduduki 4 bait (32 bit) dalam ingatan

ganda : Mewakili nombor nyata titik terapung ketepatan berganda dalam julat +/- 1.7E-308 hingga 1.7E+308. Menduduki 8 bait (64 bit) dalam ingatan

long double : Mewakili nombor nyata titik terapung berketepatan ganda sekurang-kurangnya 8 bait (64 bit). Bergantung pada saiz memori yang diduduki, julat nilai yang sah mungkin berbeza-beza.

void : taip tanpa nilai

Oleh itu, semua jenis data kecuali void boleh dibahagikan kepada tiga kumpulan: aksara (char, wchar_t, char16_t, char32_t), integer (short, int, long, long long) dan jenis nombor titik terapung (float, double, long double).

Jenis watak

Jenis yang digunakan untuk mewakili aksara dalam aplikasi ialah char, wchar_t, char16_t dan char32_t.

Mari kita tentukan beberapa pembolehubah:

Char c="d"; wchar_t d="c";

Pembolehubah char mengambil sebagai nilainya satu aksara dalam petikan tunggal: char c ="d" . Anda juga boleh menetapkan nombor daripada julat yang dinyatakan di atas dalam senarai: char c = 120 . Dalam kes ini, nilai pembolehubah c akan menjadi aksara yang mempunyai kod 120 dalam jadual aksara ASCII.

Perlu dipertimbangkan bahawa untuk mengeluarkan aksara wchar_t ke konsol, anda harus menggunakan bukan std::cout, tetapi aliran std::wcout:

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

Dalam kes ini, aliran std::wcout boleh berfungsi dengan kedua-dua char dan wchar_t. Dan aliran std::cout untuk pembolehubah wchar_t akan mengeluarkan kod berangkanya dan bukannya aksara.

Piawaian C++11 menambah jenis char16_t dan char32_t, yang berorientasikan penggunaan Unicode. Walau bagaimanapun, urutan untuk bekerja dengan jenis ini belum lagi dilaksanakan di peringkat OS. Oleh itu, jika anda perlu memaparkan nilai pembolehubah jenis ini kepada konsol, anda perlu menukar pembolehubah kepada jenis char atau wchar_t:

#termasuk 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; }

Dalam kes ini, apabila mengeluarkan, pembolehubah didahului oleh operasi tuang kepada jenis char - (char) , kerana nilai pembolehubah b, c dan d ditukar kepada jenis char dan boleh dikeluarkan kepada konsol menggunakan aliran std::cout.

Jenis integer

Jenis integer diwakili oleh jenis berikut: pendek, pendek tidak bertanda, int, int tidak bertanda, panjang, panjang tidak bertanda, panjang panjang dan panjang tidak bertanda:

Pendek a = -10; pendek tidak bertanda b= 10; int c = -30; unsigned int d = 60; panjang e = -170; panjang tidak bertanda f = 45; panjang panjang g = 89;

Jenis nombor titik terapung

Jenis titik terapung dan nombor pecahan diwakili oleh apungan, ganda dua dan ganda panjang:

Terapung a = -10.45; b ganda = 0.00105; c berganda panjang = 30.890045;

Saiz jenis data

Senarai di atas menunjukkan untuk setiap jenis saiz yang didudukinya dalam ingatan. Walau bagaimanapun, perlu diperhatikan bahawa pembangun pengkompil boleh memilih had saiz untuk jenis secara bebas, berdasarkan keupayaan perkakasan komputer. Piawaian hanya menetapkan nilai minimum yang sepatutnya. Sebagai contoh, untuk jenis int dan pendek nilai minimum ialah 16 bit, untuk jenis panjang - 32 bit, untuk jenis berganda panjang. Dalam kes ini, saiz jenis panjang mestilah tidak kurang daripada saiz jenis int, dan saiz jenis int mestilah tidak kurang daripada saiz jenis pendek, dan saiz jenis double panjang mesti menjadi lebih besar daripada dua kali ganda. Sebagai contoh, pengkompil g++ untuk Windows menggunakan 12 bait untuk beregu panjang, dan pengkompil terbina dalam Visual Studio dan juga berjalan di bawah Windows menggunakan 8 bait untuk beregu panjang. Iaitu, walaupun dalam platform yang sama, penyusun yang berbeza mungkin mempunyai pendekatan yang berbeza kepada saiz jenis data tertentu. Tetapi secara umum, saiz yang ditunjukkan di atas semasa menerangkan jenis data digunakan.

Walau bagaimanapun, terdapat situasi apabila perlu mengetahui dengan tepat saiz jenis tertentu. Dan untuk ini, C++ mempunyai operator sizeof(), yang mengembalikan saiz memori dalam bait yang diduduki pembolehubah:

#termasuk int main() ( nombor berganda panjang = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Output konsol semasa menyusun dalam g++:

saiz(nombor) = 12

Pada masa yang sama, apabila mentakrifkan pembolehubah, adalah penting untuk memahami bahawa nilai pembolehubah tidak boleh melebihi had yang digariskan untuk jenisnya. Sebagai contoh:

Nombor pendek tidak ditandatangani = -65535;

Pengkompil G++, apabila menyusun atur cara dengan baris ini, akan menghasilkan ralat yang menyatakan bahawa nilai -65535 tidak berada dalam julat nilai yang sah untuk jenis pendek yang tidak ditandatangani dan akan dipotong.

Dalam Visual Studio, kompilasi boleh diteruskan tanpa ralat, tetapi pembolehubah nombor akan menerima nilai 2 - hasil daripada menukar nombor -65535 kepada jenis pendek yang tidak ditandatangani. Iaitu, sekali lagi, hasilnya tidak akan seperti yang diharapkan. Nilai pembolehubah hanyalah koleksi bit dalam ingatan yang ditafsirkan mengikut jenis tertentu. Dan untuk jenis yang berbeza, set bit yang sama boleh ditafsirkan secara berbeza. Oleh itu, adalah penting untuk mempertimbangkan julat nilai untuk jenis tertentu apabila memberikan nilai kepada pembolehubah.

penentu auto

Kadangkala sukar untuk menentukan jenis ungkapan. Dan mengikut piawaian terkini, anda boleh membiarkan pengkompil membuat kesimpulan jenis objek itu sendiri. Dan penentu auto digunakan untuk ini. Selain itu, jika kita mentakrifkan pembolehubah dengan penentu auto, pembolehubah ini mesti dimulakan dengan beberapa nilai:

Nombor automatik = 5;

Berdasarkan nilai yang diberikan, pengkompil akan membuat kesimpulan jenis pembolehubah. Pembolehubah yang tidak dimulakan dengan penentu auto tidak dibenarkan.

Jenis data dalam C adalah kelas data yang nilainya mempunyai ciri yang serupa. Jenis mentakrifkan perwakilan dalaman data dalam ingatan. Jenis data paling asas: logik, integer, nombor titik terapung, rentetan, penunjuk.

Dengan menaip dinamik, pembolehubah dikaitkan dengan jenis pada masa permulaan. Ternyata pembolehubah dalam bahagian kod yang berlainan boleh mempunyai jenis yang berbeza. Penaipan dinamik disokong oleh Skrip Java, Python, Ruby, PHP.

Penaipan statik adalah bertentangan dengan penaipan dinamik. Apabila diisytiharkan, pembolehubah menerima jenis yang tidak berubah kemudian. Bahasa C dan C++ adalah begitu sahaja. Kaedah ini adalah yang paling mudah untuk menulis kod kompleks, dan banyak ralat dihapuskan pada peringkat penyusunan.

Bahasa secara tidak formal dibahagikan kepada ditaip kuat dan ditaip lemah. Penaipan yang kuat bermakna bahawa pengkompil akan membuang ralat jika jenis yang dijangka dan sebenar tidak sepadan.

x = 1 + “2”; //ralat - anda tidak boleh menambah simbol pada nombor

Contoh menaip yang lemah.

Pemeriksaan ketekalan jenis dijalankan oleh sistem keselamatan jenis. Ralat menaip berlaku, sebagai contoh, apabila cuba menggunakan nombor sebagai fungsi. Terdapat bahasa yang tidak ditaip. Berbeza dengan yang ditaip, mereka membenarkan anda melakukan sebarang operasi pada setiap objek.

Kelas ingatan

Pembolehubah, tanpa mengira jenisnya, mempunyai skop dan hayatnya sendiri.

Kelas ingatan:

• auto;
• statik;
• luaran;
• mendaftar.

Semua pembolehubah dalam bahasa C adalah setempat secara lalai. Ia hanya boleh digunakan dalam fungsi atau blok. Apabila fungsi selesai, nilainya dimusnahkan.

Pembolehubah statik juga setempat, tetapi boleh mempunyai nilai yang berbeza di luar bloknya, dan nilai itu disimpan antara panggilan fungsi.

Pembolehubah luaran adalah global. Ia tersedia dalam mana-mana bahagian kod dan juga dalam fail lain.

Penentu jenis data dalam C mungkin tidak dinyatakan dalam kes berikut:

1. Semua pembolehubah di dalam blok bukan pembolehubah; oleh itu, jika kelas memori tertentu ini bertujuan untuk digunakan, maka penentu auto tidak dinyatakan.
2. Semua fungsi yang diisytiharkan di luar blok atau fungsi adalah global secara lalai, jadi penentu luaran tidak diperlukan.

Untuk menunjukkan jenis mudah, gunakan penentu int, char, float atau berganda. Pengubah suai yang tidak ditandatangani, ditandatangani, pendek, panjang, panjang panjang boleh digantikan dengan pembolehubah.

Secara lalai, semua nombor ditandatangani; oleh itu, mereka hanya boleh berada dalam julat nombor positif. Untuk menentukan pembolehubah jenis char sebagai ditandatangani, tulis char yang ditandatangani. Panjang, panjang panjang dan pendek menunjukkan berapa banyak ruang memori yang diperuntukkan untuk storan. Yang terbesar panjang panjang, yang terkecil pendek.

Char ialah jenis data terkecil dalam C. Hanya 1 bait memori diperuntukkan untuk menyimpan nilai. Pembolehubah jenis aksara biasanya diberikan aksara, kurang kerap - nombor. Nilai aksara disertakan dalam tanda petikan.

Jenis int menyimpan integer, saiznya tidak ditentukan - ia memerlukan sehingga 4 bait memori, bergantung pada seni bina komputer.

Penukaran eksplisit pembolehubah yang tidak ditandatangani ditentukan seperti berikut:

Yang tersirat kelihatan seperti ini:

Terapung dan takrif dua kali nombor dengan titik. Nombor apungan diwakili sebagai -2.3 atau 3.34. Double digunakan untuk ketepatan yang lebih tinggi - lebih banyak digit ditunjukkan selepas pemisah integer dan pecahan. Jenis ini mengambil lebih banyak ruang memori daripada terapung.

Void mempunyai nilai kosong. Ia mentakrifkan fungsi yang tidak mengembalikan apa-apa. Penentu ini menentukan nilai kosong dalam argumen kaedah. Penunjuk, yang boleh menerima sebarang jenis data, juga ditakrifkan sebagai tidak sah.

Boolean jenis Bool

Digunakan dalam ujian keadaan dan gelung. Hanya mempunyai dua makna:

• benar;
• berbohong.

Nilai Boolean boleh ditukar kepada nilai int. Benar bersamaan dengan satu, palsu bersamaan dengan sifar. Penukaran jenis hanya boleh dilakukan antara bool dan int, jika tidak, pengkompil akan membuang ralat.

if (x) ( //Ralat: "Tidak boleh secara tersirat menukar jenis 'int' kepada 'bool""

jika (x != 0) // Cara C#

Rentetan dan Tatasusunan

Tatasusunan ialah jenis data yang kompleks dalam C. PL tidak berfungsi dengan rentetan dengan cara yang sama seperti Javascript atau Ruby. Dalam C, semua rentetan ialah tatasusunan elemen dengan nilai aksara. Baris berakhir dengan bait nol "

Selain membahagikan data kepada pembolehubah dan pemalar, terdapat klasifikasi data mengikut jenis. Penerangan pembolehubah terutamanya terdiri daripada mengisytiharkan jenisnya. Jenis data mencirikan julat nilainya dan bentuk perwakilan dalam ingatan komputer. Setiap jenis dicirikan oleh satu set operasi yang dilakukan pada data. Secara tradisinya, bahasa pengaturcaraan tujuan umum mempunyai jenis standard seperti integer, nyata, watak, dan logik 3 . Mari kita segera ambil perhatian bahawa tidak ada jenis logik dalam C. Ungkapan (dalam kes tertentu, pembolehubah) dianggap benar jika ia bukan sifar, jika tidak ia dianggap palsu.

Kewujudan dua jenis berangka (integer dan nyata) dikaitkan dengan dua bentuk yang mungkin mewakili nombor dalam ingatan komputer.

Data keseluruhan jenis disimpan dalam bentuk persembahan titik tetap. Ia dicirikan oleh ketepatan mutlak dalam mewakili nombor dan melaksanakan operasi padanya, serta julat nilai nombor yang terhad. Jenis integer digunakan untuk data yang, pada dasarnya, tidak boleh mempunyai bahagian pecahan (bilangan orang, kereta, dsb., nombor dan pembilang).

Taip sebenar sepadan dengan bentuk perwakilan nombor titik terapung, yang dicirikan oleh perwakilan anggaran nombor dengan bilangan digit bererti tertentu (tanda mantissa) dan julat besar susunan nombor, yang memungkinkan untuk mewakili kedua-dua nombor yang sangat besar dan sangat kecil dalam nilai mutlak. Disebabkan oleh perwakilan anggaran data jenis sebenar, mereka adalah tidak betul untuk membandingkan untuk kesamarataan.

Dalam pelaksanaan moden bahasa pengaturcaraan sejagat, biasanya terdapat beberapa integer dan beberapa jenis sebenar, setiap satunya dicirikan oleh saiz memori yang diperuntukkan untuk satu nilai dan, dengan itu, julat nilai nombornya, dan untuk jenis sebenar - dan ketepatannya. (bilangan digit mantissa).

Data jenis watak mengambil nilai pada keseluruhan set aksara yang dibenarkan untuk komputer tertentu. Satu bait diperuntukkan untuk menyimpan satu nilai aksara; aksara dikodkan mengikut jadual pengekodan standard (biasanya ASCII).

Terdapat 4 jenis asas dalam C:

char- jenis watak;

int- jenis keseluruhan,

terapung- jenis sebenar ketepatan tunggal,

berganda- jenis sebenar berketepatan berganda.

Untuk menentukan jenis terbitan, gunakan kelayakan:pendek(pendek) - digunakan dengan jenis int,panjang(panjang) - digunakan dengan jenis int Dan berganda;ditandatangani(dengan tanda), tidak ditandatangani(tidak ditandatangani) - digunakan untuk sebarang jenis integer. Dengan ketiadaan perkataan tidak ditandatangani, nilai itu dianggap ditandatangani, i.e. iaitu lalai ditandatangani. Disebabkan oleh kebolehterimaan gabungan sewenang-wenangnya bagi kelayakan dan nama jenis asas, satu jenis boleh mempunyai beberapa sebutan. Maklumat tentang jenis C standard dibentangkan dalam Jadual 1 dan 2. Deskriptor sinonim disenaraikan dalam sel lajur pertama, dipisahkan dengan koma.

Jadual 1. Jenis data integer C standard

Jenis data		Julat nilai
char, char yang ditandatangani
unsigned int, unsigned
int, int yang ditandatangani, int pendek, pendek
		2147483648...2147483647

Menariknya, dalam C, jenis char boleh digunakan sebagai aksara atau sebagai jenis integer, bergantung pada konteks.

Jadual 2. Jenis data sebenar Standard C

Komen. Untuk menulis atur cara untuk bahagian pertama manual, kami akan memerlukannya dua jenis:terapungDanint.

Dalam pengaturcaraan, jenis data ialah koleksi dua set: satu set nilai dan satu set operasi yang boleh digunakan pada mereka. Contohnya, operasi penambahan (+), pendaraban (*), pembahagian integer (/), baki (%) dan penolakan (−) boleh digunakan pada jenis data integer bukan negatif yang terdiri daripada set nombor asli terhingga.

Bahasa pengaturcaraan biasanya mempunyai set jenis data primitif—jenis yang disediakan oleh bahasa pengaturcaraan sebagai unit terbina dalam asas. Dalam C++, pencipta bahasa itu memanggil jenis jenis asas. Jenis asas dalam C++ ialah:

• boolean(bool);
• watak (cth char);
• int (cth int);
• titik terapung (cth terapung);
• penghitungan (ditakrifkan oleh pengaturcara);
• batal .

Di atas yang disenaraikan, jenis berikut dibina:

• demonstratif (cth int*);
• tatasusunan (cth char);
• rujukan (cth double&);
• struktur lain.

Mari kita beralih kepada konsep literal (contohnya, 1, 2.4F, 25e-4, 'a', dll.): literal ialah entri dalam kod sumber program yang mewakili nilai tetap. Dalam erti kata lain, literal hanyalah perwakilan objek (nilai) beberapa jenis dalam kod program. C++ mempunyai keupayaan untuk menulis nilai integer, titik terapung, aksara, boolean dan rentetan.

Literal jenis integer boleh ditulis sebagai:

• sistem nombor ke-10. Contohnya, 1205 ;
• Sistem nombor ke-8 dalam format 0 + nombor. Sebagai contoh, 0142;
• Sistem nombor ke-16 dalam format 0x + nombor. Contohnya, 0x2F.

24, 030, 0x18 - ini semua adalah rekod nombor yang sama dalam sistem nombor yang berbeza.
Untuk menulis nombor titik terapung, gunakan notasi titik: 0.1, .5, 4. - sama ada dalam
tatatanda eksponen - 25e-100. Seharusnya tiada ruang dalam rekod sedemikian.

Nama yang mana kita boleh mengaitkan nilai yang ditulis dalam literal dipanggil pembolehubah. Pembolehubah ialah kawasan ingatan yang dinamakan atau boleh dialamatkan yang alamatnya boleh digunakan untuk mengakses data. Data ini ditulis, ditulis semula dan dipadamkan dalam ingatan dengan cara tertentu semasa pelaksanaan program. Pembolehubah membolehkan anda mengakses data pada bila-bila masa dan, jika perlu, mengubahnya. Data yang boleh diambil daripada nama pembolehubah dipanggil nilai pembolehubah.
Untuk menggunakan pembolehubah dalam atur cara, ia mesti diisytiharkan, dan jika perlu, ia boleh ditakrifkan (= dimulakan). Pengisytiharan pembolehubah dalam teks program semestinya mengandungi 2 bahagian: jenis asas dan pengisytihar. Penentu dan pemula adalah bahagian pilihan:

Const int contoh = 3; // di sini const ialah penentu // int ialah jenis asas // contoh ialah nama pembolehubah // = 3 - pemula.

Nama pembolehubah ialah urutan aksara yang terdiri daripada huruf abjad Latin (huruf kecil dan besar), nombor dan/atau garis bawah, tetapi aksara pertama tidak boleh menjadi nombor. Nama pembolehubah harus dipilih supaya sentiasa mudah untuk meneka apa yang disimpan, sebagai contoh, "monthPayment". Dalam nota dan dalam amalan, kami akan menggunakan notasi CamelCase untuk peraturan untuk merekodkan pembolehubah. Nama pembolehubah tidak boleh bertepatan dengan perkataan yang dikhaskan dalam bahasa; contoh perkataan tersebut ialah: jika, sementara, fungsi, goto, suis, dsb.

Sebagai tambahan kepada nama pembolehubah, pengisytihar boleh mengandungi aksara tambahan:

• * - penunjuk; sebelum nama;
• *const - penunjuk tetap; sebelum nama;
• & - pautan; sebelum nama;
• - tatasusunan; selepas nama;
• () - fungsi; selepas nama.

Pemula membolehkan anda menentukan nilai untuk pembolehubah sejurus selepas pengisytiharannya. Pemula bermula dengan literal kesamaan (=) dan kemudian meneruskan untuk menetapkan nilai pembolehubah. Secara umumnya, tanda sama dalam C++ menandakan operasi tugasan; dengan bantuannya anda boleh menetapkan dan menukar nilai pembolehubah. Ia mungkin berbeza untuk jenis yang berbeza.

Penentu menentukan atribut tambahan selain daripada jenis. Penentu const yang diberikan dalam contoh membolehkan anda melarang perubahan seterusnya kepada nilai pembolehubah. Pembolehubah tidak berubah tersebut dipanggil pemalar atau pemalar.

Mengisytiharkan pemalar tanpa permulaan tidak akan berfungsi atas sebab logik:

Const int EMPTY_CONST; // ralat, pembolehubah malar tidak dimulakan const int CONTOH = 2; // pemalar dengan nilai 2 CONTOH = 3; // ralat, cuba berikan nilai kepada pembolehubah malar

Apabila menamakan pemalar, adalah kebiasaan untuk menggunakan hanya huruf besar, memisahkan perkataan dengan aksara garis bawah.

Jenis data asas dalam C++

Semasa meneliti setiap jenis, pembaca tidak boleh lupa tentang definisi jenis data.

1. Jenis integer (char, pendek (int), int, panjang (int), panjang panjang)

Dari namanya mudah difahami bahawa set nilai terdiri daripada integer. Juga, set nilai setiap jenis yang disenaraikan boleh ditandatangani atau tidak ditandatangani. Bilangan elemen yang terkandung dalam set bergantung pada saiz memori yang digunakan untuk menyimpan nilai jenis tersebut. Sebagai contoh, untuk pembolehubah jenis char 1 bait memori diperuntukkan, jadi jumlah elemen ialah:

• 2 8N = 2 8 * 1 = 256, di mana N ialah saiz memori dalam bait untuk menyimpan nilai

Dalam kes ini, julat integer yang tersedia adalah seperti berikut:

• - untuk char yang tidak ditandatangani
• [-128..127] - untuk char yang ditandatangani

Secara lalai, pembolehubah integer dianggap ditandatangani. Untuk menunjukkan dalam kod bahawa pembolehubah mesti tidak ditandatangani, atribut yang ditandatangani ditambahkan pada jenis asas di sebelah kiri, i.e. tidak ditandatangani:

Nilai panjang yang tidak ditandatangani; // menentukan jenis integer (panjang) tidak bertanda.

Jenis yang disenaraikan hanya berbeza dalam saiz memori yang diperlukan untuk penyimpanan. Oleh kerana bahasa C++ agak bergantung kepada mesin, standard bahasa hanya menjamin keadaan berikut:

• 1 = saiz char ≤ saiz pendek ≤ saiz int ≤ saiz panjang.

Biasanya saiz jenis adalah seperti berikut: char - 1, short - 2, int - 4, long -8, long long - 8 bait.

Anda boleh melakukan operasi aritmetik dengan nilai jenis integer: +, -, *, /, %; operasi perbandingan: ==, !=,<=, <, >, >=; operasi bit: &, |, xor,<<, >>.
Kebanyakan operasi, seperti penambahan, pendaraban, penolakan dan perbandingan, mudah difahami. Kadangkala, selepas menjalankan operasi aritmetik, hasilnya mungkin berada di luar julat nilai; dalam kes ini program akan menghasilkan ralat.
Pembahagian integer (/) mencari bahagian integer bagi satu integer dibahagikan dengan yang lain. Sebagai contoh:

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

Simbol peratusan (%) menandakan operasi menentukan baki pembahagian dua integer:

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

Operasi yang lebih sukar untuk difahami ialah operasi bitwise: & (DAN), | (ATAU), xor (eksklusif ATAU),<< (побитовый сдвиг влево), >> (anjakan sedikit ke kanan).

Operasi bit AND, OR dan XOR menggunakan operasi logik yang sepadan untuk setiap bit maklumat:

• 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 xor 3 10 = 01 2 xor 11 2 = 10 2

Dalam pemprosesan imej, 3 saluran digunakan untuk warna: merah, biru dan hijau - ditambah ketelusan, yang disimpan dalam pembolehubah int, kerana setiap saluran mempunyai julat nilai dari 0 hingga 255. Dalam sistem nombor heksadesimal, nilai tertentu ditulis seperti berikut: 0x180013FF; maka nilai 18 16 sepadan dengan saluran merah, 00 16 - biru, 13 16 - hijau, FF - saluran alfa (transparensi). Untuk memilih saluran tertentu daripada integer sedemikian, saluran yang dipanggil digunakan. topeng, di mana kedudukan yang kami minati ialah F 16 atau 1 2. Iaitu, untuk menyerlahkan nilai saluran biru, anda mesti menggunakan topeng, i.e. bitwise DAN:

Int blue_channel = 0x180013FF & 0x00FF0000;

Selepas itu nilai yang terhasil dialihkan ke kanan dengan bilangan bit yang diperlukan.

Anjakan sedikit menganjakkan nombor ke kiri atau kanan dengan seberapa banyak digit binari seperti yang dinyatakan di sebelah kanan operasi. Sebagai contoh, nombor 39 untuk jenis char ditulis dalam binari seperti berikut: 00100111. Kemudian:

Char binaryContoh = 39; // 00100111 char result = binaryContoh<< 2; // сдвигаем 2 бита влево, результат: 10011100

Jika pembolehubah adalah jenis yang tidak ditandatangani, maka hasilnya akan menjadi nombor 156, untuk yang ditandatangani ia adalah sama dengan -100. Ambil perhatian bahawa untuk jenis integer yang ditandatangani, unit dalam bit yang paling ketara bagi perwakilan bit ialah tanda bahawa nombor itu negatif. Dalam kes ini, nilai dalam bentuk binari yang terdiri daripada kesemuanya sepadan dengan -1; jika 1 hanya dalam digit paling ketara, dan digit yang tinggal adalah sifar, maka nombor tersebut mempunyai nilai minimum untuk jenis tertentu: untuk char ia adalah -128.

2. Jenis titik terapung (float, double (float))

Set nilai titik terapung ialah subset nombor nyata, tetapi tidak setiap nombor nyata boleh diwakili dalam binari, yang kadangkala membawa kepada ralat bodoh:

Nilai apungan = 0.2; nilai == 0.2; // ralat, nilai di sini tidak akan sama dengan 0.2.

Apabila bekerja dengan pembolehubah titik terapung, pengaturcara tidak seharusnya menggunakan ujian kesamaan atau ketaksamaan; sebaliknya, ujian untuk jatuh dalam selang tertentu biasanya digunakan:

Nilai - 0.2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

Selain operasi perbandingan, jenis titik terapung menyokong 4 operasi aritmetik yang sepadan sepenuhnya dengan operasi matematik dengan nombor nyata.

3. Jenis Boolean (logik) (bool)

Hanya terdiri daripada dua nilai: benar (benar) dan salah (salah). Untuk bekerja dengan pembolehubah jenis ini, operasi logik digunakan: ! (BUKAN), == (kesamaan), != (ketaksamaan), && (logik DAN), || (logik ATAU). Keputusan setiap operasi boleh didapati dalam jadual kebenaran yang sepadan. Sebagai contoh:

X Y XOR0 0 0 0 1 1 1 0 1 1 1 0

4. Jenis aksara (char, wchar_t)

Jenis aksara bukan sahaja jenis integer (biasanya jenis ini dipanggil bait), tetapi juga jenis aksara, menyimpan nombor aksara daripada jadual sebagai aksara ASCII. Sebagai contoh, kod 0x41 sepadan dengan aksara 'A' dan 0x71 - 't'.

Kadangkala ia menjadi perlu untuk menggunakan aksara yang tidak ditetapkan dalam jadual ASCII dan oleh itu memerlukan lebih daripada 1 bait untuk penyimpanan. Terdapat watak yang luas untuk mereka (wchar_t).

5.1. Tatasusunan

Tatasusunan membolehkan anda menyimpan set berurutan elemen dari jenis yang sama. Tatasusunan disimpan dalam ingatan sebagai blok bersebelahan, jadi anda tidak boleh mengisytiharkan tatasusunan tanpa menyatakan saiznya. Untuk mengisytiharkan tatasusunan, kurungan segi empat sama () ditulis selepas nama pembolehubah yang menunjukkan saiznya. Sebagai contoh:

Int myArray; // Tatasusunan 5 elemen jenis integer

Untuk memulakan tatasusunan, nilai disenaraikan dalam pendakap kerinting. Anda boleh memulakan dengan cara ini hanya pada masa pengisytiharan berubah. Dengan cara ini, dalam kes ini, tidak perlu menentukan saiz array:

Int odds = (1, 3, 7, 9, 11); // Tatasusunan dimulakan dengan 5 nilai

Untuk mengakses nilai tertentu dalam tatasusunan (elemen tatasusunan), gunakan operasi capaian indeks () yang menunjukkan nombor elemen (nombor bermula dari 0). Sebagai contoh:

Kemungkinan; // akses kepada elemen pertama tatasusunan. Mengembalikan kemungkinan nilai 1; // akses kepada elemen ketiga. Mengembalikan nilai 7 kemungkinan = 13; // Berikan nilai baharu kepada elemen ke-5 bagi kemungkinan tatasusunan; // ralat akses

5.3. rentetan

Untuk menulis rentetan, pengaturcara menggunakan idea bahawa rentetan ialah siri berurutan (tatasusunan) aksara. Untuk mengenal pasti hujung baris, gunakan aksara hujung baris khas: '\0'. Watak istimewa ini, yang terdiri daripada garis miring ke belakang dan watak mengenal pasti, dipanggil watak kawalan atau melarikan diri. Terdapat juga, sebagai contoh, '\n' - permulaan baris baharu, '\t' - penjadualan. Untuk menulis garis miring ke belakang dalam rentetan, escape digunakan - garis miring lain diletakkan sebelum tanda itu sendiri: ‘\’. Melarikan diri juga digunakan untuk menulis tanda petikan.

Mari buat pembolehubah rentetan:

Char textContoh = ('T', 'e', ​​​​'s', 't', '\0'); // rentetan "Ujian" ditulis

Terdapat tatatanda yang dipermudahkan untuk permulaan rentetan:

Char textContoh = "Ujian"; // Aksara terakhir tidak ditulis, tetapi saiznya masih 5

Tanpa pergi ke butiran, berikut ialah satu lagi jenis data yang berguna - rentetan. rentetan
Jenis ini boleh, sebagai contoh, ditambah:

String hello = "Hello,"; nama rentetan = "Maks!"; rentetan hello_name = hello + name; // Dapatkan rentetan "Hello, Max!"

6. Pautan

Int a = 2; // pembolehubah "a" menunjuk kepada nilai 2 int &b = a; // pembolehubah “b” menunjuk ke tempat yang sama dengan “a” b = 4; // dengan menukar nilai b, pengaturcara menukar nilai a. Sekarang a = 4 int & c = 4; // ralat, anda tidak boleh melakukan ini kerana rujukan tidak boleh diberikan nilai

7. Indeks

Untuk memahami jenis data ini, anda perlu ingat bahawa banyak nilai jenis ini adalah alamat sel memori di mana data bermula. Penunjuk juga menyokong operasi tambah (+), tolak (-) dan nyahrujuk (*).

Alamat 0x0 bermakna penunjuk kosong, i.e. tidak menunjuk kepada sebarang data. Alamat ini mempunyai literalnya sendiri - NULL:

Int *nullPtr = NULL; // penuding nol

Menambah dan menolak alamat dengan integer atau alamat lain membolehkan
bergerak di sekitar memori yang tersedia untuk program.

Operasi mendapatkan semula data bermula pada alamat yang disimpan dalam penunjuk dipanggil dereferencing (*). Program ini membaca bilangan sel memori yang diperlukan dan mengembalikan nilai yang disimpan dalam ingatan.

Int valueInMemory = 2; // tetapkan pembolehubah jenis integer int *somePtr = // salin alamat pembolehubah, di sini & - mengembalikan alamat pembolehubah somePtr; // alamat sel memori, contohnya, 0x2F *somePtr; // nilai disimpan dalam 4 sel: 0x2F, 0x30, 0x31 dan 0x32

Operasi penugasan, yang secara sintaksis sama dengan operasi salin, tidak tersedia untuk penunjuk. Dalam erti kata lain, anda boleh menyalin alamat penuding lain atau alamat pembolehubah, tetapi anda tidak boleh menentukan nilai alamat itu sendiri.

Penunjuk itu sendiri disimpan dalam ingatan, seperti nilai pembolehubah jenis lain, dan menduduki 4 bait, jadi anda boleh membuat penunjuk ke penunjuk.

8. Pemindahan

Penghitungan adalah satu-satunya jenis asas yang ditakrifkan oleh pengaturcara. Pada umumnya, penghitungan ialah set tertib pemalar integer bernama, dengan nama penghitungan ialah jenis asas.

Warna enum (MERAH, BIRU, HIJAU);

Secara lalai, MERAH = 0, BIRU = 1, HIJAU = 2. Oleh itu, nilai-nilai boleh dibandingkan antara satu sama lain, i.e. MERAH< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Akses enum (BACA = 1, TULIS = 2, EXEC = 4);

Selalunya mudah untuk menggunakan penghitungan yang nilainya adalah kuasa dua, kerana dalam perwakilan binari, nombor yang merupakan kuasa 2 akan terdiri daripada 1 dan sifar. Sebagai contoh:

8 10 = 00001000 2

Hasil penambahan nombor ini bersama-sama sentiasa menunjukkan dengan jelas nombor yang telah ditambah:

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

batal

Secara sintaksis, jenis lompang tergolong dalam jenis asas, tetapi ia hanya boleh digunakan sebagai sebahagian daripada jenis yang lebih kompleks, kerana Tiada objek jenis void. Biasanya, jenis ini digunakan untuk menunjukkan bahawa fungsi tidak mempunyai nilai pulangan atau sebagai jenis asas penuding kepada objek jenis yang tidak ditentukan:

Objek tidak sah; // ralat, tiada objek jenis void void // ralat, tiada rujukan kepada void void *ptr; // ok, simpan penunjuk kepada jenis yang tidak diketahui

Selalunya kita akan menggunakan void secara khusus untuk menunjukkan bahawa fungsi tidak mengembalikan sebarang nilai. Penunjuk jenis lompang digunakan apabila pengaturcara mengambil tanggungjawab penuh untuk integriti memori dan penghantaran jenis yang betul.

Pelakon

Selalunya perlu untuk menghantar nilai pembolehubah satu jenis kepada yang lain. Dalam kes di mana set nilai jenis asal ialah subset jenis yang lebih besar (contohnya, int ialah subset panjang dan panjang ialah dua kali ganda), pengkompil dapat secara tersirat ( secara tersirat) tukar jenis nilai.

integer = 2; terapung terapung = integer; // terapung = 2.0

Lemparan jenis terbalik akan dilakukan dengan kehilangan maklumat, jadi hanya bahagian integer nombor titik terapung akan kekal, bahagian pecahan akan hilang.

Terdapat kemungkinan penukaran jenis eksplisit; untuk ini, di sebelah kiri pembolehubah atau mana-mana nilai jenis asal, tulis jenis yang pelakon akan dilakukan dalam kurungan:

Nilai int = (int) 2.5;

Operasi unari dan binari

Operasi yang kami lakukan sebelum ini dipanggil binari: di sebelah kiri dan kanan simbol operasi adalah nilai atau pembolehubah, contohnya, 2 + 3. Selain operasi binari, bahasa pengaturcaraan juga menggunakan operasi unari yang digunakan untuk pembolehubah . Mereka boleh terletak sama ada di sebelah kiri atau di sebelah kanan pembolehubah; beberapa operasi sedemikian telah ditemui sebelum ini - operasi penyahrujukan (*) dan mengambil alamat pembolehubah (&) adalah unary. Pengendali “++” dan “—” masing-masing menambah dan menurunkan nilai pembolehubah integer sebanyak 1, dan boleh ditulis sama ada di sebelah kiri atau di sebelah kanan pembolehubah.

C++ juga menggunakan tatatanda trengkas untuk operasi binari dalam kes apabila bahagian kiri dan kanan ungkapan mengandungi pembolehubah yang sama, i.e. beberapa operasi dilakukan pada nilai pembolehubah dan hasil operasi disimpan dalam pembolehubah yang sama:

A += 2; // sama seperti a = a + 2; b /= 5; // sama seperti b = b / 5; c &= 3; // sama seperti c = c & 3;