Pemboleh ubah dan Jenis C ++: int, double, char, string, bool

Pemboleh ubah dalam C ++

Pemboleh ubah C ++ memberikan kita keupayaan penyimpanan yang dinamakan. Ini memungkinkan pengaturcara untuk memanipulasi data mengikut keperluan. Setiap pemboleh ubah mempunyai jenis dalam C ++. Jenis pemboleh ubah membantu menentukan ukuran dan susun atur peta memori pemboleh ubah, julat nilai yang dapat disimpan dalam memori itu, dan sekumpulan operasi yang dapat diterapkan padanya.

Dalam tutorial C ++ ini, anda akan belajar:

Pemboleh ubah dalam C ++
Jenis asas Pemboleh ubah dalam C ++
Peraturan Menyatakan Pemboleh ubah dalam C ++
Jenis Data Pembolehubah C ++
Nama Pemboleh ubah atau Pengecam
Kelayakan Const di C ++
Skop Pemboleh ubah dalam C ++
Penukaran Jenis Pembolehubah
Daftar Pemboleh ubah
Urutan melarikan diri

Jenis asas Pemboleh ubah dalam C ++

Berikut adalah jenis asas pemboleh ubah C ++:

Int:

Bilangan bulat adalah literal numerik (berkaitan dengan nombor) tanpa bahagian pecahan atau eksponen. Contohnya. 120, -90, dll.

Berganda:

Ia adalah nilai titik terapung berketepatan dua. Contoh: 11.22, 2.345

Bayaran:

Huruf watak dibuat dengan memasukkan satu watak dalam tanda petikan tunggal. Contohnya: 'a', 'm', 'F', 'P', '}' dll.

Terapung:

Literal titik terapung adalah literal numerik yang mempunyai bentuk pecahan atau bentuk eksponen. Contohnya: 1.3, 2.6

String Literals:

Huruf rentas adalah urutan watak yang dilampirkan dalam tanda petik ganda. Contohnya: "Apa khabar?"

Bool:

Ia menyimpan nilai Boolean benar atau salah.

Peraturan Menyatakan Pemboleh ubah dalam C ++

Berikut adalah beberapa peraturan umum untuk menamakan pemboleh ubah:

Nama pemboleh ubah C ++ hanya boleh mengandungi huruf, nombor, dan garis bawah.
Nama pemboleh ubah C ++ tidak boleh bermula dengan nombor.
Nama pemboleh ubah tidak boleh bermula dengan huruf besar.
Nama pemboleh ubah yang digunakan dalam C ++ tidak boleh menjadi kata kunci. Sebagai contoh, int adalah kata kunci yang digunakan untuk menunjukkan bilangan bulat.
Nama pemboleh ubah C ++ boleh dimulakan dengan garis bawah. Walau bagaimanapun, ia tidak dianggap sebagai amalan yang baik.

Jenis Data Pembolehubah C ++

C ++ mentakrifkan sekumpulan jenis primitif

Yang tidak sah jenis tiada berkaitan nilai dengannya dan boleh digunakan hanya dalam beberapa keadaan. Ia paling biasa sebagai jenis fungsi yang tidak mengembalikan nilai.

Yang jenis aritmetik memasukkan aksara, integer, nilai Boolean, dan nombor titik apung. Jenis aritmetik jika dibahagikan lagi kepada 2 kategori

Jenis titik terapung . Float (atau jenis terapung) mewakili nombor perpuluhan. Piawaian IEEE menentukan bilangan minimum digit penting. Sebilangan besar penyusun biasanya memberikan ketepatan yang lebih tinggi daripada minimum yang ditentukan. Biasanya, pelampung diwakili oleh 32 bit, dua kali ganda dalam 64 bit, dan ganda panjang sama ada 96 atau 128 bit.
Jenis integral (yang merangkumi watak, integer, dan jenis Boolean). The Boolean jenis mempunyai hanya dua jenis nilai: Benar atau Palsu. Terdapat beberapa jenis char , yang kebanyakannya ada untuk menyokong pengantarabangsaan. Jenis watak yang paling asas adalah char. Arang adalah ukuran yang sama dengan bait mesin tunggal yang bermaksud satu bait.

Yang jenis Integral boleh berdaftar atau tidak.

Jenis yang ditandatangani : Mereka mewakili nombor negatif atau positif (termasuk sifar). Dalam jenis bertanda, julat mesti dibahagi sama rata antara nilai + ve dan -ve. Oleh itu, char 8-bit yang ditandatangani akan menyimpan nilai dari -127 hingga 127.

