Membuat C++ Inheritance

Bagikan :

Tweet

C ++ adalah sekelompok penambahan kecil untuk C, dengan beberapa tambahan besar. Satu tambahan utama adalah pendekatan berorientasi objek (penambahan lainnya adalah dukungan untuk pemrograman generik, yang kita akan membahas nanti). Sebagai pemrograman berorientasi obyek nama menyarankan, pendekatan ini berkaitan dengan benda-benda. Tentu saja, ini bukan kehidupan nyata benda sendiri. Sebaliknya, benda-benda ini adalah definisi penting dari benda dunia nyata. Kelas adalah koleksi data yang terkait dengan jenis objek tunggal. Kelas tidak hanya mencakup informasi mengenai objek dunia nyata, tetapi juga berfungsi untuk mengakses data, dan kelas memiliki kemampuan untuk mewarisi dari kelas-kelas lain. (Warisan ditutupi dalam pelajaran berikutnya.)
Jika kelas adalah rumah, maka fungsi akan menjadi pintu dan variabel akan menjadi item di dalam rumah. Fungsi biasanya akan menjadi satu-satunya cara untuk memodifikasi variabel dalam struktur ini, dan mereka biasanya satu-satunya cara bahkan untuk mengakses variabel dalam struktur ini. Hal ini mungkin tampak konyol pada awalnya, tetapi gagasan untuk membuat program yang lebih modular - prinsip sendiri disebut "enkapsulasi". Ide utama adalah bahwa dunia luar tidak perlu tahu persis apa data disimpan di dalam kelas - hanya perlu tahu yang berfungsi dapat digunakan untuk mengakses data tersebut. Hal ini memungkinkan implementasi untuk mengubah lebih mudah karena tidak ada yang harus harus bergantung pada hal itu kecuali kelas itu sendiri.
Sintaks untuk kelas ini adalah sederhana. Pertama, Anda menempatkan kata kunci 'kelas' maka nama kelas. Contoh kita akan menggunakan nama komputer. Maka Anda memasang braket terbuka. Sebelum meletakkan variabel yang berbeda, maka perlu untuk menempatkan tingkat pembatasan variabel. Ada tiga tingkat pembatasan. Yang pertama adalah publik, kedua dilindungi, dan yang ketiga pribadi. Untuk saat ini, semua yang perlu Anda ketahui adalah bahwa pembatasan publik memungkinkan setiap bagian dari program, termasuk bagian luar kelas, untuk mengakses fungsi-fungsi dan variabel ditetapkan sebagai publik. Pembatasan dilindungi mencegah fungsi di luar kelas untuk mengakses variabel. Pembatasan pribadi mirip dengan dilindungi (kita akan melihat perbedaannya kemudian ketika kita melihat warisan. Sintaks untuk menyatakan pembatasan akses ini hanyalah pembatasan kata kunci (publik, swasta, dilindungi) dan kemudian titik dua. Akhirnya, Anda menempatkan variabel dan fungsi yang berbeda (Anda biasanya hanya akan menempatkan prototipe fungsi [s]) Anda ingin menjadi bagian dari kelas. Kemudian Anda meletakkan kurung tutup dan koma. Perlu diingat bahwa Anda masih harus mengakhiri prototipe fungsi (s) dengan semi-colon.
Mari kita lihat ini pembatasan akses yang berbeda untuk beberapa saat. Mengapa Anda ingin untuk menyatakan sesuatu yang pribadi, bukan publik? Idenya adalah bahwa beberapa bagian dari kelas dimaksudkan untuk menjadi internal untuk kelas - hanya untuk tujuan menerapkan fitur. Di sisi lain, beberapa bagian dari kelas yang seharusnya tersedia untuk siapa saja yang menggunakan kelas - ini adalah fungsi public class. Pikirkan kelas seolah-olah sebuah alat seperti microwave: bagian umum kelas sesuai dengan bagian-bagian dari microwave yang dapat Anda gunakan pada dasar sehari-hari - keypad, tombol start, dan sebagainya. Di sisi lain, beberapa bagian dari microwave tidak mudah diakses, tetapi mereka tidak kalah penting - itu akan sulit untuk mendapatkan generator microwave. Ini akan sesuai dengan bagian-bagian yang dilindungi atau swasta kelas - hal-hal yang diperlukan untuk kelas untuk fungsi, tetapi bahwa tidak ada yang menggunakan kelas harus perlu tahu tentang. Hal yang besar tentang pemisahan ini adalah bahwa hal itu membuat kelas lebih mudah digunakan (yang ingin menggunakan microwave di mana Anda harus tahu persis cara kerjanya untuk menggunakannya?) Ide utama adalah untuk memisahkan antarmuka Anda gunakan dari cara antarmuka didukung dan dilaksanakan.
Kelas harus selalu mengandung dua fungsi: konstruktor dan destructor. Sintaks untuk mereka sederhana: nama kelas menunjukkan konstruktor, sebuah ~ sebelum nama kelas adalah destructor. Ide dasarnya adalah untuk memiliki constructor menginisialisasi variabel, dan memiliki destructor membersihkan setelah kelas, yang meliputi membebaskan setiap memori yang dialokasikan. Jika ternyata Anda tidak perlu benar-benar melakukan inisialisasi apapun, maka Anda dapat memungkinkan compiler untuk membuat "konstruktor default" untuk Anda. Demikian pula, jika Anda tidak perlu melakukan sesuatu yang istimewa di destructor, compiler dapat menulis untuk Anda juga!
Ketika programmer menyatakan sebuah instance dari kelas, konstruktor akan secara otomatis disebut. Satu-satunya waktu destructor disebut adalah ketika instance dari kelas tidak lagi diperlukan - baik ketika program berakhir, kelas mencapai akhir lingkup, atau ketika memori deallocated menggunakan menghapus (jika Anda tidak mengerti semua itu, jangan khawatir, gagasan utama adalah bahwa destructors selalu disebut ketika kelas tidak lagi digunakan). Perlu diingat bahwa baik konstruktor maupun destructors kembali argumen! Ini berarti Anda tidak ingin (dan tidak dapat) mengembalikan nilai di dalamnya.
Perhatikan bahwa umumnya Anda ingin konstruktor dan destruktor harus dibuat publik sehingga kelas Anda dapat diciptakan! Konstruktor disebut ketika sebuah objek dibuat, tetapi jika konstruktor adalah pribadi, hal itu tidak dapat disebut objek tidak dapat dibangun. Hal ini akan menyebabkan compiler untuk mengeluh. Sintaks untuk mendefinisikan sebuah fungsi yang merupakan anggota dari luar kelas dari definisi kelas yang sebenarnya adalah untuk menempatkan jenis kembali, kemudian dimasukkan nama kelas, dua titik dua, dan kemudian nama fungsi. Ini memberitahu compiler bahwa fungsi adalah anggota dari kelas itu. Sebagai contoh:

#include 

using namespace std;

class Computer // Standard way of defining the class
{
public:
  // This means that all of the functions below this(and any variables)
  //  are accessible to the rest of the program.
  //  NOTE: That is a colon, NOT a semicolon...
  Computer();
  // Constructor
  ~Computer();
  // Destructor
  void setspeed ( int p );
  int readspeed();
protected:
  // This means that all the variables under this, until a new type of
  //  restriction is placed, will only be accessible to other functions in the
  //  class.  NOTE: That is a colon, NOT a semicolon...
  int processorspeed;
};
// Do Not forget the trailing semi-colon

Computer::Computer()
{
  //Constructors can accept arguments, but this one does not
  processorspeed = 0;
}

Computer::~Computer()
{
  //Destructors do not accept arguments
}

void Computer::setspeed ( int p )
{
  // To define a function outside put the name of the class
  //  after the return type and then two colons, and then the name
  //  of the function.
  processorspeed = p;
}
int Computer::readspeed()  
{
  // The two colons simply tell the compiler that the function is part
  //  of the class
  return processorspeed;
}

int main()
{
  Computer compute;  
  // To create an 'instance' of the class, simply treat it like you would
  //  a structure.  (An instance is simply when you create an actual object
  //  from the class, as opposed to having the definition of the class)
  compute.setspeed ( 100 ); 
  // To call functions in the class, you put the name of the instance,
  //  a period, and then the function name.
  cout<< compute.readspeed();
  // See above note.
}

Pengenalan ini jauh dari lengkap dan, demi kesederhanaan, dianjurkan praktek-praktek yang untuk menguji kemampuan anda.

Tag : C, C++