Tuesday, December 24, 2019

Pengenalan Bahasa Pemrograman C++ Lengkap Part 3

Pengenalan Bahasa Pemrograman C++ Lengkap Part 3

Pengenalan Bahasa Pemrograman C++ Lengkap Part 3

Hello sobat, untuk artikel kali ini admin mau share tentang bahasa pemrograman C++ part 3 nih, soalnya yang kemarin kan sudah tuh yang part 1-2 nah skrg giliran part 3 nya hehe.

Penasaran dengan part 1&2? Tenang admin taruh linknya di bawah nih, tinggal klik dan nikmati aja hehe...


  1. Pengenalan Bahasa Pemrograman C++ Part 1

  2. Pengenalan Bahasa Pemrograman C++ Part 2



Oke sudah di baca part 1&2? Kalo sudah lanjut ke part 3, soalnya kalo belum baca part 1&2 gak nyambung nanti(spa tau kan hehe).

F U N G S I

a.1. Definisi Fungsi

Setiap fungsi yang dipanggil didalam program harus didefinisikan. Letaknya dapat dimana saja.

Contoh definisi kuadrat() :

// Prototipe funsi
long kuadrat (long 1);
-------------------------------------
// Definisi fungsi
long kuadrat(long 1)
{
return(1 * 1);
}

Pernyataan return di dalam fungsi digunakan untuk memeberikan nilai balik fungsi. Pada contoh diatas, fungsi kuadrat() memberikan nilai balik berupa nilai kuadrat dari argumen.

Contoh program :

//*------------------------------------------------------------*
//* Contoh 5.1 : Pembuatan fungsi dengan argumen *
//* bertipe long dan nilai balik berupa *
//* long *
//*------------------------------------------------------------*
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
long kuadrat(long1); // prototipe fungsi
void main()
{
clrscr();
for ( long bil = 200; bil < 2000; bil+= 200 )
cout << setw(8) << bil
<< setw(8) << kuadrat(bil) << endl;
}


// Definisi fungsi

long kuadrat(long 1)
{
return( 1 * 1 );
}


a2. Fungsi tanpa Nilai Balik

Adakalanya suatu fungsi tidak perlu memiliki nilai balik. Misalnya fungsi yang hanya dimaksudkan untuk menampilkan suatu keterangan saja.pada funsi seperti ini, tipe nilai balik fungsi yang diperlukan adalah void.]

Contoh :

void tampilkan_judul ()
{
cout << “PT. Aria perkasa Manunggal” << endl;
cout << “Jl. Kertadipura Tenggara 27R” << endl;
cout << “Kudus” << endl;
}

pada contoh funsi diatas, tidak ada pernyataan return, mengingat fungsi tidak memiliki nilai balik. Namaun penggunaan pernyataan return secara eksplisit juga diperkenenkan. Dalam hal ini digunakan berbentuk :

return

saja.

Jadi contoh diatas dapat ditulis :

void tampilkan_judul ()
{
cout << “PT. Aria perkasa Manunggal” << endl;
cout << “Jl. Kertadipura Tenggara 27R” << endl;
cout << “Kudus” << endl;
return;
}

a.3. Lingkup variabel

Lingkup variabel menentukan keberadaan suatu variabel tertentu dalam fungsi. Ada variabel yang hanya dikenal di suatu fungsi dan tidak dikenal pada fungsi lain. Namun ada juga variabel yang dapat diakses oleh semua fungsi.

Variabel Otomatis

Variabel yang didefinisikan di dalam suatu fungsi berlaku sebagai variabel lokal bagi fungsi. Artinya, variabel tersebut hanya dikenal didalam fungsi tempat variabel didefinisikan.

Contoh program :

//*---------------------------------------------------------*
//* Contoh 5.2 : Memperlihatkan efek variabel *
//* otomatis (lokal) *
//*---------------------------------------------------------*
#include < iostream.h>
#include <conio.h>
void alpha(); // Prototipe fungsi
void main()
{
int x = 22; // Variabel lokal pada main()
double y = 2.22;
clrscr();
cout << “ Pada main() : x = “ << x
<< “ y = “ << y << endl;
alpha(); // Panggil fungsi alpha
cout << “Pada main() : x = “ << x
<< “ y = “ << y << endl;
}

