Dan Deklarasi dalam C ++ Programming - dummies

Bagian dari C ++ untuk Lembar Dosis Cheat

Untuk melakukan perhitungan di program C ++ Anda memerlukan sebuah ekspresi. Ekspresi adalah pernyataan yang memiliki nilai dan tipe. Dalam program C ++, deklarasi adalah pernyataan yang mendefinisikan variabel atau itu adalah "tangki penampung" untuk beberapa jenis nilai seperti angka atau karakter.

Ekspresi

Ekspresi mengambil salah satu dari bentuk berikut ini:

objName // untuk ekspresi operator objek sederhana // untuk operator awam expr1 operator expr2 // untuk operator biner expr1? expr2: expr3 // untuk operator ternary funcName ([daftar argumen]); // untuk panggilan fungsi

Ekspresi harfiah

Sebuah literal adalah bentuk ekspresi konstan. Berbagai jenis literal didefinisikan dalam tabel berikut.

Contoh	Ketik
1	int
1L	int panjang
1LL	int panjang
1. 0	ganda
1.	float
'1'	char
"string"	char * (otomatis diakhiri dengan karakter null)
L "string"	wchar_t * > u8 "ini adalah string UTF-8 dengan karakter UTF-8: u2018"
char8_t *	u "ini adalah string UTF-16 dengan karakter UTF-16: u2018"
char16_t *	U "ini adalah string UTF-32 dengan karakter UTF-32:
U00002018" char32_t *	benar, salah
bool	0b101
biner (C ++ 2014 standar)

Deklarasi

Deklarasi menggunakan jenis intrinsik dan tipe pengguna. Jenis intrinsiknya adalah

[] char [] wchar_t [] [] int float [long] double bool

Deklarasi memiliki salah satu dari bentuk berikut:

[] [const] type var [= expression]; // variable [] [const] type array [size] [= {list}]; // array [const] jenis objek [(daftar argumen)]; // object [const] type object [= {argument list}]; // alternative [const] type * [const] ptr [= pointer expression]; // tipe pointer & refName = object; // reference type fnName ([daftar argumen]); // fungsi

Kata kunci otomatis dapat digunakan jika C ++ dapat menentukan jenis variabel itu sendiri:

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

Kata kunci decltype mengekstrak jenis ekspresi. Jenis ini kemudian bisa digunakan dimanapun nama jenis digunakan. Sebagai contoh, contoh berikut menggunakan decltype untuk mendeklarasikan variabel kedua dengan tipe yang sama dengan variabel yang ada:

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

Definisi fungsi memiliki format berikut:

// fungsi sederhana [] ketik fnName (daftar argumen) {…} // fungsi anggota yang didefinisikan di luar kelas [inline] type Class:: func (daftar argumen) [const] {…} // konstruktor / destruktor juga dapat didefinisikan di luar kelas Kelas:: Kelas ([daftar argumen]) {…} Kelas:: ~ Kelas () {… } // konstruktor / destruktor dapat dihapus atau gagal // sebagai pengganti definisi Kelas:: Class ([daftar argumen]) =; Kelas:: ~ Kelas () =;

Operator yang kelebihan beban terlihat seperti definisi fungsi.Operator yang paling kelebihan muatan dapat ditulis sebagai anggota atau fungsi sederhana. Bila ditulis sebagai fungsi anggota, * inilah argumen pertama yang diasumsikan kepada operator:

MyClass & operator + (const MyClass & m1, const MyClass & m2); // MyClass & MyClass sederhana:: operator + (const MyClass & m2); // member;

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

ClassName [: [virtual] [public] BaseClass] {: // constructor ClassName ([daftar arg]) ClassName () [=;] // destructor [virtual] ~ ClassName () <{…} | [=; > // anggota data publik mengetikkan dataMemberName [= initialValue]; // fungsi anggota publik ketik memberFunctionName ([daftar argumen]) [{…}] // const member function type memberFunctionName ([arg list]) const [{…}] // fungsi anggota virtual tipe anggota virtualFunctionName ([daftar arg]) [{…}]; // fungsi anggota virtual murni tipe anggota virtualFunctionName ([daftar arg]) = 0; // fungsi yang harus mengesampingkan fungsi tipe kelas dasar anggotaFunctionName ([arg list]); // fungsi yang tidak dapat di-override dalam tipe anggota subkelasFunctionName ([arg list]) final;};

Sebagai tambahan, seorang konstruktor dengan satu argumen dapat ditandai sebagai makna eksplisit bahwa ia tidak akan digunakan dalam konversi implisit dari satu jenis ke jenis lainnya. Menandai sebuah konstruktor sebagai default berarti "gunakan definisi konstruktor C ++ default". Menandai sebuah constructor sebagai delete akan menghapus definisi konstruktor C ++ default.

C ++ mendukung dua jenis tipe enumerasi. Jenis pencacahan berikut tidak menciptakan tipe baru:

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

Secara default, entri individu adalah tipe int tapi ini dapat diubah dalam standar C ++ 2011:

enum ALPHABET: char {A = 'a', // gets 'a' B, // dapatkan 'b' C, // dapatkan 'c' // … dan seterusnya}; char c = A; // A adalah tipe char

C ++ 2011 memungkinkan format kedua yang menciptakan tipe baru:

// pencacahan berikut mendefinisikan tipe baru STATE enum class STATE {DC, // mendapat 0 ALABAMA, // dapatkan 1 ALASKA, // dapatkan 2 ARKANSAS, // dapatkan 3 // … dan seterusnya}; NEGARA s = NEGARA:: ALASKA; // now STATE adalah tipe baru // berikut ini menggunakan kelas enum tipe dasar yang berbeda ALPHABET: char {A = 'a', // dapatkan 'a' B, // gets 'b' C, // gets 'c ' //… dan seterusnya}; ALPHABET c = ALPHABET:: A; // A adalah tipe ALPHABET

Deklarasi template memiliki format yang sedikit berbeda:

// tipe T disediakan oleh programmer pada jenis template template FunctionName ([arg list]) className {{…}};