KONSEP MODULARISASI KODE PROGRAM

Konsep Modularisasi Kode Program

Salah satu yang paling penting konsep-konsep pemrograman adalah kemampuan untuk group beberapa baris kode ke dalam sebuah unit yang dapat dimasukan dalam program kami. Yang asli untuk kata ini adalah sub-program. Nama lain meliputi: makro, sub-rutin, prosedur, modul dan fungsi. Kita akan menggunakan istilah fungsi untuk apa mereka di sebut dalam dua bahasa pemrograman yang utama today: C++ dan java. Fungsi-fungsi penting karena membolehakn kita untuk mengambil program besar dan rumit untuk membagi mereka menjadi potongan-potongan kecil diatur. Karena fungsi yang lebih kecil adalah bagian program secara keseluruhan, kami bias berkonsentrasi pada apa yang kita inginkan dan melakukan tes untuk memastikan ia berfungsi dengan baik.
Umumnya fungsi jatuh kedalam dua kategori:
1. Control program
Fungsinya hanya di gunakan untuk membagi dan sub control program . fungsi ini adalah fungsi unik yang di tulis. Lain-lain program dapat menggunaka fungsi serupa bahkan fungsi dengan nama yang sama, tetapi isi dari fungsi hamper selalu sangaat berbeda.
2. Spesifik tugas
Fungsinya dirancang untuk digunakn dengan beberapa program . fungsi ini melakukan tugas tertentu dan dengan itu bias digunakan dalam berbagai program karna program lain juga perlu untuk melakukan tugas tertentu . spesifik tugas fungsi kadang-kadang disebut sebagai blok bangunan . karena mereka sudah di uji dank ode. Kita dapat menggunakannya daenagan keyakinan lebih efisien untuk menulis program yang besar.

Proram utama harus menetapkan adanya fungsi yang di gunakan dalam program ini . tergantung pada bahasa pemrograman, ada cara untuk formal:
1. menentukan fungsi (it’s definisi atau kode akan dijalankan))
2. memanggil fungsi
3. menyatakan fungsi (prototipe adalah sebuah deklarasi untuk kompilator)

Fungsi kontrol program biasanya tidak ke informasi untuk berkomunikasi satu sama lain, tetapi daerah yang umum digunakan untuk menyimpan variabel. Tugas fungsi-fungsi khusus dibangun agar data dapat dikomunikasikan antara memanggil program piece (yang biasanya fungsi lainnya) dan fungsi yang dipanggil. Ini kemampuan untuk berkomunikasi data yang memungkinkan kita untuk membangun suatu tugas fungsi yang dapat digunakan di banyak program. Peraturan untuk bagaimana data yang dikomunikasikan dari dalam dan fungsi sangat bervariasi oleh bahasa pemrograman, namun konsep yang sama. Data item lulus (atau dikomunikasikan) disebut parameter. Dengan demikian, kata: parameter lulus.
Empat pilihan komunikasi data antara lain:
1. tidak ada komunikasi dalam komunikasi tanpa keluar
2. beberapa komunikasi tanpa komunikasi keluar
3. beberapa komunikasi dengan beberapa komunikasi keluar
4. tidak ada komunikasi di luar komunikasi dengan beberapa

Pengenalan Fungsi dalam C + +
Kita akan mempertimbangkan sebuah program sederhana yang dapat digunakan untuk menguji kompilator untuk memastikan bahwa ia telah terinstal dengan benar.
Contoh
//******************************************************
// Filename: Compiler_Test.cpp
// Purpose: Average the ages of two people
// Author: Ken Busbee; © Kenneth Leroy Busbee
// Date: Jan 5, 2009
// Comment: Main idea is to be able to
// debug and run a program on your compiler.
//******************************************************

// Headers and Other Technical Items

#include
using namespace std;

// Function Prototypes

void pause(void);

// Variables

int age1;
int age2;
double answer;

//******************************************************
// main
//******************************************************

int main(void)
{
// Input
cout <: “;
cin >> age1;
cout <: “;
cin >> age2;

// Process
answer = (age1 + age2) / 2.0;

// Output
cout <: “;
cout << answer;

pause();
return 0;
}

