Algoritma, Struktur Data, dan Pemrograman: Bab 11. C++ Untuk Programer

Friday, December 23, 2016

Bab 11. C++ Untuk Programer

Bab.11 Bit, Karakter, C-String, dan struct

Tujuan Instruksional
· Definisi struct. · typedef. · Operator bitwise. · Bidang bit. · Pustaka karakter.	· Fungsi manipulasi-string. · Fungsi konversi-string. · Pustaka string.

11.1 Introduksi

Sekarang akan didiskusikan tentang struktur, yang ekivalen dengan kelas, dan manipulasi bit, karakter, dan string C-sytle. Banyak dari teknik yang disajikan di sini diberikan bagi para programer C dan C++.

Perancang C++ mengevolusi struktur menjadi kelas. Seperti kelas, struktur di dalam C++ dapat memuat penspesifikasi akses, fungsi anggota, konstruktor dan destruktor. Pada kenyataannya, satu-satunya perbedaan antara struktur dan kelas di dalam C++ adalah bahwa anggota struktur default adalah public dan anggota kelas default adalah private ketika tidak ada penspesifikasi yang digunakan dan bahwa pewarisan default untuk struktur adalah pewarisan public sedangkan pewarisan default untuk kelas adalah private.

11.2 Definisi Struktur

Perhatikan definisi struktur berikut:

struct Kartu

{

string muka;

string jenis;

}; // akhir struct Kartu

Katakunci struct mengintroduksi definisi struktur Kartu. Pengenal Kartu adalah nama struktur dan digunakan di dalam C++ untuk mendeklarasikan variabel bertipe struktur (di dalam C, nama tipe struktur ini adalah struct Kartu). Data (dan bisa saja fungsi, sama dengan kelas) dideklarasikan yang diapit oleh separang kurung kurawal di dalam definisi struktur adalah anggota-anggota struktur. Definisi Kartu memuat dua anggota string, muka dan jenis.

Tiga deklarasi berikut

Kartu satuKartu;

Kartu tumpukan[ 52 ];

Kartu *kartuPtr;

mendeklarasikan satuKartu menjadi sebuah variabel struktur bertipe Kartu, tumpukan menjadi sebuah array dengan 52 elemen bertipe Kartu, dan kartuPtr menjadi suatu pointer yang menunjuk ke sebuah struktur Kartu. Variabel-variabel bertipe struktur dapat pula dideklarasikan dengan nama-nama variabel yang dipisahkan koma. Tiga deklarasi di atas dapat pula digabungkan ke definisi struktur Kartu sebagai berikut:

struct Kartu

{

string muka;

string jenis;

} satuKartu, tumpukan[52], *kartuPtr;

11.3 typedef

Katakunci typedef menyediakan suatu mekanisme untuk menciptakan sinonim (nama alias) untuk tipe data yang didefinisikan. Nama untuk tipe struktur seringkali didefinisikan dengan typedef untuk menciptakan nama tipe yang lebih sederhana dan pendek. Sebagai contoh, statemen

typedef Kartu *KartuPtr;

mendefinisikan nama tipe baru KartuPtr sebagai sinonim untuk Kartu *. Penciptaan nama dengan typedef tidak sama dengan menciptakan tipe baru; typedef hanya menciptakan nama tipe baru yang dapat digunakan di dalam program sebagai nama alias.

11.4 Contoh: Simulasi Mengacak dan Menangani Kartu

Program pengacakan dan penanganan kartu akan didemonstrasikan pada Gambar 11.1 – 11.3. Program ini merepresentasikan setumpuk kartu sebagai sebuah vector yang memuat struktur-struktur dan menggunakan algoritma penanganan dan pengacakan.

Gambar 11.1 Definisi Kelas SetumpukKartu

// Gambar 11.1: SetumpukKartu.h

// Definisi kelas SetumpukKartu yang

// merepresentasikan setumpuk kartu.

#include <string>

#include <vector>

using namespace std;

// Definisi struktur Kartu

struct Kartu

{

string muka;

string jenis;

}; // akhir dari struktur Kartu

// Definisi kelas SetumpukKartu

class SetumpukKartu

{

public:

static const int jumlahKartu = 52;

static const int muka2 = 13;

static const int jenis2 = 4;

SetumpukKartu(); // konstruktor untuk menginisialisasi tumpukan kartu

void acak(); // mengacak kartu

void tangani() const; // menangani kartu

private:

vector< Kartu > tumpukan; // merepresentasikan tumpukan kartu

}; // akhir dari kelas SetumpukKartu

Konstruktor (baris 12-32 pada Gambar 11.2) menginisialisasi vector sesuai dengan urutan string karakter yang merepresentasikan Ace sampai King untuk setiap jenis kartu. Fungsi acak mengimplementasikan algoritma pengacakan tingkat-tinggi. Fungsi ini mengiterasi melalui semua 52 kartu (subskript 0 sampai 51). Untuk setiap kartu, angka 0 sampai 51 dipilih secara acak. Selanjutnya Kartu sekarang dan Kartu yang dipilih secara acak dipertukarkan di dalam vector. Terdapat 52 pertukaran kartu terjadi di dalam suatu pass dari keseluruhan vector, dan vector akhirnya menjadi acak.

Gambar 11.2 Definisi Fungsi Anggota Kelas SetumpukKartu

// Gambar 11.2: SetumpukKartu.cpp

// Definisi fungsi-anggota untuk kelas SetumpukKartu yang mensimulasikan

// penanganan dan pengacakan setumpuk kartu.

#include <iostream>

#include <iomanip>

#include <cstdlib> // prototipe untuk rand dan srand

#include <ctime> // prototipe untuk time

#include "SetumpukKartu.h" // definisi kelas SetumpukKartu

using namespace std;

// konstruktor SetumpukKartu tanpa-argumen menginisialisasi tumpukan

SetumpukKartu::SetumpukKartu()

: tumpukan( jumlahKartu )

{

// menginisialisasi array jenis

static string jenis[ jenis2 ] =

{ "Hearts", "Diamonds", "Clubs", "Spades" };

// menginisialisasi array muka

static string muka[ muka2 ] =

{ "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven",

"Eight", "Nine", "Ten", "Jack", "Queen", "King" };

// menetapkan nilai-nilai untuk tumpukan 52 Kartu

for ( int i = 0; i < jumlahKartu; ++i )

{

tumpukan[ i ].muka = muka[ i % muka2 ];

tumpukan[ i ].jenis = jenis[ i / jenis2 ];

} // akhir dari for

srand( time( 0 ) ); // pembangkit angka acak

} // akhir dari konstruktor SetumpukKartu tanpa-argumen

// mengacak kartu di dalam tumpukan

void SetumpukKartu::acak()

{

// mengacak kartu

for ( int i = 0; i < jumlahKartu; ++i )

{

int j = rand() % jumlahKartu;

Kartu temp = tumpukan[ i ];

tumpukan[ i ] = tumpukan[ j ];

tumpukan[ j ] = temp;

} // akhir dari for

} // akhir dari fungsi acak

// menangani kartu di dalam tumpukan

void SetumpukKartu::tangani() const

{

// menampilkan setiap muka dan jenis kartu

for ( int i = 0; i < jumlahKartu; ++i )

cout << right << setw( 5 ) << tumpukan[ i ].muka << " dari "

<< left << setw( 8 ) << tumpukan[ i ].jenis

<< ( ( i + 1 ) % 2 ? '\t' : '\n' );

} // akhir dari fungsi tangani

Gambar 11.3 Program Mengacak dan Menangani Kartu

// Gambar 11.3: gambar11_3.cpp

// Program mengacak dan menangani kartu.

#include "SetumpukKartu.h" // definisi kelas SetumpukKartu

int main()

{

SetumpukKartu setumpukKartu; // menciptakan objek SetumpukKartu

setumpukKartu.acak(); // mengacak kartu di dalam tumpukan

setumpukKartu.tangani(); // menangani kartu di dalam tumpukan

} // akhir dari main

King dari Clubs

Ten dari Diamonds

Five dari Diamonds

Jack dari Clubs

Seven dari Spades

Five dari Clubs

Three dari Spades

King dari Hearts

Ten dari Clubs

Eight dari Spades

Eight dari Hearts

Six dari Hearts

Nine dari Diamonds

Nine dari Clubs

Three dari Diamonds

Queen dari Hearts

Six dari Clubs

Seven dari Hearts

Seven dari Diamonds

Jack dari Diamonds

Jack dari Spades

King dari Diamonds

Deuce dari Diamonds

Four dari Clubs

Three dari Clubs

Five dari Hearts

Seven dari Clubs

Queen dari Clubs

Deuce dari Clubs

Queen dari Spades

Three dari Hearts

Five dari Spades

Deuce dari Hearts

Jack dari Hearts

Four dari Hearts

Ace dari Diamonds

Nine dari Spades

Four dari Diamonds

Ace dari Spades

Six dari Diamonds

Four dari Spades

King dari Spades

Eight dari Clubs

Ace dari Hearts

Deuce dari Spades

Ace dari Clubs

Ten dari Spades

Eight dari Diamonds

Ten dari Hearts

Six dari Spades

Queen dari Diamonds

Nine dari Hearts

11.5 Operator Bitwise

C++ menyediakan beberapa kapabilitas manipulas-bit. Sistem operasi, perangkat lunak untuk perangkat keras, perangkat lunak jaringan, dan lainnya mensyaratkan bahwa Anda berkomunikasi “secara langsung” dengan perangkat keras.

Di sini akan dikenalkan setiap operator bitwise C++ dan akan didiskusikan bagaimana menghemat memori menggunakan bidang data. Semua data direpresentasikan secara internal sebagai runtun bit. Setiap bit diasumsikan memiliki nilai 0 atau 1. Pada kebanyakan sistem, suatu runtun delapan bit membentuk sebuah byte, yang merupakan unit standard penyimpanan untuk variabel bertipe char. Beberapa tipe data lain disimpan dengan jumlah byte yang lebih besar. Operator bitwise digunakan untuk memanipulasi bit-bit dari operand-operand integral (char, short, int, dan long; untuk signed dan unsigned).

Gambar 11.4 Operator-Operator Bitwise

Operator	Nama	Penjelasan
& \| ^ << >> ~	AND bitwise OR bitwise exculsive OR bitwise geser kiri geser kanan komplemen bitwise	menetapkan setiap bit hasil menjadi 1 jika kedua bit operand adalah 1 menetapkan setiap bit hasil menjadi 1 jika salah satu atau kedua bit operandnya adalah 1 menetapkan setiap bit hasil 1 jika salah satu (tidak keduanya) bit operand adalah 1 Operator geser kiri menggeser bit-bit dari operand kiri ke kiri sejumlah bit yang dispesifikasi di dalam operand kanan menggeser bit-bit dari operand kiri ke kanan sejumlah bit yang dispesifikasi di dalam operand kanan menetapkan semua bit 0 di dalam operandnya menjadi bit 1 di dalam bit hasil dan menetapkan semua bit 1 menjadi bit 0 di dalam bit hasil

