Dan Deklarasi dalam Pengaturcaraan C ++ - monyet

Sebahagian daripada C ++ untuk Sheet Cheat Sheet

Untuk melakukan perhitungan dalam program C ++, Anda memerlukan ekspresi. Ungkapan adalah pernyataan yang mempunyai nilai dan jenis. Dalam program C ++, pernyataan ialah pernyataan yang mentakrifkan pemboleh ubah atau "tangki induk" untuk nilai semacam seperti nombor atau aksara.

Ungkapan

Ungkapan mengambil salah satu bentuk berikut:

objName // untuk penyusun operator objek mudah // // untuk pengendali unary expr1 pengendali expr2 // untuk expr1 operator binari? expr2: expr3 // untuk operator funcName ternary ([senarai hujah]); // untuk panggilan fungsi

Ungkapan-ungkapan literal

A literal adalah satu bentuk ungkapan berterusan. Pelbagai literals ditakrifkan dalam jadual berikut.

Contoh	Type
1	int
1L	int panjang
1LL	panjang panjang int
1. 0	dwi
1.	char
"1"	char
"1 string"	char * (secara automatik ditamatkan dengan aksara null)
"u8" ini adalah rentetan UTF-8 dengan watak UTF-8: u2018 "	char8_t *
u" ini adalah rentetan UTF-16 dengan aksara UTF-16: u2018 "	char16_t *
U "ini adalah rentetan UTF-32 dengan watak UTF-32:	U00002018"
char32_t * true, false	binary
	Deklarasi
Pengisytiharan menggunakan kedua-dua jenis dan jenis yang ditentukan oleh pengguna. Jenis intrinsik ialah	[] char [] wchar_t [] [] int float [long] double bool

Pernyataan mempunyai salah satu daripada bentuk berikut:

[] [const] type var [= expression]; // variable [] [const] jenis array [size] [= {list}]; // array [const] jenis objek [(argumen senarai)]; // object [const] type object [= {argument list}]; // alternatif [const] jenis * [const] ptr [= ungkapan penunjuk]; / // jenis penunjuk & refName = objek; // jenis rujukan fnName ([senarai hujah]); / function

Kata kunci auto boleh digunakan jika C + + dapat menentukan jenis pembolehubah itu sendiri:

auto var = 1L; // jenis var adalah int panjang

Kata kunci menyatakan mengekstrak jenis ungkapan. Jenis ini kemudiannya boleh digunakan di mana sahaja nama jenis digunakan. Sebagai contoh, contoh berikut menggunakan decltype untuk mengisytiharkan pembolehubah kedua dengan jenis yang sama dengan pembolehubah yang sedia ada:

decltype (var1) var2; / / jenis var2 adalah sama dengan var1

Definisi fungsi mempunyai format berikut:

// fungsi mudah [] taip fnName (senarai argumen) {…} // fungsi anggota ditakrifkan di luar kelas [inline] kelas:: func (senarai argumen) [const] {…} // constructor / destructors juga boleh ditakrifkan di luar kelas Kelas:: Class ([argument list]) {…} } // constructors / destructor boleh dipadam atau mungkir // sebagai pengganti definisi Kelas:: Class ([argumen list]) =; Kelas:: ~ Kelas () =;

Operator berlebihan kelihatan seperti definisi fungsi.Pengendali yang dilebihkan beban boleh ditulis sama ada sebagai anggota atau fungsi mudah. Apabila ditulis sebagai fungsi ahli, * ini adalah argumen pertama yang diandaikan kepada pengendali:

MyClass & operator + (const MyClass & m1, const MyClass & m2); // mudah MyClass & MyClass:: operator + (const MyClass & m2); // anggota;

Pengguna juga boleh menentukan jenis mereka sendiri menggunakan kata kunci kelas atau struct:

ClassName [: [virtual] [public] BaseClass] {: // constructor ClassName ([arg arg]) ClassName () [=;] // destructor [virtual] ~ ClassName () <{…} | [=; > // ahli data awam taip dataMemberName [= initialValue]; // fungsi awam anggota jenis memberFunctionName ([arg list]) [{…}] // fungsi anggota member jenis memberFunctionName ([arg list]) const [{…}] // fungsi anggota maya memberFunctionName jenis maya ([) [{…}]; // fungsi maya murni murni memberFunctionName ([arg list]) = 0; / / fungsi yang mesti menimpa kelas fungsi kelas memberFunctionName ([arg list]) menimpa; / / fungsi yang tidak boleh ditindih dalam subclass memberFunctionName ([arg list]) final;};

Selain itu, pembina dengan hujah tunggal mungkin ditandakan sebagai makna eksplisit bahawa ia tidak akan digunakan dalam penukaran tersirat dari satu jenis ke satu lagi. Menonjolkan pembina sebagai lalai bermaksud "gunakan definisi pembina C ++ lalai". Menyalin pembina sebagai padam membuang definisi pembina C ++ lalai.

C ++ menyokong dua jenis jenis yang disenaraikan. Jenis penghitungan lama berikut tidak mencipta jenis baru:

enum STATE {DC, // mendapat 0 ALABAMA, // mendapat 1 ALASKA, // mendapat 2 ARKANSAS, // mendapat 3 // … dan seterusnya}; int n = ALASKA; // ALASKA adalah jenis int

Secara lalai kemasukan individu adalah jenis int tetapi ini boleh ditukar dalam standard C ++ 2011:

enum ALPHABET: char {A = 'a', // gets 'a' B, // mendapat 'b' C, // mendapat 'c' // … dan sebagainya}; char c = A; // A adalah jenis char

C ++ 2011 yang membolehkan format kedua yang mencipta jenis baru:

// penghitungan berikut mentakrifkan jenis baru STATE enum class STATE {DC, // mendapat 0 ALABAMA, // mendapat 1 ALASKA, // mendapat 2 ARKANSAS, // mendapat 3 // … dan sebagainya}; NEGARA s = NEGERI:: ALASKA; // sekarang NEGERI adalah jenis baru // berikut menggunakan jenis enum yang berlainan jenis ALUMPHONE: char {A = 'a', // mendapat 'a' B, // mendapat 'b' C, // mendapat 'c ' //… dan sebagainya}; ALPHABET c = ALPHABET:: A; // A adalah jenis ALPHABET

Pernyataan template mempunyai format yang sedikit berbeza:

// jenis T disediakan oleh pengatur cara menggunakan jenis template FunctionName ([arg list]) class template ClassName {{…}};