// Definisi fungsi alpha()

void alpha()
{
int x = 20; // Variabel lokal pada alpha()
double y = 3.14;
cout << “Pada alpha() : x = “ << x
<< “ y = “ << y << endl;
}

Tampak bahwa perubahan x dan y pada alpha() tidak mempengaruhi variabel bernama sama pada main(). Karena variabel-variabel tersebut bersiafat lokal bagi masing-masing fungsi yag mendefinisikannya. Variabel x dan y pada fungsi alpha() yang disebut sebagai variabel otomatis.

Variabel Eksternal

Variabel eksternal adalah variabel yang didefinisikan diluar fungsi manapun. Variabel ini dikenal juga sebagai variabel global, sebab variabel ini dikenal disemua fungsi.

Contoh program :

//*---------------------------------------------------------------*
//* Contoh 5.3 : Pemakaian Variabel eksternal *
//*--------------------------------------------------------------*
#include <iostream.h>
#include <conio.h>
int oblade = 550; // Variabel eksternal
void tambah(); // Prototipe fungsi
void main()
{
clrscr();
cout << oblade << endl;
tambah();
cout << oblade << endl;
tambah();
cout << oblade << endl;
}
// Definisi fungsi
void tambah ()
{
oblada ++ ; // Variabel eksternal dinaikkan
}

Guna memeperjelas suatu variabel didalam suatu fungsi yang menggunakannya dapat mendeklarasikan (bukan mendefinisikan, karena tidak ada pengalokasian memori) dengan menambahkan kata extern didepan tipa data.

Contoh program :

//*------------------------------------------------------------*
//* Contoh 5.4 : Pemakaian Variabel eksternal *
//* dengan tambahan kata extern *
//*------------------------------------------------------------*
#include <iostream.h>
#include <conio.h>
int oblade = 550; // Variabel eksternal
void tambah(); // Prototipe fungsi
void main()
{
clrscr();
cout << oblade << endl;
tambah();
cout << oblade << endl;
tambah();
cout << oblade << endl;
}
// Definisi fungsi
void tambah ()
{
extern oblade;
oblada ++ ; // Variabel eksternal dinaikkan
}

Variabel Statis

Variabel eksternal maupun otomatis dapat berkedudukan sebagai variabel statis. Suatu variabel statis mempunyai sifat :

- Jika variabel lokal berdiri sebagai variabel satatis, maka :
- Variabel tetap hanya dapat diakses pada fungsi yang mendefinisikannya
- Variabel tidak hilang saat eksekusi fungsi berakhir
- Inisialisasi oleh pemrogram akan dilakukan sekali saja selama program dijalankan.
- Jika variabel eksternal dijadikan sebagai variabel statis,variabel ini dapat diakses oleh semua file yang didefinisikan pada file yang sama dengan variabel eksternal tersebut.

Contoh program :

//*-----------------------------------------------------------*
//* Contoh 5.5 : Menunjukkan efek variabel satatis *
//*-----------------------------------------------------------*
#include<iostream.h>
#include <conio.h>
void saya_ingat(); // Prototipe fungsi
void main()
{
int mana = 50;
clrscr();
saya_ingat();
saya_ingat();
saya_ingat();
cout << “ main() : mana = “ << mana << endl;
}
// Pada fungsi berikut
// mana didefinisikan sebagai variabel statis
void saya_ingat()
{
static int mana = 77; // variabel statis
mana ++; // Naikkan sebesar 1
cout << “ Saya_ingat () : mana = “ << mana << endl;
}

Berdasarkan hasil diatas, terlihat bahwa variabel statis mana pada fungsi saya_ingat () hanya diinisialisasi (bernilai 77) sekali saja. Kemudian setiap kali saya_ingat () dipanggil nilai variabel tersebut dinaikkan sebesar 1.

a.4. Operator Resolusi Lingkup
Pada C++ terdapat operator dua buah tanda titik-dua ( :: ). Operator ini disebut operator resolusi lingkup (scope resolution). Kegunaanya untuk mengakses variabel yang didefinisikan diluar suatu fungsi.

Contoh program :