Operator-operator bitwise adalah AND bitwise (&), OR bitwise (|), exclusive OR (^) bitwise, geser kiri (<<), geser kanan (>>), dan komplemen bitwise ataua komplemen 1 (~). Operator AND bitwise, exclusive OR bitwise, dan OR bitwise membandingkan dua operandnya bit demi bit. Operator AND bitwise menetapkan setiap bit hasil menjadi 1 jika kedua bit operand adalah 1. Operator OR bitwise menetapkan setiap bit hasil menjadi 1 jika salah satu atau kedua bit operandnya adalah 1. Operator exclusive OR menetapkan setiap bit hasil 1 jika salah satu (tidak keduanya) bit operand adalah 1. Operator geser kiri menggeser bit-bit dari operand kiri ke kiri sejumlah bit yang dispesifikasi di dalam operand kanan. Operator geser kanan menggeser bit-bit dari operand kiri ke kanan sejumlah bit yang dispesifikasi di dalam operand kanan. Operator komplemen bitwise menetapkan semua bit 0 di dalam operandnya menjadi bit 1 di dalam bit hasil dan menetapkan semua bit 1 menjadi bit 0 di dalam bit hasil. Diskusi detil tentang setiap operator bitwise akan diberikan pada beberapa contoh ke depan. Operator-operator bitwise disimpulkan pada Gambar 11.4.

Menampilkan Representasi Biner atas Sebuah Nilai Bertipe Integral

Ketika menggunakan operator bitwise, adalah hal yang berguna untuk mengilustrasikan representasi biner setiap tipe integral di dalam C++. Program pada Gambar 11.5 menampilkan sebuah integer unsigned yang direpresentasikan dalam grup-grup delapan bit.

Gambar 11.5 Menampilkan unsigned integer di dalam Bit

// Gambar 11.5: gambar11_5.cpp

// Menampilkan sebuah unsigned integer di dalam bit.

#include <iostream>

#include <iomanip>

using namespace std;

void tampilBit( unsigned ); // prototipe

int main()

{

unsigned nilaiMasukan; // nilai integral untuk ditampilkan dalam biner

cout << "Masukkan sebuah unsigned integer: ";

cin >> nilaiMasukan;

tampilBit( nilaiMasukan );

} // akhir dari main

// menampilkan bit atas sebuah nilai unisigned integer

void tampilBit( unsigned nilai )

{

const int GESER = 8 * sizeof( unsigned ) - 1;

const unsigned MASK = 1 << GESER;

cout << setw( 10 ) << nilai << " = ";

// menampilkan bit

for ( unsigned i = 1; i <= GESER + 1; ++i )

{

cout << ( nilai & MASK ? '1' : '0' );

nilai <<= 1; // menggeser nilai ke kiri sejauh 1

if ( i % 8 == 0 ) // menampilkan spasi setelah 8 bit

cout << ' ';

} // akhir dari for

cout << endl;

} // akhir dari fungsi tampilBit

Masukkan sebuah unsigned integer: 65000

65000 = 00000000 00000000 11111101 11101000

Masukkan sebuah unsigned integer: 29

29 = 00000000 00000000 00000000 00011101

Fungsi tampilBit (baris 19-37) menggunakan operator AND bitwise untuk mengkombinasikan variabel nilai dengan konstanta MASK menggunakan &. Seringkali operator AND bitwise digunakan dengan sebuah operand yang dikenal dengan mask, yang merupakan suatu nilai integer dengan beberapa bit ditetapkan 1. Pada tampilBit, baris 22 menugaskan nilai 1<<GESER kepada konstanta MASK. Nilai dari konstanta GESER dikalkulasi pada baris 21 dengan ekspresi

8 * sizeof( unsigned ) - 1

dimana jumlah byte memori yang diperlukan oleh suatu objek unisigned dikalikan dengan 8 untuk mendapatkan total jumlah bit yang dibutuhkan dalam menyimpan sebuah objek unsigned, kemudian dikurangi dengan 1. Representasi bit atas 1<<GESER pada suatu komputer yang merepresentasikan objek unsigned dalam empat byte memori adalah

10000000 00000000 00000000 00000000

Gambar 11.6 Hasil Pengkombinasian Dua Bit Menggunakan Operator AND Bitwise

Bit1	Bit2	Bit1 & Bit2
0 1 0 1	0 0 1 1	0 0 0 1

Operator geser-kiri menggeser nilai 1 dari bit orde-rendah (paling-kanan) ke bit orde-tinggi (paling-kiri) di dalam MASK, dan mengisi bit-bit 0 dari kanan. Baris 29 menampilkan 1 atau 0 untuk bit paling-kiri dari variabel nilai. Diasumsikan bahwa variabel nilai memuat 65000 (00000000 00000000 11111101 11101000). Ketika nilai dan MASK dikombinasikan menggunakan &, semua bit kecuali bit orde-tinggi di dalam variabel nilai tersembunyi, karena sembarang bit yang diAND dengan 0 akan menghasilkan 0. Jika bit paling-kiri adalah 1, maka hasil evaluasi atas nilai & MASK adalah

00000000 00000000 11111101 11101000 (nilai)

10000000 00000000 00000000 00000000 (MASK)

--------------------------------------

00000000 00000000 00000000 00000000 (nilai & MASK)

yang diinterpretasikan sebagai false, dan 0 ditampilkan. Kemudian baris 30 menggeser variabel nilai ke kiri sejauh satu dengan ekspresi nilai <<= 1 (nilai = nilai << 1). Langkah-langkah ini diulangi untuk setiap bit variabel nilai. Pada bagian akhir repetisi, manipulasi bit yang didapatkan adalah sebagai berikut:

11111101 11101000 00000000 00000000 (nilai)

10000000 00000000 00000000 00000000 (MASK)

-----------------------------------

10000000 00000000 00000000 00000000 (nilai & MASK)

Gambar 11.6 menyimpulkan hasil pengkombinasian dua bit menggunakan operator AND bitwise. Program pada Gambar 11.7 mendemonstrasikan operator AND bitwise, operator OR bitwise, operator exclusive OR bitwise, operator komplemen bitwise.

Gambar 11.7 Operator AND, OR, XOR, dan Komplemen Bitwise

// Gambar 11.7: gambar11_7.cpp

// Operator AND, OR,

// exclusive OR, dan komplemen bitwise.

#include <iostream>

#include <iomanip>

using namespace std;

void tampilBit( unsigned ); // prototipe

int main()

{

unsigned angka1;

unsigned angka2;

unsigned mask;

unsigned setBit;

// mendemonstrasikan & bitwise

angka1 = 2179876355;

mask = 1;

cout << "Hasil pemngkombinasian berikut\n";

tampilBit( angka1 );

tampilBit( mask );

cout << "menggunakan operator AND bitwise & adalah\n";

tampilBit( angka1 & mask );

// mendemonstrasikan | bitwise

angka1 = 15;

setBit = 241;

cout << "\nHasil pemngkombinasian berikut\n";

tampilBit( angka1 );

tampilBit( setBit );

cout << "menggunakan operator OR bitwise | adalah\n";

tampilBit( angka1 | setBit );

// mendemonstrasikan exclusive OR bitwise

angka1 = 139;

angka2 = 199;

cout << "\nHasil pemngkombinasian berikut\n";

tampilBit( angka1 );

tampilBit( angka2 );

cout << "menggunakan operator exclusive OR bitwise ^ adalah\n";

tampilBit( angka1 ^ angka2 );

// mendemonstasikan komplemen bitwise

angka1 = 21845;

cout << "\nKomplemen satu dari\n";

tampilBit( angka1 );

cout << "adalah" << endl;

tampilBit( ~angka1 );

} // akhir dari main

// menampilkan bit atas sebuah nilai unisigned integer

void tampilBit( unsigned nilai )

{

const int GESER = 8 * sizeof( unsigned ) - 1;

const unsigned MASK = 1 << GESER;

cout << setw( 10 ) << nilai << " = ";

// menampilkan bit

for ( unsigned i = 1; i <= GESER + 1; ++i )

{

cout << ( nilai & MASK ? '1' : '0' );

nilai <<= 1; // menggeser nilai ke kiri sejauh 1

if ( i % 8 == 0 ) // menampilkan spasi setelah 8 bit

cout << ' ';

} // akhir dari for

cout << endl;

} // akhir dari fungsi tampilBit

Hasil dari pengkombonasian berikut

2179876355 = 10000001 11101110 01000110 00000011

1 = 00000000 00000000 00000000 00000001

menggunakan operator AND bitwise & adalah

1 = 00000000 00000000 00000000 00000001

Hasil dari pengkombonasian berikut

15 = 00000000 00000000 00000000 00001111

241 = 00000000 00000000 00000000 11110001

menggunakan operator OR bitwise | adalah

255 = 00000000 00000000 00000000 11111111

Hasil dari pengkombonasian berikut

139 = 00000000 00000000 00000000 10001011

199 = 00000000 00000000 00000000 11000111

menggunakan operator exclusive OR bitwise ^ adalah

76 = 00000000 00000000 00000000 01001100

Komplemen satu atas

21845 = 00000000 00000000 01010101 01010101

adalah

4294945450 = 11111111 11111111 10101010 10101010

Operator AND Bitwise (&)

Pada Gambar 11.7, baris 18 menugaskan 2179876355 (10000001 11101110 01000110 00000011) kepada variabel angka1, dan baris 19 menugaskan (00000000 00000000 00000000 00000001) kepada variabel mask. Ketika mask dan angka1 dikombinasikan menggunakan operator AND bitwise (&) di dalam ekspresi angka1 & mask (baris 24), hasilnya adalah 00000000 00000000 00000000 00000001. Semua bit kecuali bit orde-rendah di dalam variabel angka1 “disembunyikan” karena pengANDan dengan konstanta MASK.

Operator OR Bitwise (|)

Operator OR bitwise digunakan untuk menetapkan bit-bit spesifik menjadi 1 di dalam suatu operand. Gambar 11.7 menugaskan 15 (00000000 00000000 00000000 00001111) kepada variabel angka1, dan baris 28 menugaskan 241 (00000000 00000000 00000000 11110001) kepada variabel setBit. Ketika angka1 dan setBit dikombinasikan menggunakan operator OR bitwise di dalam ekspresi angka1 | setBit (baris 33), hasil yang didapatkan adalah 255 (00000000 00000000 00000000 11111111). Gambar 20.8 menyimpulkan hasil pengkombinasian dua bit menggunakan operator OR bitwise.

Gambar 11.8 Hasil Pengkombinasian Dua Bit Menggunakan Operator OR Bitwise

Bit1	Bit2	Bit1 \| Bit2
0 1 0 1	0 0 1 1	0 1 1 1

Operator exclusive OR Bitwise (^)

Operator exclusive OR (^) menetapkan setiap bit di dalam hasil menjadi 1 jika hanya terdapat satu buah bit di dalam kedua operandnya yang bernilai 1. Pada Gambar 11.8, baris 36-37 menugaskan nilai 139 (00000000 00000000 00000000 10001011) dan nilai 199 (00000000 00000000 00000000 11000111) kepada variabel angka1 dan angka2. Ketika kedua variabel tersebut dikombinasikan menggunakan operator exclusive OR di dalam ekspresi angka1 ^ angka 2 (baris 42), hasil yang diperoleh adalah 00000000 00000000 00000000 01001100. Gambar 11.9 menyimpulkan hasil pengkombinasian dua bit menggunakan operator exclusive OR bitwise.

Gambar 11.9 Hasil Pengkombinasian Dua Bit Menggunakan Operator Exclusive OR Bitwise

Bit1	Bit2	Bit1 ^ Bit2
0 1 0 1	0 0 1 1	0 1 1 0

Operator Komplemen Bitwise (~)

Operator komplemen bitwise (~) menetapkan semua bit 1 di dalam operandnya menjadi bit 0 di dalam hasil dan menetapkan bit 0 di dalam operandnya menjadi bit 1 di dalam hasil. Pada Gambar 11.7, baris 45 menugaskan nilai 21845 (00000000 00000000 01010101 01010101) kepada variabel angka1. Ketika ekspresi ~angka1 dievaluasi, hasil yang diperoleh adalah (11111111 11111111 10101010 10101010).

