Template C ++
Tujuan :
Mahasiswa dapat menggunakan Warisan Beragam & Bertingkat, Fungsi Teman C ++, Fungsi Virtual C ++, Template C ++, dalam pembuatan program.
Sebagai latihan untuk meningkatkan kemampuan dalam membuat program.
C ++ Kelas / Objek
C ++ adalah bahasa pemrograman berorientasi objek.
Segala sesuatu di C ++ dikaitkan dengan kelas dan objek, bersama dengan atribut dan metodenya. Misalnya: dalam kehidupan nyata, mobil adalah benda. Mobil memiliki atribut, seperti bobot dan warna, serta metode, seperti penggerak dan rem.
Atribut dan metode pada dasarnya adalah variabel dan fungsi yang dimiliki kelas. Ini sering disebut sebagai "anggota kelas".
Modul Praktek Bahasa C++ Shell Marto Sihombing Kelas adalah tipe data yang ditentukan pengguna yang bisa kita gunakan dalam program kita, dan ia bekerja sebagai konstruktor objek, atau "cetak biru" untuk membuat objek.
Buat Kelas
Untuk membuat kelas, gunakan kata kunci kelas:
Contoh
Buat kelas yang disebut "MyClass":
class MyClass {// Kelas publik: // Penentu akses
int myNum; // Atribut (variabel int)
string myString; // Atribut (variabel string) };
Contoh menjelaskan
Kata kunci kelas digunakan untuk membuat kelas yang disebut MyClass.
Kata kunci publik adalah penentu akses, yang menetapkan bahwa anggota (atribut dan metode) kelas dapat diakses dari luar kelas.kita akan mempelajari lebih lanjut tentang penentu akses nanti.
Di dalam kelas, ada variabel integer myNum dan variabel string myString. Ketika variabel dideklarasikan di dalam kelas, mereka disebut atribut.
Terakhir, akhiri definisi kelas dengan titik koma;.
Buat Objek
Dalam C ++, sebuah objek dibuat dari sebuah kelas. Kami telah membuat kelas bernama MyClass, jadi sekarang kami dapat menggunakan ini untuk membuat objek.
Untuk membuat objek MyClass, tentukan nama kelas, diikuti dengan nama objek.
Untuk mengakses atribut kelas (myNum dan myString), gunakan sintaks titik (.) Pada objek:
Contoh
Buat objek bernama "myObj" dan akses atribut:
class MyClass {// Kelas publik: // Penentu akses
int myNum; // Atribut (variabel int)
string myString; // Atribut (variabel string) };
int main () {
MyClass myObj; // Buat objek MyClass // Mengakses atribut dan mengatur nilai myObj.myNum = 15;
myObj.myString = "Beberapa teks";
Modul Praktek Bahasa C++ Shell Marto Sihombing // Cetak nilai atribut
cout << myObj.myNum << "\ n";
cout << myObj.myString;
kembali 0;
}
Banyak Objek
Anda dapat membuat beberapa objek dari satu kelas:
Contoh
// Buat kelas Mobil dengan beberapa atribut Class Car {
publik:
merek tali;
model string;
int tahun;
};
int main () {
// Buat objek Mobil Mobil carObj1;
carObj1.brand = "BMW";
carObj1.model = "X5";
carObj1.year = 1999;
// Buat objek lain dari Mobil Mobil carObj2;
carObj2.brand = "Ford";
carObj2.model = "Mustang";
carObj2.year = 1969;
// Cetak nilai atribut
cout << carObj1.brand << "" << carObj1.model << "" << carObj1.year << "\ n";
cout << carObj2.brand << "" << carObj2.model << "" << carObj2.year << "\ n";
kembali 0;
}
Latihan C ++
Uji Dirikita Dengan Latihan Olahraga:
Buat objek MyClass yang disebut myObj.
;
Mulailah Latihan
Modul Praktek Bahasa C++ Shell Marto Sihombing Metode Kelas
Metode adalah fungsi yang dimiliki kelas.
Ada dua cara untuk mendefinisikan fungsi yang dimiliki kelas:
Di dalam definisi kelas Definisi kelas luar
Pada contoh berikut, kami mendefinisikan sebuah fungsi di dalam kelas, dan kami menamakannya "myMethod".
Catatan:kita mengakses metode sepertikita mengakses atribut; dengan membuat objek kelas dan dengan menggunakan sintaks titik (.):
Inside Example
class MyClass {// Kelas publik: // Penentu akses
void myMethod () {// Metode / fungsi didefinisikan di dalam kelas cout << "Hello World!";
} };
int main () {
MyClass myObj; // Buat objek MyClass
myObj.myMethod (); // Panggil metode tersebut kembali 0;
}
Untuk mendefinisikan fungsi di luar definisi kelas,kita harus mendeklarasikannya di dalam kelas dan kemudian mendefinisikannya di luar kelas. Ini dilakukan dengan menentukan nama kelas, mengikuti scope resolution :: operator, diikuti dengan nama fungsinya:
Contoh Luar
class MyClass {// Kelas publik: // Penentu akses
void myMethod (); // Deklarasi metode / fungsi };
// Definisi metode / fungsi di luar kelas void MyClass :: myMethod () {
cout << "Hello World!";
}
int main () {
MyClass myObj; // Buat objek MyClass
myObj.myMethod (); // Panggil metode tersebut kembali 0;
}
Parameter
Modul Praktek Bahasa C++ Shell Marto Sihombing Anda juga dapat menambahkan parameter:
Contoh
#include <iostream>
menggunakan namespace std;
Class Car { publik:
kecepatan int (int maxSpeed);
};
int Car :: speed (int maxSpeed) { kembalikan maxSpeed;
}
int main () {
Mobil myObj; // Buat objek Mobil
cout << myObj.speed (200); // Panggil metode dengan argumen kembali 0;
}
Konstruktor
Konstruktor dalam C ++ adalah metode khusus yang dipanggil secara otomatis ketika objek kelas dibuat.
Untuk membuat konstruktor, gunakan nama yang sama dengan kelas, diikuti dengan tanda kurung ():
Contoh
class MyClass {// Kelas publik: // Penentu akses MyClass () {// Pembuat cout << "Hello World!";
} };
int main () {
MyClass myObj; // Buat objek MyClass (ini akan memanggil konstruktor) kembali 0;
}
Catatan: Konstruktor memiliki nama yang sama dengan kelas, selalu publik, dan tidak memiliki nilai yang dikembalikan.
Parameter Pembuat
Konstruktor juga dapat mengambil parameter (seperti fungsi biasa), yang dapat berguna untuk menetapkan nilai awal atribut.
Modul Praktek Bahasa C++ Shell Marto Sihombing Kelas berikut memiliki atribut merek, model dan tahun, serta konstruktor dengan parameter berbeda. Di dalam konstruktor, kami menetapkan atribut yang sama dengan parameter konstruktor (merek = x, dll). Saat kita memanggil konstruktor (dengan membuat objek kelas), kita meneruskan parameter ke konstruktor, yang akan menetapkan nilai atribut terkait ke sama:
Mobil (string x, string y, int z) {// Pembuat dengan parameter merek = x;
// Buat objek Mobil dan panggil konstruktor dengan nilai berbeda Car carObj1 ("BMW", "X5", 1999);
Car carObj2 ("Ford", "Mustang", 1969);
// Cetak nilai
cout << carObj1.brand << "" << carObj1.model << "" << carObj1.year << "\ n";
cout << carObj2.brand << "" << carObj2.model << "" << carObj2.year << "\ n";
kembali 0;
}
Sama seperti fungsi, konstruktor juga dapat didefinisikan di luar kelas. Pertama,
deklarasikan konstruktor di dalam kelas, lalu tentukan di luar kelas dengan menentukan nama kelas, diikuti oleh scope resolution :: operator, diikuti dengan nama konstruktor (yang sama dengan kelasnya) :
Contoh
Mobil (string x, string y, int z); // Deklarasi pembuat };
// Definisi pembuat di luar kelas
Mobil :: Mobil (string x, string y, int z) { merek = x;
model = y;
tahun = z;
Modul Praktek Bahasa C++ Shell Marto Sihombing }
int main () {
// Buat objek Mobil dan panggil konstruktor dengan nilai berbeda Car carObj1 ("BMW", "X5", 1999);
Car carObj2 ("Ford", "Mustang", 1969);
// Cetak nilai
cout << carObj1.brand << "" << carObj1.model << "" << carObj1.year << "\ n";
cout << carObj2.brand << "" << carObj2.model << "" << carObj2.year << "\ n";
kembali 0;
}
Access Specifiers
Sekarang,kita sudah cukup familiar dengan kata kunci publik yang muncul di semua contoh kelas kami:
Contoh
class MyClass {// Kelas publik: // Penentu akses // anggota kelas pergi ke sini };
Kata kunci publik adalah penentu akses. Penentu akses menentukan bagaimana anggota (atribut dan metode) kelas dapat diakses. Dalam contoh di atas, anggota bersifat publik - yang berarti mereka dapat diakses dan dimodifikasi dari luar kode.
Namun, bagaimana jika kita ingin anggota menjadi pribadi dan tersembunyi dari dunia luar?
Di C ++, ada tiga penentu akses:
publik - anggota dapat diakses dari luar kelas
private - anggota tidak dapat diakses (atau dilihat) dari luar kelas
dilindungi - anggota tidak dapat diakses dari luar kelas, namun mereka dapat diakses di kelas yang diwariskan.kita akan mempelajari lebih lanjut tentang Warisan nanti.
Dalam contoh berikut, kami menunjukkan perbedaan antara anggota publik dan pribadi:
Contoh
class MyClass {
publik: // Penentu akses publik int x; // Atribut publik
private: // Penentu akses pribadi int y; // Atribut pribadi
};
int main () {
Modul Praktek Bahasa C++ Shell Marto Sihombing MyClass myObj;
myObj.x = 25; // Diizinkan (publik)
myObj.y = 50; // Tidak diperbolehkan (pribadi) kembali 0;
}
Jikakita mencoba mengakses anggota pribadi, kesalahan terjadi:
kesalahan: y bersifat pribadi
Catatan: Dimungkinkan untuk mengakses anggota privat kelas menggunakan metode publik di dalam kelas yang sama. Lihat bab berikutnya (Enkapsulasi) tentang bagaimana melakukan ini.
Tip: Mendeklarasikan atribut kelaskita sebagai privat (sesering mungkin) merupakan praktik yang baik. Ini akan mengurangi kemungkinan dirikita (atau orang lain) untuk mengacaukan kode. Ini juga merupakan bahan utama dari konsep Enkapsulasi, yang akankita pelajari lebih lanjut di bab berikutnya.
Catatan: Secara default, semua anggota kelas bersifat pribadi jikakita tidak menentukan penentu akses:
Contoh
class MyClass { int x; // Atribut pribadi int y; // Atribut pribadi };
Enkapsulasi
Arti dari Enkapsulasi, adalah untuk memastikan bahwa data "sensitif" disembunyikan dari pengguna. Untuk mencapai ini,kita harus mendeklarasikan variabel / atribut kelas sebagai privat (tidak dapat diakses dari luar kelas). Jikakita ingin orang lain membaca atau
mengubah nilai anggota pribadi,kita dapat memberikan metode get dan set publik.
Akses Anggota Pribadi
Untuk mengakses atribut privat, gunakan metode "get" dan "set" publik:
Contoh
#include <iostream>
menggunakan namespace std;
class Karyawan { pribadi:
// Atribut pribadi gaji int;
publik:
// Setter
void setSalary (int s) {
Modul Praktek Bahasa C++ Shell Marto Sihombing gaji = s;
}
// Getter
int getSalary () { gaji kembali;
} };
int main () { MyObj karyawan;
myObj.setSalary (50000);
cout << myObj.getSalary ();
kembali 0;
}
Contoh menjelaskan
Atribut gaji bersifat pribadi, yang memiliki akses terbatas.
Metode setSalary () publik mengambil parameter dan menugaskannya ke atribut gaji (gaji
= s).
Metode getSalary () publik mengembalikan nilai atribut gaji pribadi.
Di dalam main (), kami membuat objek dari kelas Karyawan. Sekarang kita bisa
menggunakan metode setSalary () untuk menyetel nilai atribut privat ke 50000. Kemudian kita memanggil metode getSalary () pada objek untuk mengembalikan nilainya.
Mengapa Enkapsulasi?
Merupakan praktik yang baik untuk mendeklarasikan atribut kelaskita sebagai privat (sesering mungkin). Enkapsulasi memastikan kontrol yang lebih baik atas data Anda, karenakita (atau orang lain) dapat mengubah satu bagian kode tanpa memengaruhi bagian lain
Peningkatan keamanan data Warisan
Dalam C ++, dimungkinkan untuk mewarisi atribut dan metode dari satu kelas ke kelas lainnya. Kami mengelompokkan "konsep warisan" menjadi dua kategori:
kelas turunan (anak) - kelas yang mewarisi dari kelas lain kelas dasar (induk) - kelas yang diwarisi dari
Untuk mewarisi dari kelas, gunakan simbol:.
Dalam contoh di bawah ini, kelas Car (anak) mewarisi atribut dan metode dari kelas Vehicle (induk):
Contoh // Kelas dasar
Modul Praktek Bahasa C++ Shell Marto Sihombing Kendaraan kelas {
publik:
string brand = "Ford";
batal klakson () {
cout << "Tuut, tuut! \ n";
} };
// Kelas turunan
Kelas Mobil: Kendaraan Umum { publik:
model string = "Mustang";
};
int main () { Mobil myCar;
myCar.honk ();
cout << myCar.brand + "" + myCar.model;
kembali 0;
}
Mengapa Dan Kapan Menggunakan "Warisan"?
- Berguna untuk penggunaan kembali kode: menggunakan kembali atribut dan metode kelas yang ada saatkita membuat kelas baru.
Warisan Bertingkat
Kelas juga bisa diturunkan dari satu kelas, yang sudah diturunkan dari kelas lain.
Dalam contoh berikut, MyGrandChild diturunkan dari kelas MyChild (yang diturunkan dari MyClass).
Contoh
// Kelas dasar (induk) class MyClass { publik:
void myFunction () {
cout << "Beberapa konten di kelas induk." ; }
};
// Kelas turunan (anak)
kelas MyChild: public MyClass { };
// Kelas turunan (cucu)
kelas MyGrandChild: public MyChild { };
Modul Praktek Bahasa C++ Shell Marto Sihombing int main () {
MyGrandChild myObj;
myObj.myFunction ();
kembali 0;
}
Warisan Ganda
Sebuah kelas juga bisa diturunkan dari lebih dari satu kelas dasar, menggunakan daftar yang dipisahkan koma:
Contoh // Kelas dasar class MyClass { publik:
void myFunction () {
cout << "Beberapa konten di kelas induk." ; }
};
// Kelas dasar lainnya class MyOtherClass { publik:
void myOtherFunction () {
cout << "Beberapa konten di kelas lain." ; }
};
// Kelas turunan
kelas MyChildClass: publik MyClass, publik MyOtherClass { };
int main () {
MyChildClass myObj;
myObj.myFunction ();
myObj.myOtherFunction ();
kembali 0;
}
Access Specifiers
Anda telah belajar dari bab Access Specifiers bahwa ada tiga penentu yang tersedia di C ++. Sampai saat ini, kami hanya menggunakan public (anggota kelas dapat diakses dari luar kelas) dan private (anggota hanya dapat diakses di dalam kelas). Penentu ketiga, dilindungi, mirip dengan pribadi, tetapi juga dapat diakses di kelas yang diwariskan:
Contoh
Modul Praktek Bahasa C++ Shell Marto Sihombing // Kelas dasar
class Karyawan {
protected: // Penentu akses yang dilindungi gaji int;
};
// Kelas turunan
class Programmer: public Employee { publik:
bonus int;
void setSalary (int s) { gaji = s;
}
int getSalary () { gaji kembali;
} };
int main () {
Programmer myObj;
myObj.setSalary (50000);
myObj.bonus = 15000;
cout << "Gaji:" << myObj.getSalary () << "\ n";
cout << "Bonus:" << myObj.bonus << "\ n";
kembali 0;
}
Polimorfisme
Polimorfisme berarti "banyak bentuk", dan itu terjadi ketika kita memiliki banyak kelas yang terkait satu sama lain melalui pewarisan.
Seperti yang kami tentukan di bab sebelumnya; Pewarisan memungkinkan kita mewarisi atribut dan metode dari kelas lain. Polimorfisme menggunakan metode tersebut untuk melakukan tugas yang berbeda. Ini memungkinkan kami untuk melakukan satu tindakan dengan cara berbeda.
Misalnya, pikirkan kelas dasar yang disebut Animal yang memiliki metode yang disebut animalSound (). Kelas Hewan yang diturunkan dapat berupa Babi, Kucing, Anjing, Burung - Dan mereka juga memiliki penerapan suara hewan sendiri (suara babi, kucing mengeong, dll.):
Contoh // Kelas dasar kelas Hewan { publik:
void animalSound () {
cout << "Binatang itu bersuara \ n";