Keutamaan tertinggi diberikan kepada jenis yang paling sedikit maklumat hilang. Anda tidak seharusnya menyalahgunakan penukaran jenis tersirat, kerana pelbagai situasi yang tidak dijangka mungkin timbul.

• Penukaran eksplisit berbeza dengan tersirat, ia dijalankan oleh pengaturcara. Terdapat beberapa cara untuk melakukan penukaran ini:

1. Menukar kepada Gaya C: (terapung) a
2. Menukar kepada Gaya C++: terapung()

Jenis tuangan juga boleh dilakukan menggunakan operasi berikut:

static_cast<>() const_cast<>() reinterpret_cast<>() dynamic_cast<> ()

static_cas- menukar jenis data yang berkaitan. Operator ini menghantar jenis mengikut peraturan biasa, yang mungkin diperlukan apabila pengkompil tidak melakukan penukaran automatik. Sintaks akan kelihatan seperti ini:

Taip static_cast<Тип>(sebuah objek);

Menggunakan static_cast, anda tidak boleh mengalih keluar ketekalan daripada pembolehubah, tetapi pengendali berikut boleh melakukan ini. const_cast- digunakan hanya apabila perlu untuk mengeluarkan ketekalan daripada objek. Sintaks akan kelihatan seperti ini:

taipconst_cast< taip> (sebuah objek);

reinterpret_cast- digunakan untuk menukar jenis yang berbeza, integer kepada penunjuk dan sebaliknya. Jika anda melihat perkataan "indeks" baharu - jangan risau! Ini juga merupakan jenis data, tetapi kami tidak akan mengusahakannya dalam masa terdekat. Sintaks di sini adalah sama seperti operator yang dibincangkan sebelum ini:

taipmentafsir semula_cast< taip> (sebuah objek);

dynamic_cast- digunakan untuk penukaran jenis dinamik, melaksanakan penuding atau penuangan rujukan. Sintaks:

taipdinamik _cast< taip> (sebuah objek);

Kawal aksara

Anda sudah biasa dengan beberapa "watak kawalan" ini (contohnya, dengan \n). Semuanya bermula dengan garis miring ke belakang dan juga dikelilingi oleh petikan berganda.

Semua data dalam bahasa C mempunyai jenisnya sendiri. Pembolehubah jenis tertentu menduduki beberapa ruang dalam ingatan, yang berbeza-beza bergantung pada jenis. Dalam C tidak ada penetapan yang jelas tentang jumlah memori kepada jenis tertentu. Ini diberikan kepada pelaksanaan pengkompil khusus untuk platform tertentu. Sebagai contoh, pembolehubah seperti int dalam satu pengkompil ia boleh menduduki 16 bit dalam ingatan, dalam satu lagi - 32 bit, dalam yang ketiga - 8 bit. Segala-galanya ditentukan oleh pengkompil tertentu. Benar, semua orang berusaha untuk universalisasi, dan pada dasarnya dalam kebanyakan penyusun jenisnya int , sebagai contoh, mengambil 2 bait, dan jenis char - satu.

Saya agak bodoh sejak kebelakangan ini, saya tidak ingat berapa banyak bait yang digunakan oleh satu jenis berganda V AVR-GCC. Biasanya, apabila pengawal pengaturcaraan, anda bekerja dengan jenis integer, seperti int Dan char , dan anda tidak sering menggunakan jenis titik terapung kerana penggunaan sumbernya.

Oleh itu, untuk masa hadapan, saya akan meninggalkan diri saya peringatan di sini yang menunjukkan saiz memori yang diduduki oleh jenis data untuk pengkompil AVR-GCC dan julat perubahan dalam pembolehubah jenis ini.

Jenis data dalam bahasa C untuk pengkompil AVR-GCC

Nota

Jenis pelaksanaan berganda AVR-GCC menyimpang daripada standard. Mengikut standard berganda menduduki 64 bit. Dalam AVR-GCC, pembolehubah jenis ini menduduki 32 bit, dan oleh itu, ia bersamaan dengan pembolehubah dengan jenis terapung!

Di samping itu, perpustakaan AVR-GCC memperkenalkan beberapa derivatif jenis standard. Mereka diterangkan dalam fail stdint.h . Ini mungkin dilakukan untuk meningkatkan kejelasan dan mengurangkan teks program (mempercepatkan penulisan mereka :)). Berikut ialah plat pematuhan:

Jenis yang diperoleh daripada yang standard dalam bahasa C untuk pengkompil AVR-GCC

Jenis tidak sah

Terdapat satu lagi jenis dalam bahasa C - jenis batal . batal digunakan untuk menunjukkan bahawa fungsi tidak mengembalikan apa-apa sebagai hasilnya, atau tidak mengambil sebarang parameter sebagai input. Jenis ini tidak digunakan untuk mengisytiharkan pembolehubah, jadi ia tidak mengambil ruang memori.

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.

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 yang paling ketara, dan digit yang tinggal adalah sifar, maka nombor tersebut mempunyai nilai minimum untuk jenis tertentu: untuk char ia ialah -128.

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

Set nilai titik terapung ialah subset nombor nyata, tetapi tidak setiap nombor nyata boleh diwakili dalam bentuk 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:

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 penuding ke penuding.

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. Operator “++” 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;