Gambar 11.10 mendemonstrasikan operator geser-kiri (<<) dan operator geser-kanan (>>). Fungsi tampilBit (baris 27-45) menampilkan nilai-nilai unsigned integer.

Gambar 11.10 Menggunakan Operator Geser Bitwise

// Gambar 11.10: gambar11_10.cpp

// Menggunakan operator geser bitwise.

#include <iostream>

#include <iomanip>

using namespace std;

void tampilBit( unsigned ); // prototipe

int main()

{

unsigned angka1 = 960;

// mendemonstrasikan geser-kiri bitwise

cout << "Hasil dari penggeseran kiri\n";

tampilBit( angka1 );

cout << "sejauh 8 bit menggunakan operator geser-kiri adalah\n";

tampilBit( angka1 << 8 );

// mendemonstrasikan geser-kanan bitwise

cout << "\nHasil dari penggeseran kanan\n";

tampilBit( angka1 );

cout << "sejauh 8 bit menggunakan operator geser-kanan adalah\n";

tampilBit( angka1 >> 8 );

} // akhir dari main

// menampilkan bit atas sebuah nilai unisigned integer

void tampilBit( unsigned nilai )

{

const int GESER = 8 * sizeof( unsigned ) - 1;

const unsigned MASK = 1 << GESER;

cout << setw( 10 ) << nilai << " = ";

// menampilkan bit

for ( unsigned i = 1; i <= GESER + 1; ++i )

{

cout << ( nilai & MASK ? '1' : '0' );

nilai <<= 1; // menggeser nilai ke kiri sejauh 1

if ( i % 8 == 0 ) // menampilkan spasi setelah 8 bit

cout << ' ';

} // akhir dari for

cout << endl;

} // akhir dari fungsi tampilBit

Hasil dari penggeseran kiri

960 = 00000000 00000000 00000011 11000000

sejauh 8 bit menggunakan operator geser-kiri adalah

245760 = 00000000 00000011 11000000 00000000

Hasil dari penggeseran kanan

960 = 00000000 00000000 00000011 11000000

sejauh 8 bit menggunakan operator geser-kanan adalah

3 = 00000000 00000000 00000000 00000011

Operator Geser_Kiri (<<)

Operator geser-kiri (<<) menggeser bit-bit operand kiri ke kiri sejumlah bit yang dispesifikasi di dalam operand kanannya. Bit-bit yang ditinggalkan akibat penggeseran diganti dengan 0; bit-bit yang digeser ke kiri yang melampaui bit paling kiri dibuang. Pada Gambar 11.10, baris 11 menugaskan nilai 960 (00000000 00000000 00000011 11000000) kepada variabel angka1. Hasil dari penggeseran-kiri atas variabel angka1 sejauh 8 bit di dalam ekspresi angka1 << 8 (baris 7) adalah 245760 (00000000 00000011 11000000 00000000).

Operator Geser_Kanan (<<)

Operator geser-kiri (<<) menggeser bit-bit operand kiri ke kanan sejumlah bit yang dispesifikasi di dalam operand kanannya. Bit-bit yang ditinggalkan akibat penggeseran diganti dengan 0; bit-bit yang digeser ke kanan yang melampaui bit paling kanan dibuang. Pada Gambar 11.10, hasil dari penggeseran-kanan atas variabel angka1 sejauh 8 bit di dalam ekspresi angka1 >> 8 (baris 7) adalah 3 (00000000 00000000 00000000 00000011).

Operator Penugasan Bitwise

Setiap operator bitwise (kecuali operator komplemen bitwise) memiliki suatu operator penugasan bitwise. Operator-operator penugasan ditampilkan pada Gambar 11.11;

Gambar 11.11 Operator Penugasan Bitwise

Operator Penugasan Bitwise
&= \|= ^= <<= >>=	Operator penugasan AND bitwise. Operator penugasan OR bitwise. Operator penugasan exclusive OR bitwise. Operator penugasan geser-kiri. Operator penugasan geser-kanan.

11.6 Bidang Bit

C++ menyediakan kemampuan untuk menspesifikasi jumlah bit dimana di dalamnya suatu tipe integral atau tipe enum anggota suatu kelas atau suatu struktur disimpan. Anggota semacam itu dikenal dengan bidang bit. Bidang bit memampukan utilisasi memori secara lebih baik dengan menyimpan data dalam jumlah bit minimum. Anggota bidang data harus dideklarasikan sebagai sebuah tipe integral atau suatu tipe enum.

Perhatikan definisi struktur sebagai berikut:

struct KartuBit

{

unsigned muka : 4;

unsigned jenis : 2;

unsigned warna : 1;

}; // akhir dari struct KartuBit

Definisi di atas memuat tiga bidang bit unsigned, yaitu muka, jenis, dan warna, yang digunakan untuk merepresentasikan setumpuk kartu (52 kartu). Sebuah bidang data dideklarasikan dengan mencantumkan sebuah tipe integral atau enum dengan titik dua (:) dan sebuah konstanta integer yang merepsentasikan lebar bidang data (jumlah bit dimana di dalamnya anggota disimpan). Lebar harus berupa konstanta integer.

Definisi struktur tersebut mengindikasikan bahwa anggota muka disimpan dalam empat bit, anggota jenis dalam dua bit, dan anggota warna dalam satu bit. Jumlah bit didasarkan pada rentang nilai yang diinginkan untuk setiap anggota struktur. Anggota muka menyimpan nilai antara 0 (Ace) sampai 12 (King), karena empat bit dapat menyimpan suatu nilai antara 0 sampai 15. Anggota jenis menyimpan nilai antara 0 dan 3 (0 = Diamonds, 1 = Hearts, 2 = Clubs, 3 =Spades), karena dua bit dapat menyimpan suatu nilai antara 0 sampai 3. Anggota warna menyimpan 0 (Merah) atau 1 (Hitam), karena satu bit dapat menyimpan 0 atau 1.

Program pada Gambar 11.12 - 11.14 menciptakan vector tumpukan yang memuat struktur KartuBit (baris 27 pada Gambar 11.12). Konstruktor menyisipkan 52 kartu ke dalam vector tumpukan, dan fungsi tangani menampilkan 52 kartu tersebut. Perhatikan bahwa bidang bit diakses seperti layaknya anggota struktur (baris 15-17 dan baris 26-31 pada Gambar 11.13). Anggota warna dicantumkan sebagai cara untuk mengindikasikan warna kartu.

Gambar 11.12 Definisi Kelas SetumpukKartu1

// Gambar 11.12: SetumpukKartu1.h

// Definisi kelas SetumpukKartu yang

// merepresentasikan setumpuk kartu.

#include <vector>

using namespace std;

// Definisi struktur KartuBit dengan bidang-bidang bit

struct KartuBit

{

unsigned muka : 4; // 4 bit; 0-15

unsigned jenis : 2; // 2 bit; 0-3

unsigned warna : 1; // 1 bit; 0-1

}; // akhir dari struct KartuBit

// Definisi kelas SetumpukKartu

class SetumpukKartu1

{

public:

static const int muka2 = 13;

static const int warna2 = 2; // hitam dan merah

static const int jumlahKartu = 52;

SetumpukKartu1(); // konstruktor menginisialisasi tumpukan

void tangani(); // menangani kartu di dalam tumpukan

private:

vector< KartuBit > tumpukan; // merepresentasikan tumpukan kartu

}; // akhir dari kelas SetumpukKartu

Gambar 11.13 Definisi Fungsi Anggota untuk Kelas SetumpukKartu1

// Gambar 11.13: SetumpukKartu1.cpp

// Mendefinisikan fungsi anggota untuk kelas SetumpukKartu1 yang

// mensimulasikan pengacakan setumpuk kartu.

#include <iostream>

#include <iomanip>

#include "SetumpukKartu1.h" // Definisi kelas SetumpukKartu1

using namespace std;

// Konstruktor SetumpukKartu1 tanpa-argumen menginisialisasi tumpukan

SetumpukKartu1::SetumpukKartu1()

{

for ( int i = 0; i < jumlahKartu; ++i )

{

tumpukan[ i ].muka = i % muka2;

tumpukan[ i ].jenis = i / muka2;

tumpukan[ i ].warna = i / ( muka2 * warna2 );

} // akhir dari for

} // akhir dari konstruktor SetumpukKartu1 tanpa-argumen

// menangani kartu di dalam tumpukan

void SetumpukKartu1::tangani()

{

for ( int k1 = 0, k2 = k1 + jumlahKartu / 2;

k1 < jumlahKartu / 2 - 1; ++k1, ++k2 )

cout << "Kartu:" << setw( 3 ) << tumpukan[ k1 ].muka

<< " Jenis:" << setw( 2 ) << tumpukan[ k1 ].jenis

<< " Warna:" << setw( 2 ) << tumpukan[ k1 ].warna

<< " " << "Kartu:" << setw( 3 ) << tumpukan[ k2 ].muka

<< " Jenis:" << setw( 2 ) << tumpukan[ k2 ].jenis

<< " Warna:" << setw( 2 ) << tumpukan[ k2 ].warna << endl;

} // akhir dari fungsi tangani

Gambar 11.14 Program Menguji Kelas SetumpukKartu1

// Gambar 11.14: gambar11_14.cpp

// Program menguji pengacakan dan penanganan kartu.

#include "SetumpukKartu1.h" // definisi kelas SetumpukKartu1

int main()

{

SetumpukKartu1 setumpukKartu1; // menciptakan objek SetumpukKartu1

setumpukKartu1.tangani(); // menangani kartu di dalam tumpukan

} // akhir dari main

Kartu: 0 Jenis: 0 Warna: 0 Kartu: 0 Jenis: 2 Warna: 1

Kartu: 1 Jenis: 0 Warna: 0 Kartu: 1 Jenis: 2 Warna: 1

Kartu: 2 Jenis: 0 Warna: 0 Kartu: 2 Jenis: 2 Warna: 1

Kartu: 3 Jenis: 0 Warna: 0 Kartu: 3 Jenis: 2 Warna: 1

Kartu: 4 Jenis: 0 Warna: 0 Kartu: 4 Jenis: 2 Warna: 1

Kartu: 5 Jenis: 0 Warna: 0 Kartu: 5 Jenis: 2 Warna: 1

Kartu: 6 Jenis: 0 Warna: 0 Kartu: 6 Jenis: 2 Warna: 1

Kartu: 7 Jenis: 0 Warna: 0 Kartu: 7 Jenis: 2 Warna: 1

Kartu: 8 Jenis: 0 Warna: 0 Kartu: 8 Jenis: 2 Warna: 1

Kartu: 9 Jenis: 0 Warna: 0 Kartu: 9 Jenis: 2 Warna: 1

Kartu: 10 Jenis: 0 Warna: 0 Kartu: 10 Jenis: 2 Warna: 1

Kartu: 11 Jenis: 0 Warna: 0 Kartu: 11 Jenis: 2 Warna: 1

Kartu: 12 Jenis: 0 Warna: 0 Kartu: 12 Jenis: 2 Warna: 1

Kartu: 0 Jenis: 1 Warna: 0 Kartu: 0 Jenis: 3 Warna: 1

Kartu: 1 Jenis: 1 Warna: 0 Kartu: 1 Jenis: 3 Warna: 1

Kartu: 2 Jenis: 1 Warna: 0 Kartu: 2 Jenis: 3 Warna: 1

Kartu: 3 Jenis: 1 Warna: 0 Kartu: 3 Jenis: 3 Warna: 1