//*---------------------------------------------------------*
//* Contoh 5.6 : Pemakaian operator resolusi *
//* lingkup ( :: ) *
//*---------------------------------------------------------*
#include < iostream.h>
#include <conio.h>
int x = 50; // Variabel eksternal
void main()
{
double x; // Definisi variabel lokal
clrscr();
x = 5.678901234; // Variabel lokal yang diberi nilai
cout << x << “ “ << ::x << endl;
::x = 77; // Variabel eksternal yang diberi nilai
cout << x << “ “ << ::x << endl;
}


Program diatas mengungkapkan bahwa sekalipun didalam suatu fungsi terdapat variabel yang namanya sama dengan nama variabel eksternal, kedua variabel tersebut tetap bisa diakses.

a.5. Nilai Bawaan Untuk Nilai Fungsi

Salah satu keistimewaan C++ adalah adanya kemampuan untuk menyetel nilai bawaan (default) argumen fungsi. Argumen-argumen yang mempunyai nilai bawaan nantinya dapat tidak disertakan didalam pemanggilan fungsi dan dengan sendirinya C++ akan menggunakan nilai bawaan dari argumen yang tidak disertakan.

Contoh program :

//*--------------------------------------------------------------*
//* Contoh 5.7 : Menggambarkan nilai bawaan dalam *
//* argumen fungsi *
//*--------------------------------------------------------------*
#include <iostream.h>
#include <conio.h>
void tulis_cplus(int jum); // Prototipe fungsi
void main()
{
clrscr();
tulis_cplus(1); // Untuk menuliskan sebuah tulisan C++
}
void tulis_cplus(int jum);
{
for (int i = 0; i < jum; i ++)
cout << “ C++ “ << endl;
cout << “ Seleseai “ << endl;
}

Contoh program :

//*------------------------------------------------------*
//* Contoh 5.8 : Menggambarkan nilai bawaan *
//* Dalam argumen fungsi *
//*----- ---------------------------------------------*
#include <iostream.h>
#include <conio.h>
void tulis_cplus(int jum = 1); // Prototipe fungsi
// Dan menyetel nilai bawaan fungsi
void main()
{
clrscr();
tulis_cplus(); // Argumen tidak perlu disebutkan
}
void tulis_cplus(int jum);
{
for (int i = 0; i < jum; i ++)
cout << “ C++ “ << endl;
cout << “ Seleseai “ << endl;
}

Pada contoh program a.7 dan a.8 mempunyai kesamaan hanya saja pada contoh program a.8 dalam prototipe fungsi nilai bawaannya dikut sertakan sehingga pada saat argumen pemanggilan fungsi tidak perlu di tuliskan lagi.

a.7. Referensi

Referensi digunakan untuk memberikan nama alias dari variabel. Bentuk pendeklarasiannya :

int&ref=nama_variable;

Tanda & mengawali nama referensi.
Setelah pendeklarasian seperti diatas, ref menjadi nama alias dari nama_variabel. Penggubahan nilai terhadap nama_variabel dapat dilakukan melalui nama_variabel itu sendiri atau melalui referensi ref, sebagaimana dapat dilihat pada contoh dibawah ini.

Contoh program :

//*-----------------------------------------------------*
//* Contoh 5.9 : contoh referensi *
//*-----------------------------------------------------*
#include <iostream.h>
#include <conio.h>
void main()
{
int i ;
int &r = 1; // Deklarasi referensi
clrscr();
i =10;
cout << “i = “ << i << endl;
cout << “ r = “ << r << endl;
r = 55;
cout << “i = “ << i << endl;
cout << “ r = “ << r << endl;
}

Tampak bahwa pengubahan nilai terhadap i maupun r memberikan efek sama.
Operator juga bekerja pada suatu variabel maupun referensinya dengan efek yang sama. Sebagai contoh :

//*-----------------------------------------------------*
//* Contoh 5.10 : Operasi penaikan isi variabel*
//* melalui referensi *
//*-----------------------------------------------------*
#include <iostream.h>
#include <conio.h>
void main()
{
int i = 55;
int &r = i; // Referensi
clrscr();
cout << “i = “ << i << “ r = “ << r <<endl;
i ++ ;
cout << “ i = ” << i <<“ r = “ << r << endl;
r ++ ;
cout << “i = “ << i << “ r = “ << r << endl;
}