Jenis yang tidak ditandatangani : Dalam jenis yang tidak ditandatangani, semua nilai adalah> = 0. Char yang tidak ditandatangani 8-bit boleh berisi 0 hingga 255 (keduanya termasuk)

Nama Pemboleh ubah atau Pengecam

Pengecam boleh terdiri daripada beberapa huruf, digit, dan watak garis bawah atau beberapa gabungannya. Tiada had yang dikenakan pada panjang nama.

Pengecam mesti

mulakan dengan huruf atau garis bawah ('_').
Dan peka dengan kes; huruf besar dan huruf kecil berbeza:

// mentakrifkan empat pemboleh ubah int yang berbeza

int guru99, gurU99, GuRu99, GURU99;

Bahasa C ++ telah menempah beberapa nama untuk penggunaannya.

Terdapat banyak konvensyen yang diterima untuk menamakan pemboleh ubah dalam bahasa pengaturcaraan yang berbeza. Mengikuti konvensyen ini dapat meningkatkan kebolehbacaan program.

Pengecam harus memberikan sekurang-kurangnya beberapa petunjuk tentang maksudnya.
Nama yang berubah-ubah biasanya huruf kecil-guru99, bukan Guru99 atau GURU99.
Kelas yang kami tentukan biasanya bermula dengan huruf besar.
Pengecam yang mengandungi pelbagai perkataan harus membezakan setiap perkataan secara visual. Contohnya, laman web9999 bukan laman web guru99.

Pernyataan dan Definisi Berubah C ++

Pengisytiharan pemboleh ubah membuat nama diketahui oleh program dalam skop di mana ia ditentukan. Contoh:

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

int a,b;a=b=1000;

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

Kelayakan Const di C ++

Anggaplah ada buffsize pemboleh ubah yang menyatakan jumlah input yang akan diambil dari pengguna. Di sini, kami tidak mahu mengubah nilai ukuran sepanjang program. Kami ingin menentukan pemboleh ubah yang nilainya kita tidak boleh berubah.

Sekiranya demikian, gunakan kata kunci konst

const int bufSize = 512; // input buffer size

Ini mentakrifkan bufSize sebagai pemalar. Sebarang percubaan untuk menyerahkan atau mengubah bufSize akan memberikan ralat.

Di sini, kita tidak dapat mengubah nilai objek const setelah kita membuatnya, ia mesti diisytiharkan dan diinisialisasi. Jika tidak, penyusun melemparkan ralat.

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

Skop Pemboleh ubah dalam C ++

Skop adalah jangka masa program di mana pemboleh ubah mempunyai makna. Sebilangan besar nama yang sama boleh digunakan untuk merujuk kepada entiti yang berlainan dalam ruang lingkup yang berbeza. Pemboleh ubah dapat dilihat dari titik di mana mereka diisytiharkan sehingga akhir skop di mana pernyataan mereka muncul.

#include int main(){int sum = 0;// sum values from 1 through 10 inclusivefor (int val = 1; val <= 10; ++val)sum += val; // equivalent to sum = sum + valcout << "Sum of 1 to 10 inclusive is "<< sum <
Program ini menentukan 3 nama, iaitu, utama, jumlah, dan nilai. Ia menggunakan nama namespace std, bersama dengan dua nama lain dari namespace-cout dan endl.

Nama fungsi "utama" ditakrifkan di luar pendakap keriting. Nama fungsi utama-seperti kebanyakan nama lain yang ditentukan di luar fungsi-mempunyai skop global. Yang bermaksud bahawa setelah dinyatakan, nama-nama yang berada di ruang lingkup global dapat diakses sepanjang program ini.
Jumlah pemboleh ubah ditentukan dalam ruang lingkup blok yang merupakan badan fungsi utama. Ia dapat diakses dari titik perisytiharannya dan seluruh bahagian fungsi utama. Walau bagaimanapun, tidak di luarnya. Ini bermaksud bahawa jumlah pemboleh ubah mempunyai skop blok .
Pemboleh ubah val ditentukan dalam skop "untuk pernyataan". Ia boleh digunakan dengan mudah dalam pernyataan itu tetapi tidak di tempat lain dalam fungsi utama. Ia mempunyai skop tempatan .