Kartu: 4 Jenis: 1 Warna: 0 Kartu: 4 Jenis: 3 Warna: 1

Kartu: 5 Jenis: 1 Warna: 0 Kartu: 5 Jenis: 3 Warna: 1

Kartu: 6 Jenis: 1 Warna: 0 Kartu: 6 Jenis: 3 Warna: 1

Kartu: 7 Jenis: 1 Warna: 0 Kartu: 7 Jenis: 3 Warna: 1

Kartu: 8 Jenis: 1 Warna: 0 Kartu: 8 Jenis: 3 Warna: 1

Kartu: 9 Jenis: 1 Warna: 0 Kartu: 9 Jenis: 3 Warna: 1

Kartu: 10 Jenis: 1 Warna: 0 Kartu: 10 Jenis: 3 Warna: 1

Kartu: 11 Jenis: 1 Warna: 0 Kartu: 11 Jenis: 3 Warna: 1

Kartu: 12 Jenis: 1 Warna: 0 Kartu: 12 Jenis: 3 Warna: 1

Adalah hal mungkin untuk menspesifikasi suatu bidang bit tak-bernama, dimana bidang bit itu digunakan untuk melakukan pengganjalan bit di dalam struktur. Sebagai contoh, definisi struktur berikut menggunakan bidang tiga-bit tak-bernama (tidak ada yang bisa disimpan di dalam tiga bit tersebut).

struct Contoh

{

unsigned a : 13;

unsigned : 3;

unsigned b : 4;

}; // akhir dari struct Contoh

Bidang bit tak-bernama dengan lebar bidang 0 digunakan untuk menyejajarkan ke bidang bit berikutnya pada batas unit-penyimpanan baru. Sebagai contoh, definisi struktur

struct Contoh

{

unsigned a : 13;

unsigned : 0;

unsigned b : 4;

}; // akhir dari struct Contoh

menggunakan sebuah bidang 0-bit tak-bernama untuk melompati bit-bit sisa pada unit penyimpanan dimana di dalamnya a disimpan dan menyejajarkan b pada batas unit-penyimpanan berikutnya.

11.7 Pustaka Karater

Kebanyakan data yang dimasukkan ke komputer adalah berupa karakter, termasuk huruf, angka, dan berbagai simbol. Pada bagian ini akan didiskusikan kapabilitas C++ dalam memeriksa dan memanipulasi karakter secara individual.

Pustaka karakter mencakup beberapa fungsi yang dapat melakukan beberapa pengujian dan pemanipulasian data karakter. Setiap fungsi meneriman sebuah karakter, yang direprensentasikan sebagai sebuah int. Karakter seringkali dimanipulasi seperti integer. Ingat bahwa EOF normalnya memiliki nilai -1 dan beberapa arsitek perangkat keras tidak mengijinkan nilai negatif untuk disimpan di dalam variabel char. Oleh karena itu, fungsi pustaka karakter memanipulasi karakter sebagai integer. Gambar 11.15 menyimpulkan fungsi-fungsi pustaka karakter. Ketika menggunakan pustaka karakter, Anda harus mencantumkan header <cctype>.

Gambar 20.15 Fungsi Pustaka Karakter

Prototipe

Penjelasan

int isdigit(int c)

int isalpha(int c)

int isalnum (int c)

int isxdigit(int c)

int islower(int c)

int isupper(int c)

int tolower(int c)

int toupper(int c)

int isspace(int c)

int iscntrl(int c)

int ispunct(int c)

int isprint(int c)

int isgraph(int c)

mengembalikan 1 jika c adalah dijit dan jika tidak mengembalikan 0.

mengembalikan 1 jika c adalah huruf dan jika tidak mengembalikan 0.

mengembalikan 1 jika c adalah dijit atau huruf dan jika tidak mengembalikan 0.

mengembalikan 1 jika c adalah karakter dijit heksadesimal dan jika tidak mengembalikan 0.

mengembalikan 1 jika c adalah huruf kecil dan jika tidak mengembalikan 0.

mengembalikan 1 jika c adalah huruf besar dan jika tidak mengembalikan 0.

jika c adalah huruf besar, tolower mengembalikan c sebagai huruf kecil, jika c tidak huruf besar, tolower mengembalikan argumen yang tidak berubah.

jika c adalah huruf kecil, toupper mengembalikan c sebagai huruf besar, jika c tidak huruf kecil, toupper mengembalikan argumen yang tidak berubah.

mengembalikan 1 jika c adalah karakter spasi-putih, yaitu garis-baru (‘\n’), spasi (‘ ‘), carriage return (‘\r’), tab horisontal (‘\t’), atau tab vertikal (‘\v’). Jika c bukan spasi-putih, isspace mengembalikan 0.

mengembalikan 1 jika c adalah karakter kontrol, yaitu garis-baru (‘\n’), form feed (‘\f’), carriage return (‘\r’), tab horisontal (‘\t’), tab vertikal (‘\v’), alert (‘\a’), atau backspace (‘\b). Jika c bukan karakter kontrol, iscntrl mengembalikan 0.

mengembalikan 1 jika c adalah karakter printing selain spasi, dijit, atau huruf. Jika selain itu, ispunct mengembalikan 0.

mengembalikan 1 jika c adalah karakter printing termasuk spasi (‘ ‘) dan mengembalikan 0 jika c bukan karakter printing.

mengembalikan 1 jika c adalah karakter printing selain spasi (‘ ‘) dan sebaliknya mengembalikan 0.

Gambar 11.16 mendemonstrasikan fungsi isdigit, isalpha, isalnum, dan isxdigit. Fungsi isdigit menentukan apakah argumennya sebuah dijit (0-9) atau tidak. Fungsi isalpha menentukan apakah argumennya sebuah huruf (A-Z, a-z) atau tidak. Fungs isalnum menentukan apakah argumennya sebuah huruf atau dijit (0-9, A-Z, a-z) atau tidak. Fungsi isxdigit menentukan apakah argumennya sebuah dijit heksadesimal (A-F, a-f, 0-9).

Gambar 11.16 Beberapa Fugsi Pustaka Karakter

// Gambar 11.16: gambar11_16.cpp

// Fungsi pustaka karakter isdigit, isalpha, isalnum dan isxdigit.

#include <iostream>

#include <cctype> // character-handling function prototypes

using namespace std;

int main()

{

cout << "Menurut isdigit:\n"

<<( isdigit( '8' ) ?"8 adalah" : "8 bukan" ) << " dijit\n"

<<( isdigit( '#' ) ?"# adalah" : "# bukan" ) << " dijit\n";

cout << "\nMenurut isalpha:\n"

<<( isalpha( 'A' ) ?"A adalah" : "A bukan" ) << " huruf\n"

<<( isalpha( 'b' ) ?"b adalah" : "b bukan" ) << " huruf\n"

<<( isalpha( '&' ) ?"& adalah" : "& bukan" ) << " huruf\n"

<<( isalpha( '4' ) ?"4 adalah" : "4 bukan" ) << " huruf\n";

cout << "\nMenurut isalnum:\n"

<<( isalnum( 'A' ) ?"A adalah" : "A bukan" )

<< " dijit atau huruf\n"

<<( isalnum( '8' ) ?"8 adalah" : "8 bukan" )

<< " dijit atau huruf\n"

<<( isalnum( '#' ) ?"# adalah" : "# bukan" )

<< " dijit atau huruf\n";

cout << "\nMenurut isxdigit:\n"

<<( isxdigit( 'F' ) ?"F adalah" : "F bukan" )

<< " dijit heksadesimal\n"

<<( isxdigit( 'J' ) ?"J adalah" : "J bukan" )

<< " dijit heksadesimal\n"

<<( isxdigit( '7' ) ?"7 adalah" : "7 bukan" )

<< " dijit heksadesimal\n"

<<( isxdigit( '$' ) ?"$ adalah" : "$ bukan" )

<< " dijit heksadesimal\n"

<<( isxdigit( 'f' ) ?"f adalah" : "f bukan" )

<< " dijit heksadesimal" << endl;

} // akhir dari main

Menurut isdigit:

8 adalah dijit

# bukan dijit

Menurut isalpha:

A adalah huruf

b adalah huruf

& bukan huruf

4 bukan huruf

Menurut isalnum:

A adalah dijit atau huruf

8 adalah dijit atau huruf

# bukan dijit atau huruf

Menurut isxdigit:

F adalah dijit heksadesimal

J bukan dijit heksadesimal

7 adalah dijit heksadesimal

$ bukan dijit heksadesimal

f adalah dijit heksadesimal

Gambar 11.16 menggunakan operator kondisional (?:) dengan setiap fungsi untuk menentukan apakah string “adalah” atau string “bukan” yang harus ditampilkan pada keluaran untuk setiap karakter yang diuji. Sebagai contoh, baris 10 mengindikasikan bahwa jika ‘8’ adalah dijit, yaitu jika isdigit mengembalikan true, maka string “8 adalah“ yang ditampilkan. jika ‘8’ bukan dijit, yaitu jika isdigit mengembalikan 0, maka string “8 bukan“ yang ditampilkan.

Gambar 11.17 mendemonstrasikan fungsi islower, isupper, tolower, dan toupper. Fungsi islower menentukan apakah argumennya adalah huruf kecil (a-z) atau tidak. Fungsi isupper menentukan apakah argumennya huruf besar (A – Z) atau tidak. Fungsi tolower mengkonversi huruf besar menjadi huruf kecil dan menjadikan huruf kecil sebagai nilai balik. Jika argumennya tidak huruf besar, fungsi ini mengembalikan argumennya sebagai nilai balik. Fungsi toupper mengkonversi huruf kecil menjadi huruf besar dan menjadikan huruf besar sebagai nilai balik. Jika argumennya tidak huruf kecil, fungsi ini mengembalikan argumennya sebagai nilai balik.

Gambar 11.17 Beberapa Fugsi Lain Pustaka Karakter

// Gambar 11.17: gambar11_17.cpp

// Fungsi pustaka karakter islower, isupper, tolower dan toupper.

#include <iostream>

#include <cctype> // prototipe fungsi pustaka karakter

using namespace std;

int main()

{

cout << "Menurut islower:\n"

<<( islower( 'p' ) ?"p adalah" : "p bukan" )

<< " huruf kecil\n"

<<( islower( 'P' ) ?"P adalah" : "P bukan" )

<< " huruf kecil\n"

<<( islower( '5' ) ?"5 adalah" : "5 bukan" )

<< " huruf kecil\n"

<<( islower( '!' ) ?"! adalah" : "! bukan" )

<< " huruf kecil\n";

cout << "\nMenurut isupper:\n"

<<( isupper( 'D' ) ?"D adalah" : "D bukan" )

<< " huruf besar\n"

<<( isupper( 'd' ) ?"d adalah" : "d bukan" )

<< " huruf besar\n"

<<( isupper( '8' ) ?"8 adalah" : "8 bukan" )

<< " huruf besar\n"

<<( isupper( '$' ) ?"$ adalah" : "$ bukan" )

<< " huruf besar\n";

cout << "\nu dikonversi menjadi huruf besar adalah "

<< static_cast< char >( toupper( 'u' ) )

<< "\n7 dikonversi menjadi huruf besar adalah "

<< static_cast< char >( toupper( '7' ) )

<< "\n$ dikonversi menjadi huruf besar adalah "

<< static_cast< char >( toupper( '$' ) )

<< "\nL dikonversi menjadi huruf kecil adalah "

<< static_cast< char >( tolower( 'L' ) ) << endl;

} // akhir dari main

Menurut islower:

p adalah huruf kecil

P bukan huruf kecil

5 bukan huruf kecil

! bukan huruf kecil

Menurut isupper:

D adalah huruf besar

d bukan huruf besar

8 bukan huruf besar

$ bukan huruf besar

u dikonversi menjadi huruf besar adalah U

7 dikonversi menjadi huruf besar adalah 7

$ dikonversi menjadi huruf besar adalah $

L dikonversi menjadi huruf kecil adalah l

Gambar 11.18 mendemonstrasikan fungsi isspace, iscntrl, ispunct, isprint dan isgraph. Fungsi isspace menentukan apakah argumennya merupakan karakter spasi, seperti garis-baru (‘\n’), spasi (‘ ‘), carriage return (‘\r’), tab horisontal (‘\t’), atau tab vertikal (‘\v’). Fungsi iscntrl menentukan apakah argumennya berupa karakter kontrol, seperti garis-baru (‘\n’), form feed (‘\f’), carriage return (‘\r’), tab horisontal (‘\t’), tab vertikal (‘\v’), alert (‘\a’), atau backspace (‘\b). Fungsi ispunct menentukan apakah argumennya karakter printing selain spasi, dijit, atau huruf. Fungsi isprint menentukan apakah argumennya berupa karakter yang bisa ditampilkan pada layar (termasuk spasi). Fungsi isgraph menguji sama dengan isprint, tetapi karakter spasi di sini tidak disertakan.

Gambar 11.18 Menggunakan Fungsi isspace, iscntrl, ispunct, isprint, dan isgraph

// Gambar 11.18: gambar11_18.cpp

// Menggunakan isspace, iscntrl, ispunct, isprint dan isgraph.

#include <iostream>

#include <cctype> // prototipe fungsi pustaka karakter

using namespace std;

int main()

{

cout << "Menurut isspace:\nGaris-baru "

<<( isspace( '\n' ) ?"adalah" : "bukan" )

<< " karakter spasi-putih\nTab horisontal "

<<( isspace( '\t' ) ?"adalah" : "bukan" )

<< " karakter spasi-putih\n"

<<( isspace( '%' ) ?"% adalah" : "% bukan" )

<< " karakter spasi-putih\n";

cout << "\nMenurut iscntrl:\nGaris-baru "

<<( iscntrl( '\n' ) ?"adalah" : "bukan" )

<< " karakter kontrol\n"

<<( iscntrl( '$' ) ?"$ adalah" : "$ bukan" )

<< " karakter kontrol\n";

cout << "\nMenurut ispunct:\n"

<<( ispunct( ';' ) ?"; adalah" : "; bukan" )

<< " karakter tanda-baca\n"

<<( ispunct( 'Y' ) ?"Y adalah" : "Y bukan" )

<< " karakter tanda-baca\n"

<<( ispunct( '#' ) ?"# adalah" : "# bukan" )

<< " karakter tanda-baca\n";

cout << "\nMenurut isprint:\n"

<<( isprint( '$' ) ?"$ adalah" : "$ bukan" )

<< " karakter printing\nAlert "

<<( isprint( '\a' ) ?"adalah" : "bukan" )

<< " karakter printing\nSpasi "

<<( isprint( ' ' ) ?"adalah" : "bukan" )

<< " karakter printing\n";

cout << "\nMenurut isgraph:\n"

<<( isgraph( 'Q' ) ?"Q adalah" : "Q bukan" )

<< " karakter printing selain spasi\nSpasi "

<<( isgraph( ' ' ) ?"adalah" : "bukan" )

<< " karakter printing selain spasi" << endl;

} // akhir dari main

Menurut isspace:

Garis-baru adalah karakter spasi-putih

Tab horisontal adalah karakter spasi-putih

% bukan karakter spasi-putih

Menurut iscntrl:

Garis-baru adalah karakter kontrol

$ bukan karakter kontrol

Menurut ispucnt:

; adalah karakter tanda-baca

Y bukan karakter tanda-baca

# adalah karakter tanda-baca

Menurut isprint:

$ adalah karakter printing

Alter bukan karakter printing

Spasi adalah karakter printing

Menurut isgraph:

Q adalah karakter printing selain spasi

Spasi bukan karakter printing selain spasi

11.8 Fungsi Pemanipulsi String Berbasis Pointer

Pustaka string menyediakan beberapa fungsi untuk memanipulasi data string, membandingkan string, mencari string, dan lain-lain. Bagian ini menyajikan beberapa fungsi pemanipulasi string yang umum digunakan. Fungsi-fungsi tersebut disimpulkan pada Gambar 11.19; kemudian setiap fungsi digunakan di dalam contoh kode. Prototipe fungsi-fungsi tersebut dilokasikan di dalam header <cstring>.

Gambar 11.19 Fungsi Pemanipulasi String di dalam Pustaka String

Prototipe Fungsi

Penjelasan Fungsi

char *strcpy( char *s1, const char *s2 );

Menyalin string s2 ke array karakter s1. Nilai s1 yang dijadikan nilai

balik.

char *strncpy( char *s1, const char *s2, size_t n );

Menyalin sebanyak-banyaknya n karakter dari string s2 ke array

karakter s1. Nilai s1 yang dijadikan nilai balik.

char *strcat( char *s1, const char *s2 );

Menyambung string s2 ke string s1. Karakter pertama dari s2

menindih karakter null dari s1. Nilai s1 yang dijadikan nilai balik.

char *strncat( char *s1, const char *s2, size_t n );

Menyambung sebanyak-banyaknya n karakter dari string s2 ke string

s1. Karakter pertama dari s2 menindih karakter null dari s1. Nilai s1

yang dijadikan nilai balik.

int strcmp( const char *s1, const char *s2 );

Membandingkan string s1 dengan string s2. Fungsi ini

mengembalikan sebuah nilai nol, kurang dari nol, atau lebih dari nol

jika s1 sama dengan, kurang dari, atau lebih dari s2.

int strncmp( const char *s1, const char *s2, size_t n );

Membandingkan sampai dengan n karakter dari string s1 dengan

string s2. Fungsi ini mengembalikan sebuah nilai nol, kurang dari nol,

atau lebih dari nol jika n karakter penggalan dari s1 sama dengan,

kurang dari, atau lebih dari n karakter penggalan dari s2.

char *strtok( char *s1, const char *s2 );

Sederet pemanggilan terhadap strtok akan memecah string s1 menjadi token-token, potongan logis atas suatu kata di dalam sebaris teks. String s1 dipecah sesuai dengan karakter di dalam string s2. Sebagai contoh, jika akan dipecah string “danau:toba:siantar” menjadi token-token berdasarkan karakter ‘:’, maka token yang dihasilkan adalah “danau”, “toba”, dan “siantar”. Fungsi strtok memberikan nilai balik berupa satu token per unit waktu. Pemanggilan pertama memuat s1 sebagai argumen, dan pemanggilan selanjutnya akan melanjutkan pentokenan string yang sama.

size_t strlen( const char *s );

Menentukan panjang suatu string s. Jumlah karakter yang berada sebelum karakter null yang akan dijadikan nilai balik.

Beberapa fungsi pada Gambar 11.19 memuat parameter dengan tipe data size_t. Tipe ini didefinisikan di dalam header <cstring> yang merupakan tipe integral unsigned seperti unsigned int, unsigned long, dan seterusnya.

Menyalin String dengan strcpy dan strncpy

Fungsi strcpy menyalin argumen keduanya, sebuah string, ke dalam argumen pertamanya, sebuah array karakter yang cukup besar untuk menyimpan string pada argumen kedua dan karakter nullnya (yang juga disalin). Fungsi strncpy sangat mirip dengan strcpy, kecuali bahwa strncpy menspesifikasi jumlah karakter yang akan disalin dari string ke array karakter. Fungsi strncpy tidak harus selalu menyalin karakter null dari argumen keduanya, karena karakter null hanya disalin jika jumlah karakter yang akan disalin setidaknya lebih besar satu dari panjang string. Sebagai contoh, jika “binjai ” adalah argumen kedua, maka karakter null akan disalin jika argumen ketiga dari strncpy sedikitnya memiliki panjang 7 karakter (6 karakter di dalam “binjai ” ditambah satu karakter null).

Gambar 11.20 menggunakan strcpy (baris 13) untuk menyalin keseluruhan string di dalam array x ke dalam array y dan menggunakan strncpy (baris 19) untuk menyalin 14 karakter pertama di dalam array x ke dalam array z. Baris 20 menambahkan sebuah karakter null (‘\0’) ke dalam array z, karena pemanggilan terhadap strncpy di dalam program tidak menyalin karakter null. (Argumen ketiga kurang dari panjang string pada argumen kedua ditambah satu).

Gambar 11.20 Menggunakan strcpy dan strncpy

// Gambar 11.20: gambar11_20.cpp

// Menggunakan strcpy dan strncpy.

#include <iostream>

#include <cstring> // prototipe untuk strcpy dan strncpy

using namespace std;

int main()

{

char x[] = "Selamat Ulang Tahun ya!"; // panjang string 23

char y[ 25 ];

char z[ 15 ];

strcpy( y, x ); // menyalin isi x ke y

cout << "String di dalam array x adalah: " << x

<< "\nString di dalam array y adalah: " << y << '\n';

// menyalin 14 karakter pertama dari x ke z

strncpy( z, x, 14 ); // tidak menyalin karakter null

z[ 14 ] = '\0'; // menyambung '\0' ke isi z

cout << "String di dalam array z adalah: " << z << endl;

} // akhir dari main

String di dalam array x adalah: Selamat Ulang Tahun ya!

String di dalam array y adalah: Selamat Ulang Tahun ya!

String di dalam array z adalah: Selamat Ulang

Menyambung String dengan strcat dan strncat

Fungsi strcat menyambung argumen keduanya (sebuah string) ke argumen pertamanya (sebuah array karakter yang memuat string). Karakter pertama pada argumen kedua menggantikan karakter null (‘\0’) di dalam argumen kedua. Anda harus memastikan bahwa array yang dipakai untuk menyimpan string pertama harus cukup besar untuk menampung penggabungan atas string pertama, string kedua dan karakter null (karakter null yang disalin dari string kedua). Fungsi strncat menyambung sejumlah karakter tertentu dari string kedua ke string pertama dan menyambung sebuah karakter null kepada hasil. Program pada Gambar 11.21 mendemonstrasikan fungsi strcat (baris 15 dan 25) dan fungsi strncat (baris 20).

Gambar 11.21 Menggunakan strcat dan strncat

// Gambar 11.21: gambar11_21.cpp

// Using strcat and strncat.

#include <iostream>

#include <cstring> // prototipe untuk strcat dan strncat

using namespace std;

int main()

{

char s1[ 20 ] = "Selamat "; // panjang 8

char s2[] = "Tahun Baru "; // panjang 11

char s3[ 40 ] = "";

cout << "s1 = " << s1 << "\ns2 = " << s2;

strcat( s1, s2 ); // menyambung s2 ke s1 (panjang 19)

cout << "\n\nSetelah strcat(s1, s2):\ns1 = " << s1 << "\ns2 = " << s2;

// menyambung 8 karakter pertama dari s1 ke s3

strncat( s3, s1, 8 ); // menempatkan '\0' setelah karakter terakhir

cout << "\n\nSetelah strncat(s3, s1, 8):\ns1 = " << s1

<< "\ns3 = " << s3;

strcat( s3, s1 ); // menyambung s1 ke s3

cout << "\n\nSetelah strcat(s3, s1):\ns1 = " << s1

<< "\ns3 = " << s3 << endl;

} // akhir dari main