Operator ++ pada i maupun r akan mengubah nilai keduanya, karena i dan r menyiratkan memori yang sama.

a.8. Inline Function

Inline function dengan cukup menyisipkan kata-kata inline didepan tipe nilai balik fungsi dalam pendefinisian fungsi. Contoh :

inline jumlah (int x, int y)
{
return(x + y);
}

inline function disarankan dipakai pada fungsi yang sering dipanggil dan ukurannya kecil (terdiri satu atau dua pernyataan), terutama jika dilibatkan pada pernyataan pengulangan proses (while, for dan do-while). Misalnya pada bentuk seperti berikut :

for (int i = 1; i < 100; i++)
cout << i << “.” << jumlah (i, 2 * i) << endl;
jika fungsi jumlah () tidak ditulis sebagai inline function, proses tersebut akan menjadi relatif lambat.

Contoh program :
//*---------------------------------------------------------*
//* Contoh 5.11 : Pembuatan fungsi inline *
//*---------------------------------------------------------*
#include <iostream.h>
#include <conio.h>
// Definisi fungsi sebagai inline
inline int jumlah(int x, int y)
{
return(x + y );
}
void main()
{
clrscr();
for (int i = 1; i < 100; i ++ )
cout << i << “ . “ << jumlah(i, 2 * i) << endl;
}

a.9. Function Overloading

Function Overloading atau Overloading terhadap fungsi memungkinkan sebuah fungsi dapat menerima bermacam-macam tipe dan memberikan nilai balik yang bervariasi pula.

Contoh program :

//*-----------------------------------------------*
//* Contoh 5.12 : Contoh overloading *
//* terhadap fungsi *
//*-----------------------------------------------*

#include <iostream.h>
#include <conio.h>
// Prototipe fungsi
int kuadrat (int i);
long kuadrat(long l);
double kuadrat(double d);
void main()
{
cout << kuadrat(2) << endl;
cout << kuadrat(66666) << endl;
cout << kuadrat(1.2) << endl;
}
// Definisi fungsi
int kuadrat (int i)
{
return(i * i);
}
long kuadrat (long l)
{
return(l * l);
}
double kuadrat (double d)
{
return(d * d);
}

Program 5.12 menunjukkan pemanggilan fungsi kuadrat() dengan berbagai bentuk tipe data.

a.10. Rekursi

Fungsi dalam C++ dapat dipakai secara rekursi, artinya suatu fungsi dapat memanggil fungsi yang merupakan dirinya sendiri. Penerapan rekursi diantaranya untuk menghitung nilai :

Xn

Dengan n merupakan bilangan bulat positif. Solusi dari persoalan ini berupa :
Jika n = 1 maka Xn = X
Selain itu : Xn = X * Xn – 1

Contoh program :

//*------------------------------------------------*
//* Contoh 5.13 : Opreasi pangkat secara *
//* rekursi *
//*------------------------------------------------*
# include <iostream.h>
#include <conio.h>
long int pangkat ( int x, int n);
void main()
{
int x, y;
clrscr();
cout << “ Menghitung x ^ y “<< endl;
cout << “ x = “ ;
cin >> x ;
cout << “ y = “ ;
cin >> y ;
cout << x << “ ^ “ << y << endl;
<< pangkat(x, y) << endl;
}
long int pangkat(int x, int n)
{
if (n = = 1 )
return(x);
else
return(x * pangkat(x, n – 1));
}

MENGENAL ARRAY
b.1. Array Dimensi Satu

Gambaran sebuah array ditunjukkan pada Contoh Program b.1. Program ini meminta pemakai untuk memasukkan 5 buah data temperatur dari keyboard. Kelima data tersebut disimpan pada array bernam suhu. Selanjutnya data yang ada pada array tersebut ditampilkan ke layar.

Contoh program :

//*------------------------------------------------*
//* Contoh 6.1 : program menggunakan *
//* array *
//*------------------------------------------------*
#include <iostream.h>
#include <conio.h>
void main()
{
float suhu[5]; // Array dengan elemen 5 bertipe float
clrscr();
// Membaca data dari keyboard dan meletakkan array
cout << “Masukkan 5 buah data suhu” << endl;
for (int i = 0; i < 5; i ++)
{
cout << i + 1 << “ . “;
cin >> suhu[i];
}
// Menampilkan isi array ke layar
cout << “Data suhu yang anda masukkan : “ << endl;
for ( i = 0; i < 5; i ++ )
cout << suhu[i] << endl;
}

