BAB
11.
Namespace
dan Direktif Praprosesor
11.1 Pengantar
Konsep namespace merupakan fitur penting pada C++. Kebutuhan fitur ini
dirasakan setelah tahun 1990 ketika C++ telah cukup populer dan sejumlah
organisasi mulai menawarkan program-program yang dapat didaur-ulang. Telah
diduga akan terjadi permasalahan benturan atau tubrukan nama ketika satu
program dibeli dari satu vendor dan program lain dibeli dari vendor lain.
Benturan nama terjadi ketika nama sama dipakai untuk variabel yang berbeda.
Permasalahan yang sama juga bisa terjadi ketika sejumlah programer terlibat
dalam pengembangan program besar. Pada kasus itu, adalah sangat mungkin bahwa
nama sama akan dipakai untuk variabel, konstanta, atau fungsi yang berbeda.
Solusi dari permasalahan ini adalah: (i) mengubah nama-nama sama tersebut atau
(ii) menyekat nama-nama di dalam namespace-namespace yang berbeda. Opsi pertama
merupakan pekerjaan yang melelahkan. Opsi kedua melibatkan penempatan nama-nama
di dalam namespace-namespace yang berbeda. Konsep namespace diintroduksi di
dalam C++ pada tahun 1995.
Untuk mengilustrasikan konsep ini, dimisalkan bahwa terdapat beberapa
keranjang buah yang memuat nama-nama buah yang sama. Katakanlah, semua
keranjang buah memuat buah apel. Jika Anda mengatakan apel, itu berarti bisa
mengacu pada apel yang dimuat di keranjang mana saja. Namun, jika Anda menomori
atau memberikan nama pada tiap keranjang, katakanlah, keranjang1, keranjang2, keranjang3, dan seterusnya, maka Anda
dapat lebih mudah membedakan apel-apel yang ada di keranjang1 dari apel-apel yang ada di keranjang3, dan seterusnya.
Dalam C++, kode yang diperlukan adalah:
keranjang1 :: apel; //ini
mengacu ke apel-epel di dalam keranjang1
keranjang1 :: apel;
//ini mengacu ke apel-epel di dalam
keranjang3
Pada dua atau lebih subprogram, jika apel
adalah nama sama untuk variabel-variabel yang berbeda dan keranjang1, keranjang2,
dan keranjang3 adalah nama-nama dari
namespace yang dideklarasikan di dalam program, maka setiap variabel yang
berbeda itu (meski memiliki nama sama) dapat dengan mudah diidentifikasi dengan
bantuan operator resolusi skop dan pengenal (nama) namespace.
11.2 Aplikasi
Namespace
Anda pertama-tama perlu mendeklarasikan namespace pada skop file untuk
sebuah program atau subprogram. Ini sama dengan memberikan nama untuk tiap
keranjang, seperti yang telah didiskusikan sebelumnya. Namespace dapat
dideklarasikan sebagai berikut:
namespace NS1 {deklarasi_variabel;}
Kata pertama adalah katakunci namespace,
yang diikuti dengan pengenal NS1,
yang kemudian diikuti oleh kurung kurawal {} dimana di dalamnya nama dari
sejumlah variabel dideklarasikan. Untuk memanggil variabel di dalam program,
Anda perlu menggunakan operator resolusi skop seperti yang telah diberikan pada
kasus apel dan keranjang.
Program berikut mengilustrasikan konsep ini. Anda mendeklarasikan beberapa
variabel di dalam namespace S1. Nama-nama sama akan dipakai untuk
variabel-variabel yang berbeda di dalam namespace lain, S2. Kompiler dapat
mengidentifikasi nama-nama mana yang ada di dalam namespace tertentu. Kapanpun
Anda menggunakan variabel tertentu, Anda perlu lebih dahulu menuliskan pengenal
namespace yang diikuti dengan operator resolusi skop (::) dan kemudian nama
variabel.
|
Program 11.1 Mengilustrasikan
aplikasi dari namespace
|
|
|
|
#include <iostream>
using namespace std;
namespace S1 // name namespace S1
{
int
a = 8; //variabel int yang
didefinisikan di dalam namespace S1.
char
ch = 'X';
double
b = 10.5; //variabel double yang
didefinisikan di dalam namespace S1.
char
E[] = "John";
}
namespace S2
{
double
a = 5.4; //'a' sekarang double
di dalam namespace S2
char
ch = 'Y'; //ch sekarang 'Y' di
dalam namespace S2
int
E = 5; //E sekarang int, sebelumnya string di dalam namespace S1
char
b[] = "Kristof"; //b
sekarang string, sebelumnya double di dalam namespace S1
}
void main ()
{
double
A = S1::a * S2::a; //resolusi skopr
mengidentifikasi
//apakah a milik
dari S1 atau S2
double
B = S1:: b + S2::E ;
cout<<"A =
"<<A<<", "<<"B =
"<<B<< endl;
cout<<S1::ch<<", "<<S2::ch<<endl;
cout<<S1::E<<"
"<<S2::b<< endl;
}
|
|
KELUARAN
|
|
|
A = 43.2, B =
15.5
X, Y
John Kristof
|
|
Anda telah sering menggunakan deklarasi using namespace std; untuk
menyederhanakan penulisan std::cout
menjadi hanya cout, dan lain
sebagainya. File-file header dan fungsi-fungsi dituliskan di dalam namespace std.
11.3 Direktif
using dan using namespace
Pada program sebelumnya, Anda telah menggunakan operator resolusi skop
(::) yang diawali dengan pengenal namespace untuk mengakses variabel yang
diinginkan. Ini bisa juga dilakukan dengan menggunakan katakunci using yang diikuti dengan pengenal
namespace dan operator resolusi skop untuk mengakses variabel atau fungsi. Jika
beberapa nama yang dideklarasikan di dalam suatu namespace akan digunakan pada
bagian tertentu di dalam program, Anda bisa menggunakan direktif berikut:
using
namespace pengenal_namespace;
Program berikut mengilustrasikan hal tersebut.
|
Program 11.2 Mengilustrasikan
aplikasi dari penggunaan direktif using
|
|
|
|
#include <iostream>
using namespace std;
namespace boneka //boneka adalah pengenal untuk namespace
{
int
a = 8;
char
E[] = "John";
}
namespace bola //bola adalah pengenal untuk
namespace
{
double
b = 4.5;
char
E[] = "Pergi ke sekolah!";
}
void main ()
{
using
namespace boneka; //aplikasi dari
direktif using
cout<<a*a<< endl; //sekarang operasi resolusi skop tidak
diperlukan
//untuk
variabel-variabel dari namespace boneka, tetapi
//diperlukan untuk variabel-variabel dari namespace bola
cout<<E<<"
"<<bola::E<<endl;
//menggunakan operator resolusi skop untuk
E
}
|
|
KELUARAN
|
|
|
64
John Pergi ke sekolah!
|
|
Program berikut mengilustrasikan aplikasi dari katakunci using untuk nama dari satu variabel.
|
Program 11.3 Mengilustrasikan
aplikasi dari penggunaan katakunci using
|
|
|
|
#include <iostream>
using namespace std;
namespace NS1
{
int
n = 3;
float
m = 2.5;
}
namespace NS2
{
float
n = 4.0;
int
m = 2;
}
namespace NS1
{
int k = 2;
double R = n*m*k;
}
namespace NS2
{
double
k = 3.0 ;
double
R = n*m*k;
}
int main()
{
using
NS1::R; //aplikasi dari using
cout<<"R dari NS1 =
"<<R<<endl;
using
NS1::k; //aplikasi dari using
cout<<"k dari NS1 =
"<<k<< endl;
cout<<"m dari NS2 =
"<<NS2::m<< endl;
using
NS1::m; //aplikasi dari using
cout<<"m dari NS1 =
"<<m<<endl;
cout<<"R dari NS2 =
"<<NS2::R<< endl;
return
0 ;
}
|
|
KELUARAN
|
|
|
R dari NS1 = 15
k dari NS1 = 2
m dari NS2 = 2
m dari NS1 =
2.5
R dari NS2 = 24
|
|
11.4 Nama Alias
dari Namespace
Nama alias (samaran atau pengganti) untuk pengenal namespace dapat
digunakan kapanpun hal itu diperlukan. Dengan nama yang lebih pendek, ada
kemungkinan terjadi benturan penamaan. Jadi, adalah lebih baik untuk memilih
nama panjang untuk pengenal namespace dan kemudian mendeklarasikan nama pendek
sebagai nama aliasnya. Ini diilustrasikan pada program berikut.
|
Program 11.4 Mengilustrasikan penggunaan alias untuk namespace
|
|
|
|
#include <iostream>
using namespace std;
namespace
namespace_programKu
{
int
n = 3;
float
m = 2.5;
int
k = 2;
double
R = n*m*k;
}
namespace namespaceKu
{
float
n = 4.0;
int
m = 2 ;
double
k = 3.0 ;
double
R = n*m*k;
}
int main()
{
namespace NS1= namespace_programKu ;
//NS1 adalah alias untuk
namespace_programKu
namespace NS2 = namespaceKu ; // NS2
adalah alias untuk namespaceKu
cout<<"R di dalam namespace_programKu =
"<<NS1::R<<", \tn di dalam NS1 =
"<<NS1::n<<endl;
cout<<"R di dalam namespaceKu =
"<<NS2::R<<", \tn di dalam NS2 = "<<NS2::n
<<endl;
cout<<"m di dalam namespace_programKu =
"<<NS1::m<<", \tm di dalam NS2 =
"<<NS2::m<<endl;
return
0 ;
}
|
|
KELUARAN
|
|
|
R di dalam
namespace_programKu = 15, n di dalam
NS1 = 3
R di dalam
namespaceKu = 24, n di dalam NS2 = 4
m di dalam
namespace_programKu = 2.5, m di dalam
NS2 = 2
|
|
Program berikut juga contoh lain dari alias untuk namespace.
|
Program 11.5 Mengilustrasikan penggunaan lain dari alias untuk namespace
|
|
|
|
#include <iostream>
using namespace std;
namespace NS1
{
int
n = 3;
float
m = 2.5;
}
namespace NS2
{
float
n = 4.0;
int
m = 2 ;
}
namespace NS1
{
int
k = 2;
double
R = n*m*k;
}
namespace NS2
{
double
k = 3.0;
double
R = n*m*k;
}
namespace ruangKu = NS1;
namespace Ruang = NS2;
int main()
{
cout<<"R dari ruangKu =
"<<ruangKu:: R<<endl;
cout<<"k dari ruangKu =
"<<ruangKu::k<<endl;
cout<<"k dari namespace NS2 =
"<<NS2::k<<endl;
cout<<"m dari Ruang =
"<<Ruang::m<<endl;
cout<<"m dari ruangKu =
"<<ruangKu::m<<endl;
cout<<"R dari Ruang =
"<<Ruang::R<<endl;
return 0 ;
}
|
|
KELUARAN
|
|
|
R dari ruangKu
= 15
k dari ruangKu
= 2
k dari
namespace NS2 = 3
m dari Ruang =
2
m dari ruangKu
= 2.5
R dari Ruang =
24
|
|
11.5 Perluasan
Namespace
Namespace dapat diperluas atau dikembangkan di bagian-bagian tertentu di
dalam program yang sama atau di dalam beberapa file yang berbeda. Program
berikut merupakan ilustrasi dari perluasan atau pengembangan namespace di dalam
program yang sama.
|
Program 11.6 Mengilustrasikan pengembangan atau perluasan namespace
|
|
|
|
#include <iostream>
using namespace std;
namespace NS1
{
int
n = 3;
float
m = 2.5;
}
namespace NS2
{
float
n = 4.0;
int
m = 2 ;
}
namespace NS1
//menggunakan NS1 kembali
{
int
k = 2;
double
R = n*m*k;
}
namespace NS2
//menggunakan NS2 kembali
{
double
k = 3.0 ;
double
R = n*m*k;
}
int main()
{
cout<<"R dari NS1 =
"<<NS1:: R<<endl;
cout<<"k dari NS1 =
"<<NS1::k<< endl;
cout<<"m dari NS2 =
"<<NS2::m<< endl;
cout<<"m dari NS1 =
"<< NS1 ::m<<endl;
cout<<"R dari NS2 =
"<<NS2::R<<endl;
return
0 ;
}
|
|
KELUARAN
|
|
|
R dari NS1 = 15
k dari NS1 = 2
m dari NS2 = 2
m dari NS1 =
2.5
R dari NS2 = 24
|
|
11.6 Namespace
Bersarang
Namespace bisa bersarang di dalam namespace lain. Sebagai contoh, berikut
adalah ilustrasi dari namespace bersarang:
namespace NS1
{
namespace NS2 //namespace
NS2 dideklarasikan di dalam NS1
{
int x = 2;
}
}
Dengan deklarasi tersebut, variabel x diakses dengan:
NS1::NS2::x;
Program berikut mengilustrasikan namespace bersarang.
|
Program 11.7 Mengilustrasikan namespace bersarang
|
|
|
|
#include <iostream>
using namespace std;
namespace NS1
{
int
n = 3;
float
m = 2.5;
namespace
NS2 // NS2 dideklarasikan di dalam NS1
{
float
n = 4.0;
int
m = 2;
}
}
namespace NS3
{
int
k = 2;
double
R = NS1::NS2::n * NS1::m * NS3::k; //menggunakan
variabel-variabel dari
//namespace-namespace
berbeda
namespace
NS4 //NS4 dideklarasikan di dalam NS3
{
double
k = 3.0;
}
}
int main()
{
cout<<"R dari NS1 =
"<<NS3::R<<endl;
cout<<"k dari NS4 =
"<<NS3::NS4::k<<endl;
cout<<"m dari NS2 =
"<<NS1::NS2::m<<endl;
cout<<"m dari NS1 =
"<<NS1::m<<endl;
return
0 ;
}
|
|
KELUARAN
|
|
|
R dari NS1 = 20
k dari NS4 = 3
m dari NS2 = 2
m dari NS1 =
2.5
|
|
11.7 namespace
std
Sejumlah file header dan nama di dalam C++ sekarang dideklarasikan di
bawah namespace std. Seperti
didiskusikan sebelumnya, namespace, secara umum, dapat dimodifikasi dengan
deklarasi-deklarasi dan definisi-definisi tambahan, namun, ini tidak berlaku
untuk namespace std. Anda perlu
mengingat bahwa namespace std tidak dapat dimodifikasi. Sesuai dengan konvensi,
file header ditulis dengan ekstensi (.h) seperti <iostream.h>. Sekarang, di bawah namespace std, file header yang sama ditulis dengan <iostream>, namun Anda perlu
mencantumkan using namespace std; di
dalam program di atas main().
File header standar C yang sebelumnya dituliskan dengan ekstensi (.h)
seperti <xxxx.h> sekarang
ditulis dengan <cxxxx> di
bawah namespace std. Ekstensi h
diabaikan dan c ditambahkan di depan nama header file. Sebagai contoh, nama <assert.h> sekarang dituliskan sebagai
<cassert>. Kompiler mendukung
kedua konvensi ini. Contoh-contoh lain diberikan berikut ini.
TABEL 11.1 Sejumlah file header yang perlu Anda ketahui
|
Nama sebelumnya
|
Nama di bawah
namespace std
|
|
Sejumlah file header
C++
|
|
|
<algorithm.h>
|
<algorithm>
|
|
<bitset.h>
|
<bitset>
|
|
<iomanip.h>
|
<iomanip>
|
|
<set.h>
|
<set>
|
|
Sejumlah file header
ANSI C
|
|
|
<assert.h>
|
<cassert>
|
|
<float.h>
|
<cfloat>
|
|
<limits.h>
|
<climit>
|
|
<math.h>
|
<cmath>
|
|
<stdio.h>
|
<cstdio>
|
|
<stdlib.h>
|
<cstdlib>
|
|
<time.h>
|
<ctime>
|
11.8 Direktif
Praprosesor
Ada sejumlah direktif praprosesor yang diwarisi C++ dari C. Direktif ini
dapat dipakai untuk mendefinisikan konstanta simbolis, makro, dan direktif
kondisional. Anda telah mengetahui #include
dan #define. Sejumlah direktif
praprosesor diberikan pada Tabel 11.2. Semua direktif praprosesor diawali
dengan simbol #.
TABEL 11.2 Sejumlah direktif praprosesor
|
Direktif
praprosesor
|
Penjelasan
|
|
#
|
direktif null.
|
|
#define
|
Dipakai untuk mendefinisikan konstanta simbolis atau
makro.
|
|
##
|
Dipakai dengan #define, untuk menggabungkan dua item.
|
|
#error
|
Menghentikan kompilasi dan menampilkan pesan error.
|
|
#include
|
Mencantumkan nama file di dalam kurung siku <> atau
di dalam kutip ganda “” pada kode sumber. Anda telah menggunakan direktif ini
di semua program.
|
|
#line
|
Dipakai untuk
menetapkan nomor baris pada sebuah file. Dikode sebaga
#line
nomor_baris<“nama_file”>.
|
|
#pragma
|
Direktif sepesifik untuk implementasi.
|
|
#undef
|
Menggagalkan apa yang sebelumnya didefinisikan.
|
DIREKTIF #define
Direktif praprosesor #define
dipakai untuk menciptakan makro dan konstanta simbolis. Penggunaan direktif #define diilustrasikan sebagai berikut:
#define Pi 3.14159
Perhatikan bahwa tidak ada semikolon (titik-koma) di akhir baris dan
terdapat satu spasi antara define
dan Pi dan antara Pi dan nilai 3.14159. Di dalam program yang menggunakan kode
tersebut, di mana pun Pi digunakan, nilai 3.14159 akan disubstitusi. Pada
dasarnya, deklarasi tersebut ekivalen dengan statemen berikut:
const double Pi = 3.14159 ;
Makro dapat pula diciptakan dengan #define.
Sebagai contoh, lihat kode berikut:
Pada deklarasi tersebut, direktif #define
menciptakan sebuah makro, yaitu sebuah fungsi untuk mendapatkan nilai maks dari
dua nilai. Nilai-nilai dapat berupa nilai integar atau nilai titik-mengambang,
atau karakter. Tidak ada pemeriksaan tipe. Perhatikan bahwa pada definisi tidak
ada spasi antara maks dan kurung kiri ‘(‘. Hal ini diilustrasikan pada program
berikut.
|
Program 11.8 Mengilustrasikan diretif praprosesor #define
|
|
|
|
#include<iostream>
using namespace std;
#define maks(x,y) (x >y ? x : y) //definisi makro
int main()
{
float
x,y;
char
ch, kh;
int
A, B;
cout<<"Masukkan dua nilai
integer: "; cin>>A>>B;
cout<<"Masukkan dua nilai titik
mengambang: "; cin>>x>>y;
cout<<"Masukkan dua karakter:
"; cin>>ch>>kh;
cout<<"Terbesar dari dua int =
"<<maks(A, B)<< endl;
cout<<"Terbesar dari dua float
= "<<maks(x, y)<<endl;
cout<<"Terbesar dari dua char =
"<<maks(ch, kh)<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Masukkan dua
nilai integer: 35 65
Masukkan dua
nilai titik mengambang: 45.65 54.66
Masukkan dua
karakter: v f
Terbesar dari
dua int = 65
Terbesar dari
dua float = 54.66
Terbesar dari
dua char = v
|
|
Program berikut merupakan ilustrasi lain dari pendefinisian makro dengan
praprosesor #define. Perhatikan
bahwa keduanya, panjang dan lebar, diapit di dalam kurung. Hal ini
untuk mengeliminasi error yang mungkin terjadi, misalnya, panjang = 2 + 3 dan lebar
= 2 + 2, dimana pada kasus itu akan dihitung sebagai 2 + 3 * 2 + 2 = 10, bukan
20. Ini karena operator * memiliki keutamaan lebih tinggi dari +.
|
Program 11.9 Mengilustrasikan definisi fungsi lain dengan #define
|
|
|
|
#include<iostream>
using namespace std;
#define luas ((panjang)*(lebar))
// the macro
defines area of a rectangle.
int main()
{
int
panjang, lebar;
cout<<"Tuliskan panjang dan
lebar dari sebuah persegi-panjang: ";
cin>>lebar>>panjang;
cout<<"Luas =
"<<luas<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Tuliskan
panjang dan lebar dari sebuah persegi-panjang: 23 56
Luas = 1288
|
|
OPERATOR # dan ##
Sebuah # pada satu baris akan diabaikan oleh kompiler. Jadi,
#
tidak memiliki konsekuensi apapun. Ketika digunakan dengan suatu variabel
seperti #x di dalam sebuah statemen #define, operator # akan menjadi token
pengganti, yaitu ia mengganti nilai di manapun x muncul di dalam program.
Penggantian dikonversi menjadi sebuah string dengan kutip ganda. Sebagai
contoh, lihat kode berikut:
#define F(x) cout<<“Selamat
Pagi” #x
Ketika fungsi F(x) dipanggil
dengan F(Pak), kode tersebut akan
ekivalen dengan statemen berikut:
cout<<“Selamat Pagi Pak”;
Operator praprosesor ## dipakai
dengan #define untuk menyambung dua
token. Sebagai contoh, kode berikut:
#define sambung(m,
n) m ## n
akan menghasilkan keluaran mn.
Lihat program berikut untuk ilustrasi.
|
Program 11.10 Mengilustrasikan penggunaan praprosesor operator ##
|
|
|
|
#include<iostream>
using namespace std;
#define Fungsi(y)
cout<<"Selamat Pagi" #y<<endl;
#define SAMBUNG(a, b) a ## b
void main()
{
Fungsi(Pak!);
cout<<SAMBUNG(5, 7)<<endl;
cout<<SAMBUNG("O",
"K")<<endl;
cout<<SAMBUNG("Selamat",
" Pagi Kristof!")<<endl;
}
|
|
KELUARAN
|
|
|
Selamat
PagiPak!
57
OK
Selamat Pagi
Kristof!
|
|
DIREKTIF #undef
Praprosesor #undef dipakai
untuk membuang atau menggagalkan konstanta simbolis dan makro yang diciptakan
oleh #define. Jadi, skop dari makro
dan konstanta simbolis diawali dari titik definisi sampai titik di mana ia
digagalkan oleh #undef atau sampai
akhir dari file bila #undef tidak
diberikan. Tidak ada pembatasan pada pendefinisian-ulang makro atau konstanta
yang sama oleh #define. Hal ini
diilustrasikan oleh program berikut.
|
Program 11.11 Mengilustrasikan penggunaan #define dan #undef
|
|
|
|
#include<iostream>
#define Panjang 40 //Pendefinisian pertama harus sebelum
main()
using namespace std;
int main()
{
cout<<"Panjang awal =
"<<Panjang<<endl;
#undef
Panjang
#define
Panjang 60
cout<<"Panjang baru =
"<<Panjang<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Panjang awal =
40
Panjang baru =
60
|
|
11.9 Direktif
Praprosesor Kondisional
Direktif-direktif praprosesor kondisional disediakan untuk mengendalikan
aksi dari praprosesor dan untuk mengendalikan kompilasi program. Hal ini
dicantumkan pada Tabel 11.3 dengan penjelasan untuk tiap kasus. Perhatikan
bahwa jika #if digunakan, maka ia harus
diakhiri dengan #endif. Program 11.11
mengilustrasikan aplikasi dari beberapa direktif kondisional ini.
TABEL 11.3 Direktif-direktif praprosesor kondisional
|
Direktif
praprosesor
|
Penjelasan
|
|
#if
|
Direktif kondisional if, yang harus diakhir dengan #endif
|
|
#elif
|
direktif kondisional else if
|
|
#endif
|
akhir dari if
|
|
#else
|
else
|
|
#ifdef
|
jika didefinisikan
|
|
#ifndef
|
jika tidak didefinisikan
|
|
Program 11.12 Mengilustrasikan penggunaan #if, #elif, #define, dan #undef
|
|
|
|
#include<iostream>
using namespace std;
#define lebar 40
#define
luas (panjang*lebar)
#if 0
#if
panjang > 2*lebar
#undef
lebar //membuang
definisi sebelumnya dari lebar
#define
lebar panjang/2
#elif panjang
< lebar //sama dengan else if
#endif
#undef lebar
#define lebar panjang/4
//pendefinisian-ulang. Tidak ada semikolon di akhir
#endif
int main()
{
int
panjang ;
cout<<"Tuliskan panjang dari
sebuah persegi-panjang: ";
cin>>panjang;
cout<<"panjang =
"<<panjang<<"\t lebar =
"<<lebar<<endl;
cout<<"luas =
"<<luas<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Tuliskan
panjang dari sebuah persegi-panjang: 100
panjang =
100 lebar = 40
luas = 4000
|
|
|
Program 11.13 Mengilustrasikan penggunaan #error, #if, #endif, dan #else
|
|
|
|
#include<iostream>
using namespace std;
#define luas (panjang*lebar)
#define panjang 10
#if (panjang>50)
#error
1- Tidak sesuai dengan rencana
#else
#endif
int main()
{
int
lebar;
cout<<"Tuliskan lebar dari
persegi-panjang: ";
cin>>lebar;
cout<<"luas= "<<lebar*panjang<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Tuliskan lebar
dari persegi-panjang: 25
luas= 250
Jika ditetapkan
panjang = 100
#error : 1- Tidak sesuai dengan rencana
|
|
FUNGSI assert()
Fungsi assert() didefinisikan
di dalam file header <cassert>,
yang dipakai untuk menguji sebuah nilai. Sebagai contoh,
assert(k>0);
Dengan statemen semacam itu, jika k bernilai 0 atau kurang dari 0, maka
program akan diaborsi atau dibatalkan dan pesan error akan mengidentifikasi
baris mana di dalamnya error terjadi. Ini diilustrasikan pada program berikut.
|
Program 11.14 Mengilustrasikan penggunaan
dari fungsi assert()
|
|
|
|
#include<iostream>
#include<cassert>
using namespace std;
void main()
{
int
A, B;
cout<<"Masukkan dua integer:
";
cin>>A>>B;
assert(B>0);
double
C = A/B;
cout <<"C =
"<<C<<endl;
}
|
|
KELUARAN
|
|
|
Masukkan dua
integer: 5 0
Assertion
failed: B>0, file E:\Program\program11.14.cpp, line 11
|
|
11.10 Makro
Pustaka
Ada enam makro pustaka di dalam C++, yang diberikan pada Tabel 11.4. Tabel
itu juga menjelaskan keluaran dari tiap makro. Program 11.15 mengilustrasikan
aplikasi dari beberapa makro pustaka.
TABEL 11.4 Sejumlah makro pustaka di dalam C++
|
Nama makro
|
Penjelasan
|
|
_cplusplus
|
Program c++
|
|
_DATE
|
Tanggal
(mmm dd yyyy)
mmm = tiga
karakter untuk nama, contoh Oct.
|
|
_FILE_
|
Nama file dari
kode sumber.
|
|
_LINE_
|
Nomor baris.
|
|
_STDC_
|
ANSI.
|
|
_TIME_
|
Waktu
kompilasi ( hh: mm : ss).
|
|
Program 11.15 Mengilustrasikan penggunaan
sejumlah makro pustaka
|
|
|
|
#include <iostream>
using namespace std;
int main()
{
int
jum = 0;
for
(int i = 0 ; i<6; i++)
jum +=i;
cout<<"jum =
"<<jum<<endl;
cout<<"Nomor baris =
"<<__LINE__ <<endl;
cout<<"Tanggal penulisan
program: "<<__DATE__<<endl;
cout<<"Waktu kompilasi:
"<<__TIME__<< endl;
cout<<"Nama file =
"<< __FILE__<<endl;
cout<<"Nilai dari cplusplus
"<<__cplusplus<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
jum = 15
Nomor baris =
13
Tanggal
penulisan program: Jul 2 2015
Waktu
kompilasi: 17:30:23
Nama file = E:\Program\program11.15.cpp
Nilai dari
cplusplus 1
|
|
LATIHAN
1.
Apa itu makro?
2.
Bagaimana Anda
mendefinisikan makro dan membatalkan definisi makro tersebut?
3.
Apa itu
konstanta simbolis?
4.
Apa yang
dilakukan fungsi assert()? Tuliskan
sebuah program untuk mengilustrasikan penggunaannya.
5.
Definisikan
sebuah makro untuk mencari nilai terbesar dari dua nilai.
6.
Definisikan
sebuah makro untuk mencari nilai terbesar dari tiga nilai yang dimasukkan oleh
user.
7.
Definisikan
sebuah makro untuk menentukan luas segitiga dimana ketiga sisi dari segitiga
disediakan oleh user.
No comments:
Post a Comment