S1 = Selamat

s2 = Tahun Baru

Setelah strcat(s1, s2):

s1 = Selamat Tahun Baru

s2 = Tahun Baru

Seteleh strncat(s3, s1, 8):

s1 = Selamat Tahun Baru

s3 = Selamat

Setelah strcat(s3, s1)

s1 = Selamat Tahun Baru

s3 = Selamat Selamat Tahun Baru

Membandingkan String dengan strcmp dan strncmp

Gambar 11.22 membandingkan dua string menggunakan strcmp (baris 15-17) dan strncmp (baris 20-22). Fungsi strcmp membandingkan argumen string pertamanya dengan argumen string keduanya karakter demi karakter. Fungsi ini menghasilkan nol jika kedua string sama sama, nilai negatif jika string pertama kurang dari string kedua, dan nilai positif jika string pertama lebih dari string kedua. Fungsi strncmp ekivalen dengan strcmp, kecuali bahwa strncmp membandingkan sampai sejumlah karakter tertentu. Fungsi strncmp akan berhenti membandingkan karakter jika ia mencapai karakter null di dalam salah satu argumen stringnya. Program kemudian menampilkan nilai integer yang dihasilkan oleh tiap pemanggilan fungsi.

Gambar 11.22 Menggunakan strcmp dan strncmp

// Gambar 11.22: gambar11_22.cpp

// Using strcmp and strncmp.

#include <iostream>

#include <iomanip>

#include <cstring> // prototipe untuk fungsi strcmp dan strncmp

using namespace std;

int main()

{

char *s1 = "Selamat Ulang Tahun";

char *s2 = "Selamat Ulang Tahun";

char *s3 = "Selamat Berlibur";

cout << "s1 = " << s1 << "\ns2 = " << s2 << "\ns3 = " << s3

<< "\n\nstrcmp(s1, s2) = " << setw( 2 ) << strcmp( s1, s2 )

<< "\nstrcmp(s1, s3) = " << setw( 2 ) << strcmp( s1, s3 )

<< "\nstrcmp(s3, s1) = " << setw( 2 ) << strcmp( s3, s1 );

cout << "\n\nstrncmp(s1, s3, 6) = " << setw( 2 )

<< strncmp( s1, s3, 6 ) << "\nstrncmp(s1, s3, 9) = " << setw( 2 )

<< strncmp( s1, s3, 9 ) << "\nstrncmp(s3, s1, 9) = " << setw( 2 )

<< strncmp( s3, s1, 9 ) << endl;

} // akhir dari main

s1 = Selamat Tahun Baru

s2 = Selamat Tahun Baru

s3 = Selamat Berlibur

strcmp(s1, s2) = 0

strcmp(s1, s3) = 19

strcmp(s3, s1) = -19

strncmp(s1, s3, 6) = 0

strncmp(s1, s3, 7) = 19

strncmp(s3, s1, 7) = -19

Mentokenkan String dengan strtok

Fungsi strtok memecah suatu string menjadi beberapa token. Token merupakan suatu runtun karakter yang dipisahkan oleh karakter-karakter pembatas (biasanya spasi atau tanda baca). Sebagai contoh, dalam sebaris teks, setiap kata dipandang sebagai token dan spasi yang memisahkan setiap kata dipandang sebagai karakter pembatas.

Pemanggilan berkali-kali terhadap strtok dibutuhkan untuk memecah sebuah string menjadi beberapa token (diasumsikan string memuat lebih dari satu token). Pemanggilan pertama terhadap strtok memuat dua argumen, sebuah string yang akan ditokenkan dan sebuah string yang memuat karakter yang memisahkan antar token (delimiter atau pembatas). Baris 16 pada Gambar 11.23 menugaskan suatu pointer yang menunjuk ke token pertama (di dalam kalimat) kepada tokenPtr. Argumen kedua, “ “, mengindikasikan bahwa token-token di dalam kalimat dipisahkan oleh spasi. Fungsi strtok mencari karakter pertama di dalam kalimat yang tidak merupakan karakter pembatas (spasi). Ini merupakan token pertama. Fungsi ini kemudian mencari karakter pembatas pertama di dalam string dan menggantikannya dengan karakter null (‘\0’). Ini menghentikan token sekarang. Fungsi strtok menyimpan (di dalam sebuah variabel static) suatu pointer yang menunjuk ke karakter berikutnya setelah token pertama di dalam kalimat.

Pemanggilan berkali-kali terhadap strtok akan melanjutkan pentokenan kalimat yang memuat NULL sebagai argumen pertama (baris 22). Argumen NULL mengindikasikan bahwa pemanggilan terhadap strtok harus berlanjut mulai dari lokasi di dalam kalimat yang disimpan oleh pemanggilan terakhir terhadap strtok. Fungsi strtok melakukan hal ini meski Anda tidak menyadarinya. Jika tidak ada lagi token yang tersisa ketika strtok dipanggil, maka strtok menghasilkan nilai balik NULL. Program pada Gambar 11.23 menggunakan strtok untuk mentokenkan string “Ini adalah sebuah kalimat dengan 7 token”. Program kemudian menampilkan setiap token pada baris yang terpisah. Baris 25 menampilkan kalimat setelah tokenisasi. Perhatikan bahwa strtok memodifikasi string masukan; oleh karena itu, salinan dari string asli harus diciptakan jika program memerlukannya setelah pemanggilan strtok. Ketika kalimat ditampilkan setelah tokenisasi, hanya kata “Ini” yang tertampil, karena strtok mengganti setiap spasi di dalam kalimat dengan sebuah karakter null (‘\n’) selama proses tokenisasi.

Gambar 11.23 Menggunakan strtok untuk Menokenkan String

// Gambar 11.23: gambar11_23.cpp

// Menggunakan strtok untuk mentokenkan sebuah string.

#include <iostream>

#include <cstring> // prototipe untuk strtok

using namespace std;

int main()

{

char kalimat[] = "Ini adalah sebuah kalimat dengan 7 token";

char *tokenPtr;

cout << "String yang akan ditokenkan adalah:\n" << kalimat

<< "\n\nToken-token tersebut adalah:\n\n";

// mulai tokenisasi kalimat

tokenPtr = strtok( kalimat, " " );

// melanjutkan tokenisasi kalimat sampai tokenPtr menjadi NULL

while ( tokenPtr != NULL )

{

cout << tokenPtr << '\n';

tokenPtr = strtok( NULL, " " );// mendapatkan token berikutnya

} // akhir dari while

cout << "\nSetelah strtok, kalimat = " << kalimat << endl;

} // akhir dari main

String yang akan ditokenkan adalah:

Ini adalah sebuah kalimat dengan 7 token

Token-token tersebut adalah:

Ini

adalah

sebuah

kalimat

dengan

7 token

Setelah strtok, kalimat = Ini

Menentukan Panjang String

Fungsi strlen mengambil sebuah string sebagai argumen dan menjadikan jumlah karakter di dalam string sebagai nilai balik, dimana karakter null tidak dihitung. Program pada Gambar 11.24 mendemonstrasikan fungsi strlen.

Gambar 11.24 Menggunakan strlen

// Gambar 11.24: gambar11_24.cpp

// Menggunakan strlen.

#include <iostream>

#include <cstring> // prototipe untuk strlen

using namespace std;

int main()

{

char *string1 = "abcdefghijklmnopqrstuvwxyz";

char *string2 = "empat";

char *string3 = "Surabaya";

cout << "Panjang dari \"" << string1 << "\" adalah " << strlen( string1 )

<< "\nPanjang dari \"" << string2 << "\" adalah " << strlen( string2 )

<< "\nPanjang dari \"" << string3 << "\" adalah " << strlen( string3 )

<< endl;

} // akhir dari main

Panjang dari “abcdefghijklmnopqrstuvwxyz” adalah 26

Panjang dari “empat” adalah 4

Panjang dari “Surabaya” adalah 8

11.9 Fungsi Konversi String Berbasis Pointer

Sebelumnya telah didiskusikan beberapa fungsi pemanipulasi string yang paling populer di dalam C++. Sekarang, akan didiskusikan fungsi-fungsi untuk mengkonversi string menggunakan utilitas <cstdlib>. Fungsi-fungsi ini mengkonversi string berbasis pointer menjadi integer dan nilai pecahan. Pada Gambar 11.25 disimpulkan beberapa fungsi konversi string berbasis pointer. Ketika menggunakannya, Anda perlu mencantumkan header <cstdlib>.

Gambar 11.25 Fungsi Pengkonversi String di dalam Pustaka String

Prototipe Fungsi

Penjelasan Fungsi

double atof( const char *nPtr );

Mengkonversi string nPtr menjadi double. Jika string tidak dapat dikonversi, 0 diberikan sebagai nilai balik.

int atoi( const char *nPtr )

Mengkonversi string nPtr menjad int. Jika string tidak dapat dikonversi, 0 diberikan sebagai nilai balik.

long atol( const char *nPtr )

Mengkonversi string nPtr menjad long int. Jika string tidak dapat dikonversi, 0 diberikan sebagai nilai balik.

double strtod( const char *nPtr, char **endPtr )

Mengkonversi string nPtr menjadi double. endPtr merupakan alamat sebuah pointer ke sisa string setelah double. Jika string tidak dapat dikonversi, 0 diberikan sebagai nilai balik.

long strtol( const char *nPtr, char **endPtr, int base )

Mengkonversi string nPtr menjadi long. endPtr merupakan alamat sebuah pointer ke sisa string setelah long. Jika string tidak dapat dikonversi, 0 diberikan sebagai nilai balik. Parameter base adalah parameter yang mengindikasikan basis bilangan yang akan dikonversi. (8 untuk oktal, 10 untuk desimal, atau 16 untuk heksadesimal). Default adalah desimal.

unsigned long strtoul( const char *nPtr, char **endPtr, int base )

Mengkonversi string nPtr menjadi unsigned long. endPtr merupakan alamat sebuah pointer ke sisa string setelah long. Jika string tidak dapat dikonversi, 0 diberikan sebagai nilai balik. Parameter base adalah parameter yang mengindikasikan basis bilangan yang akan dikonversi. (8 untuk oktal, 10 untuk desimal, atau 16 untuk heksadesimal). Default adalah desimal.

Fungsi atof (Gambar 11.26 pada baris 9) mengkonversi argumennya, sebuah string yang merepresentasikan suatu angka pecahan, menjadi nilai double. Fungsi ini menghasilkan nilai balik double. Jika string tidak dapat dikonversi, misalnya jika karakter pertama string bukan suatu dijit, maka fungsi atof menghasilkan nol.

Gambar 11.26 Menggunakan atof

// Gambar 11.26: gambar11_26.cpp

// Menggunakan atof.

#include <iostream>

#include <cstdlib> // prototipe atof

using namespace std;

int main()

{

double d = atof( "99.0" ); // mengkonversi string ke double

cout << "String \"99.0\" dikonversi ke double menjadi " << d

<< "\nNilai terkonversi dibagi 2 adalah " << d / 2.0 << endl;

} // akhir dari main

String “99.0” dikonversi ke double menjadi 99

Nilai terkonversi dibagi 2 adalah 49.5

Fungsi atoi (Gambar 11.27 pada baris 9) mengkonversi argumennya, sebuah string dijit yang merepresentasikan suatu integer, menjadi suatu nilai int. Fungsi ini menghasilkan nilai int sebagai nilai balik. Jika string tidak dapat dikonversi, fungsi atoi menghasilkan nol.

Gambar 11.27 Menggunakan atoi

// Gambar 11.27: gambar11_27.cpp