Skop Bersarang
Skop boleh mengandungi ruang lingkup lain. Skop yang terkandung (atau bersarang) disebut sebagai ruang lingkup dalaman. Skop yang mengandungi adalah ruang lingkup luar.
#include 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 nameint reused = 42; // reused has global scopeint main(){int unique = 0; // unique has block scope// output #1: uses global reused; prints 42 0cout << reused << " " << unique << endl;int reused = 0; // new, local object named reused hides global reused// output #2: uses local reused; prints 0 0cout << reused << " " << unique << endl;// output #3: explicitly requests the global reused; prints 42 0cout << ::reused << " " << unique << endl;return 0;}
Output # 1 muncul sebelum definisi tempatan digunakan semula. Oleh itu, output ini
pernyataan adalah yang menggunakan nama yang digunakan semula yang ditentukan dalam skop global. Penyataan ini menghasilkan
42 0
Output # 2 berlaku selepas definisi tempatan digunakan semula. Sekarang dalam skop. Oleh itu, pernyataan keluaran kedua ini hanya menggunakan objek tempatan yang dinamakan digunakan semula dan bukan output global
0 0
Output # 3 mengatasi peraturan scoping lalai menggunakan operator skop. Skop global tidak mempunyai nama. Oleh itu, apabila operator skop (: :) mempunyai sebelah kiri kosong. Ini menafsirkannya sebagai permintaan untuk mengambil nama di sebelah kanan ruang lingkup global. Oleh itu, ungkapan itu menggunakan global dan output semula
42 0

Penukaran Jenis Pembolehubah
Pembolehubah satu jenis boleh ditukar menjadi yang lain. Ia dikenali sebagai "Jenis Penukaran." Mari lihat peraturan untuk menukar jenis pemboleh ubah C ++ yang berbeza:
Menetapkan bukan bool ke pemboleh ubah bool menghasilkan palsu jika nilainya 0 dan benar sebaliknya.
bool b = 42; // b is true
Menetapkan bool ke salah satu jenis aritmetik yang lain menghasilkan 1 jika bool itu benar dan 0 jika bool itu salah.
bool b = true;int i = b; // i has value 1
Menetapkan nilai floating-point kepada pemboleh ubah jenis int menghasilkan nilai yang terpotong. Nilai yang disimpan adalah bahagian sebelum titik perpuluhan.
int i = 3.14; // i has value 3
Menetapkan nilai int kepada pemboleh ubah jenis apungan mengakibatkan bahagian pecahan menjadi sifar. Ketepatan biasanya hilang jika bilangan bulat mempunyai lebih banyak bit daripada yang boleh ditampung oleh pemboleh ubah terapung.
Int i=3;double pi = i; // pi has value 3.0
Sekiranya kita cuba memberikan nilai di luar julat kepada pemboleh ubah jenis yang tidak ditandatangani, hasilnya adalah nilai selebihnya% (modulo)
Sebagai contoh, jenis char yang tidak ditandatangani 8-bit dapat menyimpan nilai dari 0 hingga 255, termasuk. Menetapkan nilai di luar julat ini akan menyebabkan pengkompil menetapkan nilai modulo 256 yang selebihnya. Oleh itu, oleh logik di atas, penugasan -1 kepada char 8-bit yang tidak ditandatangani memberikan objek itu nilai 255.
unsigned char c = -1; // assuming 8-bit chars, c has value 255
Sekiranya kita berusaha memberikan nilai di luar jangkauan ke objek jenis bertanda, hasilnya tidak dapat diramalkan. Ia tidak ditentukan. Program mungkin kelihatan berfungsi di luar, atau mungkin terhempas, atau mungkin menghasilkan nilai sampah.
signed char c2 = 256; // assuming 8-bit chars, the value of c2 is undefined
Penyusun menggunakan jenis penukaran yang sama apabila kita menggunakan nilai satu jenis di mana nilai jenis lain diharapkan.
int i = 42;if (i) // condition will evaluate as truei = 0;
Sekiranya nilai ini = 0, maka syaratnya adalah salah; semua nilai lain (bukan sifar) menghasilkan benar. Dengan konsep yang sama, apabila kita menggunakan bool dalam ungkapan aritmetik, nilainya selalu ditukar menjadi 0 atau 1. Akibatnya, menggunakan bool dalam ungkapan aritmetik biasanya hampir tidak betul.
Perhatian: Jangan Campurkan Jenis yang Ditandatangani dan Tidak Ditandatangani
Ungkapan yang mencampurkan ditandatangani dan tidak ditandatangani dapat memberikan hasil yang mengejutkan dan salah apabila nilai yang ditandatangani negatif. Seperti yang dibincangkan di atas, nilai yang ditandatangani diubah secara automatik menjadi tidak ditandatangani.
Contohnya, dalam ungkapan aritmetik seperti
x* y
Sekiranya x adalah -1 dan y adalah 1, dan jika kedua x dan y adalah int, maka nilainya adalah, seperti yang diharapkan, -1.
Sekiranya x adalah int dan y tidak ditandatangani, maka nilai ungkapan ini bergantung pada berapa bit bilangan bulat yang terdapat pada mesin penyusun. Pada mesin kami, ungkapan ini menghasilkan 4294967295.