//******************************************************
// pause
//******************************************************

void pause(void)
{
cout << "\n\n";
system("PAUSE");
cout << "\n\n";
return;
}

//******************************************************
// End of Program
//******************************************************

Program ini memiliki dua fungsi tersebut, satu dari masing-masing dari kami kategori. Layout teknis fungsi-fungsi yang sama, sekarang kami perbezaan yang membuat dua kategori berdasarkan fungsi yang sedang dilaksanakan.

Fungsi control
Program utama di bagian C + + program khusus fungsi dengan nama pengenal utama. Khusus atau dari keunikan sebagai salah satu fungsi utama adalah bahwa ini adalah tempat program mulai dijalankan dan kode ini di tempat yang biasanya berhenti menjalankan kode. Biasanya pertama fungsi yang ditetapkan dalam sebuah program dan muncul setelah daerah yang digunakan untuk meliputi, teknis lainnya item, deklarasi prototip, listing global konstan dan variabel dan item lainnya pada umumnya diperlukan oleh program. Kode untuk menentukan fungsi utama yang disediakan, namun itu tidak prototyped atau biasa disebut dengan fungsi-fungsi lainnya seperti sebuah program. Dalam contoh sederhana ini, tidak ada program lain fungsi kontrol.

Fungsi control program
Kami sering tidak perlu melakukan tugas tertentu yang dapat digunakan dalam banyak program. Khusus atau dari keunikan sebagai salah satu fungsi utama adalah bahwa ini adalah tempat program mulai dijalankan dan kode ini di tempat yang biasanya berhenti menjalankan kode. Biasanya pertama fungsi yang ditetapkan dalam sebuah program dan muncul setelah daerah yang digunakan untuk meliputi, teknis lainnya item, deklarasi prototip, listing global konstan dan variabel dan item lainnya pada umumnya diperlukan oleh program. Kode untuk menentukan fungsi utama yang disediakan, namun itu tidak prototyped atau biasa disebut dengan fungsi-fungsi lainnya seperti sebuah program. Dalam contoh sederhana ini, tidak ada program lain fungsi kontrol.