// Menggunakan atoi.

#include <iostream>

#include <cstdlib> // prototipe atoi

using namespace std;

int main()

{

int i = atoi( "2593" ); // mengkonversi string menjadi int

cout << "String \"2593\" dikonversi ke int menjadi " << i

<< "\nNilai terkonversi dikurangi 593 adalah " << (i - 593) << endl;

} // akhir dari main

String “2593” dikonversi ke int menjadi 2593

Nilai terkonversi dikurangi 593 adalah 2000

Fungsi atol (Gambar 11.28 pada baris 9) mengkonversi argumennya, sebuah string dijit yang merepresentasikan suatu long integer, menjadi suatu nilai long. Fungsi ini menghasilkan nilai long sebagai nilai balik. Jika string tidak dapat dikonversi, fungsi atol menghasilkan nol. Jika int dan long keduanya disimpan dalam empat byte, maka fungsi atoi dan atol akan memberikan hasil yang identik.

Gambar 11.28 Menggunakan atol

// Gambar 11.28: gambar11_28.cpp

// Menggunakan atol.

#include <iostream>

#include <cstdlib> // prototipe atol

using namespace std;

int main()

{

long x = atol( "1000000" ); // mengkonversi string menjadi long

cout << "String \"1000000\" dikonversi ke long menjadi " << x

<< "\nNilai terkonversi dibagi 2 adalah " << x/2 << endl;

} // akhir dari main

String “1000000” dikonversi ke long menjadi 1000000

Nilai terkonversi dibagi 2 adalah 500000

Fungsi strtod (Gambar 11.29) mengkonversi sebuah runtun karakter yang merepresentasikan suatu nilai pecahan menjadi double. Fungsi strtod menerima dua argumen, sebuah string (char *) dan alamat dari sebuah pointer char * (yaitu char **). String tersebut memuat runtuk karakter yang akan dikonversi menjadi double. Argumen kedua memampukan strtod untuk memodifikasi sebuah pointer char * di dalam fungsi pemanggil, sehingga pointer itu menunjuk ke lokasi dari karakter pertama setelah sepenggal string yang dikonversi. Baris 13 mengindikasikan bahwa d ditugasi nilai double yang dikonversi dari string dan bahwa stringPtr ditugasi alamat dari karakter pertama setelah nilai terkonversi (51.2) di dalam string.

Gambar 11.29 Menggunakan strtod

// Gambar 11.29: gambar11_29.cpp

// Menggunakan strtod.

#include <iostream>

#include <cstdlib> // prototipe strtod

using namespace std;

int main()

{

double d;

const char *string1 = "51.2% mahasiswa adalah perempuan";

char *stringPtr;

d = strtod( string1, &stringPtr ); // mengkonversi karakter menjadi double

cout << "String \"" << string1

<< "\" dikonversi ke \nnilai double " << d

<< " dan string \"" << stringPtr << "\"" << endl;

} // akhir dari main

String “51.2% mahasiswa adalah perempuan” dikonversi ke

nilai double 51.2 dan string “% mahasiswa adalah perempuan”

Fungsi strtol (Gambar 11.30) mengkonversi ke long dari sebuah runtun karakter yang merepresentasikan sebuah integer. Fungsi menerima sebuah string (char *), alamat pointer char *, dan sebuah integer. Argumen string memuat runtun karakter yang akan dikonversi. Argumen kedua ditugasi lokasi karakter pertama yang ditempatkan setelah penggalan string yang dikonversi. Argumen integer menspesifikasi basis nilai yang sedang dikonversi. Baris 13 mengindikasikan bahwa x ditugasi nilai long yang dikonversi dari string dan bahwa sisaPtr ditugasi lokasi karakter pertama yang ditempatkan setelah nilai terkonversi (-1234567) di dalam string1. Penggunaan pointer null untuk argumen kedua menyebabkan sisa string diabaikan. Argumen ketiga, 0, mengindikasikan bahwa nilai yang dikonversi dapat berupa bilangan oktal (basis 8), desimal (basis 10), atau heksadesimal (basis 16). Ini ditentukan oleh karakter awal di dalam string, dimana 0 mengindikasikan bilangan oktal, 0x mengindikasikan heksadesimal, dan suatu angka dari 1 sampai 9 mengindikasikan desimal.

Gambar 11.30 Menggunakan strtol

// Gambar 11.30: gambar11_30.cpp

// Menggunakan strtol.

#include <iostream>

#include <cstdlib> // prototipe strtol

using namespace std;

int main()

{

long x;

const char *string1 = "-1234567abc";

char *sisaPtr;

x = strtol( string1, &sisaPtr, 0 ); // mengkonversi karakter menjadi long

cout << "String awal adalah \"" << string1

<< "\"\nNilai terkonversi adalah " << x

<< "\nSisa dari string asli adalah \"" << sisaPtr

<< "\"\nNilai terkonversi plus 567 adalah " << (x + 567) << endl;

} // akhir dari main

String asli adalah "-1234567abc"

Nilai terkonversi adalah -1234567

Sisa dari string asli adalah "abc"

Nilai terkonversi plus 567 adalah -1234000

Di dalam suatu pemanggilan fungsi strtol, basis dapat dispesifikasi sebagai nol atau sembarang nilai di antara 2 dan 36. Representasi numerik atas integer dari basis 11 sampai 36 menggunakan karakter A – Z untuk merepresentasikan nilai dari 10 sampai 35. Sebagai contoh, nilai-nilai heksadesimal dapat memuat dijit 0 sampai 9 dan karakter A sampai F. Suatu integer basis 11 dapat memuat dijit 0 sampai 9 dan karakter A. Suatu integer basis 24 dapat memuat dijit 0 sampai 9 dan karakter A sampai N. Suatu integer basis 36 dapat memuat dijit 0 sampai 9 dan karakter A sampai Z.

Fungsi strtoul (Gambar 11.31) mengkonversi ke unsigned long dari suatu runtun karakter yang merepresentasikan sebuah integer unsigned long. Fungsi ini bekerja secara identik dengan strtol. Baris 14 mengindikasikan bahwa x ditugasi nilai unsigned long yang dikonversi dari string dan bahwa sisaPtr ditugasi lokasi karakter pertama yang ditempatkan setelah nilai terkonversi (1234567) di dalam string1. Argumen ketiga, 0, mengindikasikan bahwa nilai yang dikonversi dapat berupa bilangan oktal, desimal, atau heksadesimal.

Gambar 11.31 Menggunakan strtoul

// Gambar 11.31: gambar11_31.cpp

// Menggunakan strtoul.

#include <iostream>

#include <cstdlib> // prototipe strtoul

using namespace std;

int main()

{

long x;

const char *string1 = "1234567abc";

char *sisaPtr;

// mengkonversi runtun karakter menjadi unsigned long

x = strtoul( string1, &sisaPtr, 0 );

cout << "String awal adalah \"" << string1

<< "\"\nNilai terkonversi adalah " << x

<< "\nSisa dari string asli adalah \"" << sisaPtr

<< "\"\nNilai terkonversi minus 567 adalah " << (x - 567) << endl;

} // akhir dari main

String asli adalah "1234567abc"

Nilai terkonversi adalah 1234567

Sisa dari string asli adalah "abc"

Nilai terkonversi plus 567 adalah 1234000

11.10 Fungsi Pencarian Pada Pustaka String

Bagian ini menyajikan beberapa fungsi string yang bisa dipakai untuk mencari karakter dan string di dalam suatu string. Fungsi-fungsi tersebut disimpulkan pada Gambar 11.32. Fungsi strcspn dan strspn menspesifikasi tipe size_t. Tipe size_t merupakan sebuat tipe yang didefinisikan sebagai tipe integral standard yang dijadikan nilai balik oleh operator sizeof. Fungsi strchr mencari kemunculan pertama dari sebuah karakter di dalam suatu string. Jika karakter ditemukan, maka strchr memberikan nilai balik berupa suatu pointer yang menunjuk ke karakter tersebut di dalam string; sebaliknya, strchr menghasilkan suatu pointer null. Program pada Gambar 11.33 menggunakan strchr (baris 14 dan 22) untuk mencari kemunculan pertama dari ‘a’ dan ‘z’ di dalam string “Ini adalah sebuah test”.

Gambar 11.32 Fungsi Pencarian di dalam Pustaka String

Prototipe Fungsi

Penjelasan Fungsi

char *strchr( const char *s, int c );

Mencari lokasi kemunculan pertama dari karakter c di dalam string s. Jika c ditemukan, maka sebuah pointer yang menunjuk ke c di dalam s dijadikan nilai balik. Sebaliknya, sebuah pointer null yang dijadikan nilai balik.

char *strrchr( const char *s, int c )

Mencari dimulai dari ujung akhir string s dan melokasi kemunculan terakhir dari karakter c di dalam string s. Jika c ditemukan, maka sebuah pointer yang menunjuk ke c di dalam s dijadikan nilai balik. Sebaliknya, sebuah pointer null yang dijadikan nilai balik.

size_t strspn( const char *s1, const char *s2 )

Menentukan dan menjadikan nilai balik panjang segmen awal string s1 yang hanya memuat karakter-karakter yang dimuat di dalam string s2.

char *strpbrk( const char *s1, const char *s2 )

Mencari lokasi kemunculan pertama dari sembarang karakter di dalam string s2 di dalam string s1. Jika suatu karakter dari string s2 ditemukan, maka pointer yang menunjuk ke karakter tersebut di dalam string s1 dijadikan nilai balik. Sebaliknya, sebuah pointer null yang dijadikan nilai balik.

size_t strcspn( const char *s1, const char *s2 )

Menentukan dan menjadikan nilai balik panjang segmen awal string s1 yang hanya memuat karakter-karakter yang tidak dimuat di dalam string s2.

char *strstr( const char *s1, const char *s2 )

Mencari lokasi kemunculan pertama string s2 di dalam string s1. Jika string tersebut ditemukan, maka pointer yang menunjuk ke string s2 di dalam s1 dijadikan nilai balik. Sebaliknya, sebuah pointer null yang dijadikan nilai balik.

Gambar 11.33 Menggunakan strchr

// Gambar 11.33: gambar11_33.cpp

// Menggunakan strchr.

#include <iostream>

#include <cstring> // prototipe strchr

using namespace std;

int main()

{

const char *string1 = "Ini adalah sebuah test";

char karakter1 = 'a';

char karakter2 = 'z';

// mencari karakter1 di dalam string1

if( strchr( string1, karakter1 ) != NULL )

cout << '\'' << karakter1 << "' ditemukan di dalam \""

<< string1 << "\".\n";

else

cout << '\'' << karakter1 << "' tidak ditemukan di dalam \""

<< string1 << "\".\n";

// mencari karakter2 di dalam string1

if( strchr( string1, karakter2 ) != NULL )

cout << '\'' << karakter2 << "' ditemukan di dalam \""

<< string1 << "\".\n";

else

cout << '\'' << karakter2 << "' tidak ditemukan di dalam \""

<< string1 << "\"." << endl;

} // akhir dari main

‘a’ ditemukan di dalam “Ini adalah sebuah test”

‘z’ tidak ditemukan di dalam “Ini adalah sebuah test”

Fungsi strcspn (Gambar 11.34, baris 15) menentukan panjang dari segmen awal dari string di dalam argumen pertamanya yang tidak memuat sembarang karakter dari string di dalam argumen keduanya. Fungsi ini mengembalikan panjang segmen.

Gambar 11.34 Menggunakan strcspn

// Gambar 11.34: gambar11_34.cpp

// Menggunakan strcspn.