Daftar Pemboleh ubah
Pemboleh ubah register lebih pantas diakses berbanding pemboleh ubah memori. Jadi, pemboleh ubah yang sering digunakan dalam program C ++ dapat dimasukkan ke dalam daftar menggunakan kata kunci daftar . Kata kunci daftar memberitahu penyusun untuk menyimpan pemboleh ubah yang diberikan dalam daftar. Ini adalah pilihan pengkompil untuk memasukkannya ke dalam daftar atau tidak. Secara amnya, penyusun sendiri melakukan pelbagai pengoptimuman yang merangkumi memasukkan beberapa pemboleh ubah dalam daftar. Tidak ada had bilangan pemboleh ubah daftar dalam program C ++. Tetapi penyusun mungkin tidak menyimpan pemboleh ubah dalam daftar. Ini kerana memori daftar sangat terhad dan biasanya digunakan oleh OS.
Untuk menentukan:
register int i;
Komen
Komen adalah bahagian kod yang diabaikan oleh penyusun. Ini membolehkan pengaturcara membuat catatan di kawasan yang berkaitan dengan kod sumber / program. Komen datang sama ada dalam bentuk blok atau baris tunggal. Komen program adalah pernyataan penjelasan. Ia boleh dimasukkan dalam kod C ++ yang membantu sesiapa sahaja membaca kod sumbernya. Semua bahasa pengaturcaraan membenarkan beberapa bentuk komen. C ++ menyokong komen baris tunggal dan berbilang baris.

Komen baris tunggal adalah komen yang bermula dengan // dan berterusan hingga akhir baris. Sekiranya watak terakhir dalam baris komen adalah \ maka komen akan diteruskan di baris seterusnya.
Komen pelbagai baris adalah komen yang bermula dengan / * dan diakhiri dengan * /.

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

Urutan melarikan diri
Beberapa watak, seperti ruang belakang dan watak kawalan, tidak mempunyai gambar yang dapat dilihat. Watak seperti itu dikenali sebagai watak yang tidak boleh dicetak. Karakter lain (tanda petik tunggal dan berganda, tanda tanya, dan garis miring terbalik) mempunyai makna khas dalam banyak bahasa pengaturcaraan.
Program kami tidak dapat menggunakan watak-watak ini secara langsung. Sebagai gantinya, kita dapat menggunakan urutan pelarian untuk mewakili watak tersebut. Urutan melarikan diri bermula dengan garis miring terbalik.
Bahasa pengaturcaraan C ++ menentukan beberapa urutan pelarian:

Apa yang dilakukannya?

Perwatakan

Baris baru

\ n

Tab menegak

\ v

Tanda Belakang

Perjalanan pulang

\ r

Tab mendatar

\ t

Ruang Belakang

\ b

Tanda soal

Formfeed

\ f

Makluman (loceng)

\ a

Petikan berganda

\ "

Petikan tunggal

\ '

Kami menggunakan urutan pelarian seolah-olah ia adalah satu watak:
cout << '\n'; // prints a newlinecout << "\tguru99!\n"; // prints a tab followed by "guru99!" and a newline
Kita juga boleh menulis urutan pelarian umum \ x diikuti oleh satu atau lebih digit heksadesimal. Atau kita menggunakan \ diikuti oleh satu, atau dua, atau tiga digit oktal. Urutan pelarian umum menunjukkan nilai numerik watak. Beberapa contoh (dengan anggapan set char Latin-1):
\7 (bell) \12 (newline) \40 (blank)\0 (null) \115 ('M') \x4d ('M')
Kita boleh menggunakan urutan pelarian yang telah ditentukan, seperti kita menggunakan watak lain.
cout << "Hi \x4dO\115!\n"; // prints Hi MOM! followed by a newlinecout << '\115' << '\n'; // prints M followed by a newline
Ringkasan

Pemboleh ubah C ++ memberikan kita keupayaan penyimpanan yang dinamakan.
Jenis pemboleh ubah C ++: int, double, char, float, string, bool, dll.
Ruang lingkup yang terkandung (atau bersarang) disebut sebagai ruang lingkup dalam, dan ruang lingkup yang mengandung adalah ruang lingkup luar.
Pembolehubah satu jenis boleh ditukar menjadi yang lain. Ia dikenali sebagai "Jenis Penukaran."
Pemboleh ubah register lebih cepat diakses berbanding pemboleh ubah memori.
Komen adalah bahagian kod yang diabaikan oleh penyusun.
Beberapa watak, seperti ruang belakang dan watak kawalan, tidak mempunyai gambar yang dapat dilihat.