Tugas fungsi spesifik
Kami sering tidak perlu melakukan tugas tertentu yang dapat digunakan dalam banyak program. Compile_Test.cpp dalam kode sumber di atas kami memiliki tugas yang digunakan untuk menghentikan pelaksanaan kode sampai hits pengguna yang memasukkan kunci. Fungsi nama adalah: tunda. Fungsi ini tidak berkomunikasi informasi apapun antara panggilan dan fungsi itu sendiri, sehingga penggunaan data tipe void. Umum layout kode yang mendefinisikan sebuah fungsi adalah sebagai berikut:
Contoh
function identifier name( )
{
lines of code;
return ;
}
Tidak ada setengah-setelah titik dua baris pertama. Semi-colons digunakan pada akhir suatu pernyataan dalam C + +, namun tidak di baris pertama ketika mendefinisikan sebuah function. Fungsi yang ada satu set braces () digunakan untuk mengidentifikasi kelompok atau blok pernyataan atau baris kode. Biasanya ada beberapa baris kode di dalam suatu fungsi. Baris kode yang berisi instruksi akhir di semi-colon. Anda dapat mengidentifikasi definisi yang menunda fungsi dalam program contoh di atas? Fungsi yang dimaksud adalah jeda setelah fungsi utama. Meskipun secara teknis tidak diperlukan, sebagian besar program daftar semua fungsi (program kontrol atau tugas spesifik) setelah fungsi utama.
Mari kita mengenali lokasi di mana fungsi jeda disebut. Panggilan fungsi adalah fungsi utama dan di akhir fungsi. Baris seperti:
Contoh
Pause () ;
Bila Anda memanggil fungsi Anda menggunakan identifier nama dan kumpulan tanda kurung. Anda menempatkan item data apapun anda lulus di dalam tanda kurung, dan dalam contoh kita tidak ada. A semi-colon berakhir pernyataan atau baris kode. Setelah program kami dikompilasi dan dijalankan, baris kode pada fungsi utama yang dijalankan dan saat ini untuk mendapat panggilan yang menunda fungsi kontrol dari program berpindah ke jeda dan mulai menjalankan fungsi baris kode di jeda fungsi. Bila dilakukan dengan baris kode, ia akan kembali ke tempat di program yang memanggilnya (dalam contoh kita fungsi utama) dan lanjutkan dengan kode yang berfungsi.
Setelah kita tahu cara untuk menentukan fungsi dan bagaimana cara memanggil fungsi, biasanya kita perlu tahu cara untuk menyatakan suatu fungsi ke compiler (yang disebut prototipe). Karena biasa komputer pemrograman standar industri, biasanya pemrogram daftar fungsi utama pertama dengan fungsi lainnya setelah ditetapkan. Kemudian dalam suatu fungsi utama, kami akan memanggil fungsi. Ketika kami kami mengkonversi kode sumber program yang dijalankan untuk versi yang berjalan di komputer kita, langkah pertama dari proses kompilasi adalah. Compiler program menuntut untuk mengetahui apa yang akan komunikasi antara dua fungsi saat fungsi dipanggil. Akan mengetahui komunikasi (apa yang terjadi di dalam dan keluar sebagai parameter) jika fungsi yang dipanggil telah ditetapkan. Tetapi, kami tidak ada fungsi yang belum ditentukan, yang ditetapkan setelah fungsi utama. Untuk mengatasi masalah ini, kami akan menampilkan sebuah compiler prototipe fungsi dari apa yang akan terlihat seperti (paling tidak komunikasi yang memiliki fungsi), ketika kita menetapkan itu.
Contoh
Void pause (void) ;
Baris kode ini terlihat sama seperti baris pertama kami dengan salah satu fungsi definisi penting selain dari setengah titik dua. Prototip (atau deklarasi untuk compiler dari fungsi komunikasi yang belum ditentukan) ditempatkan di dekat bagian atas program sebelum fungsi utama. Aktivitas konsep: Jika Anda memanggil fungsi sebelum didefinisikan Anda harus prototipe sebelum disebut . Melihat daftar dari tiga hal yang dilakukan bersama-sama dengan salah satu fungsi dalam urutan yang biasa muncul dalam sebuah program, ada cara untuk formal:
1. menyatakan fungsi (prototype adalah sebuah deklarasi untuk komunikasi kompilator)
2. memanggil fungsi
3. menentukan fungsi

TEKNIK MODULARISASI
C + + tidak, secara default, melakukan pekerjaan yang sangat lengkap untuk mendukung data abstak:
1. J kelas mendefinisikan data anggota dari kasus, dan meskipun para anggota yang dinyatakan swasta, mereka cukup terlihat pada header file
2. Klien kode yang instantiates kelas compiles hanya jika compiler memiliki akses ke definisi jenis data anggota. Jika ada perubahan dan definisi ini adalah recompiled, klien kode harus dibawa up-to-date dan juga recompiled .

Sejak antarmuka yang lebih stabil dari implementasi, it pays off untuk membuat klien kode sebagai independen mungkin dari perubahan dalam implementasi rincian.
Mengherankan, kami tidak memerlukan definisi kelas dalam sebuah header file untuk menyatakan sebuah fungsi yang menggunakan kelas, bahkan jika tidak fungsi atau kembali melewati kelas oleh jenis-nilai:
1. Kami dapat selalu menentukan referensi dan pointer ke jenis dengan hanya sebuah deklarasi untuk jenis.
2. Jenis definisi untuk kembali nilai nilai atau parameter yang diperlukan hanya untuk klien bahwa kode panggilan fungsi.
3. Klien Mei baik menggunakan hanya subset dari layanan yang diberikan oleh kepala, sehingga kita tidak ingin beban setiap klien dengan dependensi kompilasi buatan pada jenis definisi klien tidak menggunakan atau membutuhkan.