Tampak diatas terdapat pernyataan :

- float suhu[5]; menyatakan array suhu dapat menyimpan 5 (lima) buah data bertipe float.
- suhu[i] menyatakan elemen suhu dengan subscript sama dengan i.
- cin >> suhu[i]; : membaca data dari keyboard dan meletakkan ke elemen nomor i pada array suhu.
- cout << suhu[i]; : akan menampilkan elemen bernomor i pada array suhu.

b.2. Array Berdimensi Dua
Array ini dapat digunakan untuk berbagai keperluan. Sebagai gambaran, data kelulusan dari jurusan Teknik Tnformatika, Manajemen Informatika dan Teknik Komputer pada sekolah tinggi Komputer dari tahun 1992 hingga 1995 dapat dinyatakan dengan array berdimensi dua.
Sebelum membahas cara pendefinisian array berdimensi dua, perhatikan tabel berikut :


Jurusan 1992 1993 1994 1995
1. Teknik Informatika 35 45 80 120
2. Manajemen Informatika 100 110 70 101
3. Teknik Komputer 10 15 20 17

Bentuk seperti tabel diatas dapat dituangkan kedalam array berdimensi dua. Pendefinisiannya :

int data_lulus[3][4];

pada pendefiniasian diatas :

3 menyatakan jumlah baris (mewakili jurusan)
4 menyatakan jumlah kolom (mewakili tahun kelulusan)
array berdimensi dua dapat diakses dengan bentuk :


Contoh program :

//*-----------------------------------------------------*
//* Contoh 6.2 : Pemakaian array berdimensi *
//* dua *
//*-----------------------------------------------------*
#include <iostream.h>
#include <conio.h>
void main()
{
int data_lulus[3][4]; // Array berdimensi dua
int tahun, jurusan;
clrscr();
// Memberikan data ke elemen array data_lulus
data_lulus[0][0] = 35; // data TI – 1992
data_lulus[0][1] = 45; // data TI - 1993
data_lulus[0][2] = 90; // data TI - 1994
data_lulus[0][3] = 120; // data TI - 1995
data_lulus[1][0] = 100; // data MI – 1992
data_lulus[1][1] = 110; // data MI - 1993
data_lulus[1][2] = 70; // data MI – 1994
data_lulus[1][3] = 101; // data MI - 1995
data_lulus[2][0] = 10; // data TK – 1992
data_lulus[2][1] = 15; // data TK- 1993
data_lulus[2][2] = 20; // data TK - 1994
data_lulus[2][3] = 17; // data TK – 1995
// Proses untuk memperoleh informasi kelulusan
while (1)
{
cout << “Jurusan ( 0 = TI, 1 = MI, 2 = TK ) : “ ;
cin >> jurusan;
if ((jurusan = = 0 ) || (jurusan = = 1) || (jurusan = = 3))
break; // Keluar dari while
}
while (1)
{
cout << “Tahun ( 1992 – 1995) : “ ;
cin >> tahun;
if (( tahun >= 1992 ) && ( tahun <= 1995 )
{
tahun - = 1992; // Konversi ke 0, 1, 2 atau 3
break; // Keluar dari while
}
}
cout << “Jumlah yang lulus = “
<< data_lulus[jurusan][tahun] << endl;
}

Mula-mula program mengisi data ke array data_lulus. Kemudian program meminta data jurusan dan tahun dari keyboard. Kedua data masukkan dipastikan tidak akan berada diluar jangkauan kedua subscript-nya.

b.3. Array Berdimensi Tiga
Bentuk umum pendefinisian array berdimensi tiga :

Sebagai contoh :

int huruf[2][8][8] ;

merupakan pendefinisian array data_huruf sebagai array berdimensi tiga.


HALAMAN SELANJUTNYA:

iklan banner

Silahkan Berkomentar Sesuai dengan Topik Artikelnya
EmoticonEmoticon