#include <iostream>

#include <cstring> // prototipe strcspn

using namespace std;

int main()

{

const char *string1 = "Nilai adalah 3.14159";

const char *string2 = "1234567890";

cout << "string1 = " << string1 << "\nstring2 = " << string2

<< "\n\nPanjang segmen awal dari string1"

<< "\nyang tidak memuat sembarang karakter dari string2 = "

<< strcspn( string1, string2 ) << endl;

} // akhir dari main

string1 = Nilai adalah 3.14159

string2 = 1234567890

Panjang segmen awal dari string1

yang tidak memuat sembarang karakter dari string2 = 13

Fungsi strpbrk mencari kemunculan pertama dari sembarang karakter di dalam argumen string keduanya di dalam argumen string pertamanya. Jika sebuah karakter dari argumen kedua ditemukan, maka fungsi strpbrk mengembalikan sebuah pointer yang menunjuk ke karakter tersebut di dalam argumen pertama; sebaliknya, sebuah pointer null yang dijadikan nilai balik. Baris 13 pada Gambar 11.35 mencari loksi kemunculan pertama dari sembarang karakter dari string2 di dalam string1.

Gambar 11.35 Menggunakan strpbrk

// Gambar 11.35: gambar11_35.cpp

// Menggunakan strpbrk.

#include <iostream>

#include <cstring> // prototipe strpbrk

using namespace std;

int main()

{

const char *string1 = "Ini adalah sebuah test";

const char *string2 = "berhati-hatilah";

cout << "Dari karakter-karakter di dalam \"" << string2 << "\"\n'"

<< *strpbrk( string1, string2 ) << "\' adalah karakter pertama "

<< "yang muncul di dalam\n\"" << string1 << '\"' << endl;

} // akhir dari main

Dari karakter-karakter di dalam “berhati-hatilah”

‘i’ adalah karakter pertama yang muncul di dalam

“Ini adalah sebuah test”

Fungsi strrchr mencari kemunculan terakhir dari karakter yang dispesifikasi di dalam sebuah string. Jika karakter yang dicari ditemukan, strrchr menjadikan nilai balik berupa sebuah pointer yang menunjuk ke karakter tersebut di dalam string; sebaliknya, strrchr menghasilkan 0. Baris 15 pada Gambar 11.36 mencari kemunculan terakhir dari karakter ‘d’ di dalam string “Panorama danau toba telah dikenal di segala penjuru dunia”.

Gambar 11.36 Menggunakan strrchr

// Gambar 11.36: gambar11_36.cpp

// Menggunakan strrchr.

#include <iostream>

#include <cstring> // prototipe strrchr

using namespace std;

int main()

{

const char *string1 = "Panorama danau toba telah dikenal di segala penjuru dunia";

char c = 'd';

cout << "string1 = " << string1 << "\n" << endl;

cout << "Sisa dari string1 yang diawali dengan\n"

<< "kemunculan terakhir karakter '"

<< c << "' adalah: \"" << strrchr( string1, c ) << '\"' << endl;

} // akhir dari main

string1 = Panorama danau toba telah dikenal di segala penjuru dunia

Sisa dari string1 yang diawali dengan

kemunculan terakhir dari karakter ‘d’ adalah: “dunia”

Fungsi strspn (Gambar 11.37, baris 15) menentukan panjang segmen awal dari string di dalam argumen pertamanya yang hanya memuat karakter-karakter dari string di dalam argumen keduanya. Fungsi ini menghasilkan panjang segmen.

Gambar 11.37 Menggunakan strrchr

// Gambar 11.37: gambar11_37.cpp

// Using strspn.

#include <iostream>

#include <cstring> // prototipe strspn

using namespace std;

int main()

{

const char *string1 = "Nilai adalah 3.14159";

const char *string2 = "abcd efg ";

cout << "string1 = " << string1 << "\nstring2 = " << string2

<< "\n\nPanjang segmen awal dari string1\n"

<< "yang hanya memuat karakter-karakter dari string2 = "

<< strspn( string1, string2 ) << endl;

} // akhir dari main

string1 = Nilai adalah 3.14159

string2 = abcd efg

Panjang segmen awal dari string1

yang hanya memuat karakter-karakter dari string2 = 0

Fungsi strstr mencari kemunculan pertama dari argumen string kedua di dalam argumen string pertamanya. Jika string kedua ditemukan di dalam string pertama, maka sebuah pointer yang menunjuk ke lokasi string kedua tersebut di dalam argumen string pertama dijadikan nilai balik; sebaliknya, 0 dijadikan nilai balik. Baris 15 pada Gambar 11.38 menggunakan strstr untuk mencari string “def” di dalam string “abcdefabcdef”.

Gambar 11.38 Menggunakan strstr

// Gambar 11.38: gambar11_38.cpp

// Menggunakan strstr.

#include <iostream>

#include <cstring> // prototipe strstr

using namespace std;

int main()

{

const char *string1 = "abcdefabcdef";

const char *string2 = "def";

cout << "string1 = " << string1 << "\nstring2 = " << string2

<< "\n\nPotongan dari string1 yang diawali dengan\n"

<< "kemunculan pertama dari string2 adalah: "

<< strstr( string1, string2 ) << endl;

} // akhir dari main

string1 = abcdefabcdef

string2 = def

Potongan dari string1 yang diawali dengan

kemunculan pertaman dari string2 adalah: defabcdef

Kesimpulan

Operator bitwise digunakan untuk memanipulasi bit-bit dari operand-operand integral (char, short, int, dan long; untuk signed dan unsigned).

Fungsi isdigit, isalpha, isalnum, dan isxdigit. Fungsi isdigit menentukan apakah argumennya sebuah dijit (0-9) atau tidak. Fungsi isalpha menentukan apakah argumennya sebuah huruf (A-Z, a-z) atau tidak. Fungs isalnum menentukan apakah argumennya sebuah huruf atau dijit (0-9, A-Z, a-z) atau tidak. Fungsi isxdigit menentukan apakah argumennya sebuah dijit heksadesimal (A-F, a-f, 0-9).

Fungsi islower menentukan apakah argumennya adalah huruf kecil (a-z) atau tidak. Fungsi isupper menentukan apakah argumennya huruf besar (A – Z) atau tidak. Fungsi tolower mengkonversi huruf besar menjadi huruf kecil dan menjadikan huruf kecil sebagai nilai balik. Jika argumennya tidak huruf besar, fungsi ini mengembalikan argumennya sebagai nilai balik. Fungsi toupper mengkonversi huruf kecil menjadi huruf besar dan menjadikan huruf besar sebagai nilai balik. Jika argumennya tidak huruf kecil, fungsi ini mengembalikan argumennya sebagai nilai balik.

Fungsi isspace, iscntrl, ispunct, isprint dan isgraph. Fungsi isspace menentukan apakah argumennya merupakan karakter spasi, seperti garis-baru (‘\n’), spasi (‘ ‘), carriage return (‘\r’), tab horisontal (‘\t’), atau tab vertikal (‘\v’). Fungsi iscntrl menentukan apakah argumennya berupa karakter kontrol, seperti garis-baru (‘\n’), form feed (‘\f’), carriage return (‘\r’), tab horisontal (‘\t’), tab vertikal (‘\v’), alert (‘\a’), atau backspace (‘\b). Fungsi ispunct menentukan apakah argumennya karakter printing selain spasi, dijit, atau huruf. Fungsi isprint menentukan apakah argumennya berupa karakter yang bisa ditampilkan pada layar (termasuk spasi). Fungsi isgraph menguji sama dengan isprint, tetapi karakter spasi di sini tidak disertakan.

Fungsi strtok memecah suatu string menjadi beberapa token. Token merupakan suatu runtun karakter yang dipisahkan oleh karakter-karakter pembatas (biasanya spasi atau tanda baca).

Fungsi strlen mengambil sebuah string sebagai argumen dan menjadikan jumlah karakter di dalam string sebagai nilai balik, dimana karakter null tidak dihitung.

Fungsi atof (Gambar 20.26 pada baris 9) mengkonversi argumennya, sebuah string yang merepresentasikan suatu angka pecahan, menjadi nilai double. Fungsi ini menghasilkan nilai balik double. Jika string tidak dapat dikonversi, misalnya jika karakter pertama string bukan suatu dijit, maka fungsi atof menghasilkan nol.

Fungsi atoi (Gambar 20.27 pada baris 9) mengkonversi argumennya, sebuah string dijit yang merepresentasikan suatu integer, menjadi suatu nilai int. Fungsi ini menghasilkan nilai int sebagai nilai balik. Jika string tidak dapat dikonversi, fungsi atoi menghasilkan nol.

Fungsi atol (Gambar 20.28 pada baris 9) mengkonversi argumennya, sebuah string dijit yang merepresentasikan suatu long integer, menjadi suatu nilai long. Fungsi ini menghasilkan nilai long sebagai nilai balik. Jika string tidak dapat dikonversi, fungsi atol menghasilkan nol. Jika int dan long keduanya disimpan dalam empat byte, maka fungsi atoi dan atol akan memberikan hasil yang identik.

Fungsi strtod mengkonversi sebuah runtun karakter yang merepresentasikan suatu nilai pecahan menjadi double. Fungsi strtod menerima dua argumen, sebuah string (char *) dan alamat dari sebuah pointer char * (yaitu char **). String tersebut memuat runtuk karakter yang akan dikonversi menjadi double. Argumen kedua memampukan strtod untuk memodifikasi sebuah pointer char * di dalam fungsi pemanggil, sehingga pointer itu menunjuk ke lokasi dari karakter pertama setelah sepenggal string yang dikonversi.

Fungsi strchr mencari kemunculan pertama dari sebuah karakter di dalam suatu string. Jika karakter ditemukan, maka strchr memberikan nilai balik berupa suatu pointer yang menunjuk ke karakter tersebut di dalam string; sebaliknya, strchr menghasilkan suatu pointer null.

Fungsi strcspn menentukan panjang dari segmen awal dari string di dalam argumen pertamanya yang tidak memuat sembarang karakter dari string di dalam argumen keduanya. Fungsi ini mengembalikan panjang segmen.

Fungsi strspn menentukan panjang segmen awal dari string di dalam argumen pertamanya yang hanya memuat karakter-karakter dari string di dalam argumen keduanya. Fungsi ini menghasilkan panjang segmen.

Latihan

1) Tulislah sebuah program yang membalikkan urutan bit di dalam sebuah nilai bertipe unsigned int. Program harus memasukkan nilai dari pengguna dan memanggil fungsi balikBit untuk menampilkan bit-bit dalam urutan terbalik. Tampilkan nilai sebelum dan sesudah bit dibalikkan untuk mengkonfirmasi bahwa pembalikan bit telah dilakukan secara benar.

2) Tulislah sebuah program yang mengentrikan suatu karakter dari papanketik dan menguji karakter tersebut menggunakan setiap fungsi di dalam pustaka karakter. Tampilkan nilai balik setiap fungsi tersebut.

3) Tulislah sebuah program yang mengentrikan sebaris teks dengan fungsi anggota getline (pada kelas istream) ke dalam array karakter s[100]. Tampilkan sebaris teks tersebut dengan semua huruf kecil dan semua huruf besar.

4) Tulislah sebuah program yang mengentrikan empat string yang merepresentasikan empat integer, kemudian konversilah string menjadi integer, jumlahkan nilainya dan tampilkan total keempat nilai yang didapatkan.

Algoritma, Struktur Data, dan Pemrograman

Menu

Friday, December 23, 2016

Bab 11. C++ Untuk Programer

No comments:

Post a Comment