Jika berikut bahwa dengan hati-hati desain, kami dapat menentukan antarmuka yang terdiri dari fungsi dinyatakan prototip tanpa exposing pernyataan yang sebenarnya dari jenis data yang digunakan.
Aktivitas Informasi Hiding Techniques
Berikut teknik menyediakan sarana untuk tetap besar program unit fisikterpisah, sehingga setiap meminimalkan kebetulan dependensi:
• Menangani-Badan dan abstrak dasar (interface) kelas fisik decouple antarmuka dari implementasi.
• Never # menyertakan file header yang tidak perlu dalam file header, dan selalu menggunakan kelas deklarasi ( “kelas X;”), bukan definisi kelas, kecuali Anda tidak akan mengkompilasi header tanpa mereka.
• Selain itu, menyatakan atau menetapkan hanya kelas Anda butuhkan, dan membiarkan klien anda file header # berisi header tambahan yang diperlukan untuk membuat kode dikompilasi.

Sebuah Contoh:
Standar perpustakaan menyediakan khusus kepala deklarasi yang berisi maju untuk semua template streaming dan standar typedef s, seperti ostream.
Misalnya, dalam operasi berikut output < / / mendapatkan nama “std:: ostream”
3 . . . . .
4 kelas ; / / menyatakan kelas X
5
6 / / Define output X untuk operasi:
7 : ostream & operator < value ( ) ; }
4
5 void Handle : : update ( ) {
6 rep_ – > update ( ) ; }
7 . . . . .

Referensi Counting
Menyalin besar badan mungkin sangat mahal. Acuan yang dihitung solusi transforms normal nilai tugas C + + ke dalam skema yang menggunakan rebinding sederhana daripada anggota-bijaksana menyalin nilai. An pelaksanaan obyek ini dipakai bersama-sama oleh banyak menangani untuk efisiensi, sementara referensi count digunakan untuk melestarikan nilai semantik memori manajemen dan benar.
Sejak pelaksanaan rincian tersembunyi, definisi yang menangani kelas tetap sama dengan dasar-Menangani Badan solusi:
Contoh :
1 class X {
2 public:
3 typedef .. value_type;
4 // X services:
5 value_type get_value () const;
6 void update ();
7 ….
8 // standard construction and destruction:
9 X (); // default constructor
10 X (const X&); // copy constructor
11 X& operator = (const X&); // assignment
12 void swap (X&); // exchange values
13 ~X (); // destructor
14 private:
15 struct Rep * rep_;
16 }; // X

Referensi dihitung menggunakan varian dari Badan Handle-idiom. Kami menambahkan referensi ke count Rep kelas, dengan operasi untuk initialize, pengujian, dan memperbarui referensi count.
Contoh :
1 // .cpp file
2 #include “X.h”
3
4 struct Rep
5 {
6 X::value_type data_; // actual info
7 size_t count_; // reference count
8 //
9 // initialize single-owned item:
10 Rep () : count_(1) { data_= .. }
11 void update (); // omitted here..
12 ….
13 }; // Rep

Yang lupa () fungsi decrements referensi dihitung per satu, dan jika dihitung menjadi nol (0) menghancurkan objek. Kami dapat menetapkan fungsi sebagai inline tanpa masalah.
Selain itu, own_copy () fungsi inspects referensi hitungan untuk menentukan apakah objek ini dipakai bersama-sama > 1) atau tidak (count_ == 1); jika objek ini dipakai bersama-sama, fungsi kembali salinan yang baru ini hanya memiliki satu pemilik :
Contoh :
1 inline void forget (Rep*& rep) {
2 if (–rep->count_== 0)
3 delete rep;
4 rep = 0;
5 } // forget
6
7 inline void own_copy (Rep*& rep) {
8 if (rep->count_== 1) return;
9 Rep * copy = new Rep (*rep);
10 –rep->count_; // break old binding
11 rep = copy;
12 } // own_copy

Yang menangani kelas investigates dan memperbarui referensi count untukmengelola memori dalam standar konstruksi dan pemusnahan operasi:
Contoh :
1 ….
2 X::X () : rep_(0) {
3 rep_= new Rep); }
4
5 X::X (const X& rhs) : rep_(rhs.rep_) {
6 ++rep_->count_; }
7
8 X& X::operator = (const X& rhs) {
9 // self check is not needed:
10 ++rhs.rep_->count_; // don’t change the order
11 forget (rep_); // of these statements!
12 rep_= rhs.rep_;
13 return *this; }
14
15 void X::swap (X& rhs) {
16 Rep * tmp = rhs.rep_;
17 rhs.rep_= rep_;
18 rep_= tmp; }
19
20 X::~X () {
21 forget (rep_); }

Namun, bila menangani memperbaharui abstrak negara, kita harus berhati-hati untuk menjaga nilai yang benar semantik dari perwakilan. Ketika ada operasi memodifikasi bersama tubuh objek, maka harus terlebih dahulu memutuskan mengikat dan membuat salinan sendiri. Strategi ini disebut malas menyalin.
Contoh :
1 ….
2 X::value_type X::get_value () const {
3 return rep_->data_; } // OK to use as such
4
5 void X::update () {
6 // must first ensure sole ownership:
7 own_copy (rep_);
8 rep_->update (); }
9 ….

Tunggal Desain Pola
Pada prinsipnya, kita harus menghindari menggunakan global benda. Setiap berbagi data Mei ntena membeberkan data perwakilan sehingga melanggar encapsulation dan menyembunyikan informasi. Global juga dapat membuat objek yang tidak diinginkan dependensi antara differents bagian dari program, dan mungkin justru nanti menimbulkan masalah dengan pemeliharaan sistem. Akibatnya, objek global umumnya harus dianggap sebagai gangguan.
Namun, beberapa subsystems Mei alam oleh mereka dan memberikan akses ke beberapa sumber daya bersama, penyimpanan mereka dan saat ini melayani beberapa klien. Kita harus dikontrol kemudian memberikan akses ke layanan.
Misalnya, pertimbangkan hal berikut hipotesis printer renang sistem (sinkronisasi masalah tidak dibahas di sini):
Contoh :
1 class PrinterPool {
2 public:
3 // define printer services:
4 void enterJob (PrintJob *);
5 ….
6 // provide common access point:
7 static PrinterPool& instance ();
8 private:
9 PrinterPool (); // but restrict creation
10 }; // PrinterPool
11
12 ….
13 // request services from the printer:
14 PrinterPool::instance().enterJob (new FilePrint (“out.txt”));
15 ….

Selain itu, kita harus memastikan bahwa semua struktur data yang benar diinisialisasi. Ini dapat bermasalah di C + +, karena C + + tidak menetapkan urutan yang constructors untuk objek global yang disebut di terjemahan unit. Contoh The () fungsi menggunakan teknik disebut lazy initialization; nilai itu kembali tidak dibuat dan disimpan sampai pertama diakses. Hal ini akan memastikan bahwa (1) objek yang diinisialisasi sebelum digunakan, dan (2) ini dibuat hanya sekali:
Contoh :
1 // PrinterPool.cpp
2….
3 namespace { // unnamed for private objects
4 PrinterPool * PrintPoolInstance_; // zero (0) by default
5 }
6 ….
7 PrinterPool& PrinterPool::instance () {
8 if (PrintPoolInstance_== 0)
9 PrintPoolInstance_= new PrinterPool;
10 return *PrintPoolInstance_;
11 } // instance

Dasar solusi ini memiliki struktur biasa, dan kami dapat, sebagai contoh, menulis sebagai template umum. Disini kita juga harus menyertakan definisi untuk tersembunyi pointer variabel. Hal ini ditetapkan bersama-sama dengan kelas sebagai template statis anggota:
Contoh :
1 template
2 class Singleton {
3 public:
4 static T& instance ();
5 protected:
6 static T * instance_; // declaration
7 }; // Singleton
8
9 template
10 T * Singleton::instance_; // definition
11
12 template
13 T& Singleton ::instance () {
14 if (instance_== 0)
15 instance_= new T;
16 return *instance_;
17 } // instance

sumber :https://bagiwawasan.wordpress.com/2010/05/04/konsep-dan-tehnik-modularisasi-pada-c/