Bab 2. Pemrograman C# Belajar Dari Contoh

2. Tipe Data, Literal, dan Variabel

Mengapa Tipe Data Penting

Tipe data sangat penting dalam C# karena semua operasi diperiksa oleh kompiler tentang kompatibilitas tipenya. Operasi yang ilegal tidak dapat dikompilasi. Hal ini mendukung kehandalan dalam pencegahan error. Untuk mendukung kehandalan pemrograman, semua variabel, ekspresi, dan nilai harus memiliki sebuah tipe data. Tipe data suatu variabel menentukan operasi apa saja yang diijinkan untuk diterapkan pada nilai variabel. Operasi yang dapat diterapkan pada suatu tipe bisa jadi tidak dapat diterapkan pada tipe data lain.

Tipe Data Dalam C#

C# memuat dua kategori umum dari tipe data built-in: tipe nilai dan tipe referensi. Perbedaan antara dua tipe itu adalah apa yang dimuat oleh suatu variabel. Untuk tipe nilai, variabel dapat menampung suatu nilai, seperti 3.1416 atau 212. Untuk tipe referensi, variabel dapat memuat sebuah referensi ke suatu nilai. Tipe referensi yang paling umum dipakai adalah kelas, dan diskusi tentang kelas dan tipe referensi akan dilakukan secara detil pada buku ini. Yang dibahas pada bab ini hanya tipe nilai.

Tipe	Arti
bool	Merepresentasikan nilai true/false
byte	Integer tak-bertanda 8-bit
char	Karakter
decimal	Nilai numerik untuk perhitungan keuangan
double	Titik mengambang kepresisian ganda
float	Titik mengambang kepresisian tunggal
int	Integer
long	Long integer
sbyte	Integer bertanda 8-bit
short	Integer short
uint	Integer tak-bertanda
ulong	Long tak-bertanda
ushort	Short tak-bertanda

Tabel 2.1 Tipe-tipe nilai dalam C#

Dalam C#, terdapat 13 tipe nilai seperti ditampilkan pada Tabel 2.1. Secara kolektif, tipe nilai disebut pula dengan tipe sederhana atau tipe primitif. Disebut dengan tipe sederhana karena hanya memuat satu nilai.

Integer

C# mendefinisikan sembilan tiga integer: char, byte, sbyte, short, ushort, int, uint, long, dan ulong. Tetapi, tipe char secara umum dipakai untuk merepresentasikan karakter, dan akan didiskusikan nanti pada akhir bab ini. Delapan tipe integer lainnya dipakai untuk perhitungan numerik. Lebar-bidang dan rentang dari delapan tipe integer tersebut ditampilkan di sini:

Seperti ditunjukkan pada tabel, C# mendefinisikan versi bertanda dan tak-bertanda dari berbagai tipe integer. Perbedaan antara integer bertanda dan tak-bertanda adalah bagaiman bit paling signifikan (MSB, most significant bit) diinterpretasikan. Jika integer bertanda dispesifikasi, maka kompiler C# akan menghasilkan kode yang mengasumsikan bahwa bit paling signifikan dari suatu integer dipakai sebagai flag. Jika tanda flag adalah 0, maka angka tersebut positif; jika flag adalah 1, maka angka tersebut negatif. Angka negatif direpresentasikan menggunakan pendekatan komplemen dua. Dengan metode ini, semua bit dalam angka negatif dibalik, kemudian ditambahkan 1.

Integer bertanda penting untuk banyak algoritma, tetapi hanya memiliki magnitudo setengah dari versi integer tak-bertanda. Sebagai contoh, sebuah short, di sini adalah 32,767:

0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

Untuk nilai tak-bertanda, jika bit paling signifikan ditetapkan 1, maka angka tersebut akan diinterpretasikan sebagai -1 (dalam format komplemen dua). Namun, jika Anda mendeklarasikannya sebagai ushort, maka ketika bit paling signifikan ditetapkan 1, angka tersebut akan menjadi 65,535.

Yang paling umum dipakai dari tipe integer adalah int. Variabel bertipe int seringkali dipakai untuk mengendalikan loop, untuk mengindeks array, dan untuk kepentingan matematika. Ketika Anda membutuhkan sebuah integer yang memiliki rentang nilai lebih dari int, maka Anda mempunyai banyak opsi. Jika nilai yang ingin disimpan adalah tak-bertanda, maka Anda bisa memakai uint. Untuk nilai bertanda yang besar, gunakan long. Untuk nilai tak-bertanda yang besar, gunakan ulong. Sebagai contoh, berikut adalah sebuah program yang menghitung jarak dari Bumi ke Matahari, dalam inci. Karena nilai ini terlalu besar, program menggunakan variabel long untuk menampungnya.

// Menghitung jarak dari Bumi ke Matahari dalam inci.

using System;

class Inci

{

    static void Main() {

        long inci;

        long mile;

       

        mile = 93000000; // 93,000,000 mile ke matahari

       

        // 5,280 kaki dalam satu mile, 12 inci dalam satu kaki.

        inci = mile * 5280 * 12;

       

        Console.WriteLine("Jarak ke matahari : " +

        inci + " inci.");

    }

}

Berikut adalah keluaran program:

Jarak ke matahari : 5892480000000 inci.

Jelaslah, hasil yang diperoleh tidak mungkin ditampung oleh variabel bertipe int atau uint.

Tipe integer terkecil adalah byte dan sbyte. Tipe byte merupakan nilai tak-bertanda dalam rentang 0 dan 255. Variabel bertipe byte berguna ketika bekerja dengan data biner, seperti aliran byte yang dihasilkan oleh divais tertentu. Untuk integer kecil tak-bertanda, gunakan sbyte.  Berikut disajikan contoh penggunaan variabel bertipe byte untuk mengendalikan sebuah loop for yang menghasilkan penjumlahan angka 0 sampai 100.

// Menggunakan byte.

using System;

class Menggunakan_byte {

    static void Main() {

        byte x;

        int jum;

        jum = 0;

        for (x = 1; x <= 100; x++)

            jum = jum + x;

       

        Console.WriteLine("Penjumlahan dari 0-100 adalah " + jum);

    }

}

Keluaran program ditampilkan di sini:

Penjumlahan dari 0-100 adalah 5050

Karena loop for hanya dijalankan dari 0 sampai 100, yang berada dalam rentang suatu byte, maka tidak diperlukan variabel bertipe yang lebih besar untuk mengendalikannya.

Ketika Anda memerlukan sebuah integer yang lebih besar dari byte atau sbyte, tetapi lebih kecil dari int atau uint, Anda bisa menggunakan short atau ushort.

Tipe Titik-Mengambang

Tipe titik-mengambang (floating-point) dapat merepresentasikan angka dengan komponen fraksional. Ada dua jenis tipe titik-mengambang, float dan double, yang merepresentasikan angka kepresisian tunggal dan kepresisian ganda. Tipe float berlebar 32 bit dan memiliki rentang berkisar 1.5E-45 sampai 3.4E+38. Tipe double berlebar 64 bit dan memiliki rentang berkisar 5E-324 sampai 1.7E308.

Dari keduanya, double adalah yang paling umum digunakan. Alasannya adalah bahwa banyak fungsi matematika dalam pustaka kelas C# (yang merupakan pustaka Framework .NET) menggunakan nilai-nilai double. Sebagai contoh, metode Sqrt() (yang didefinisikan oleh kelas System.Math) menghasilkan nilai balik bertipe double, yang merupakan akar kuadrat dari argumen bertipe double. Berikut disajikan Sqrt() yang dipakai untuk menghitung radius suatu lingkaran bila diberikan luas lingkaran.

// Menemukan radius dari luas suatu lingkaran.

using System;

class FindRadius {

  static void Main() {

      Double r;

      Double luas;

      luas = 10.0;

      r = Math.Sqrt(luas / 3.1416);

      Console.WriteLine("Radius adalah " + r);

  }

}

Keluaran program ditampilkan di sini:

Radius adalah 1.78412203012729

Seperti disebutkan sebelumnya, Sqrt() adalah anggota dari kelas Math. Perhatikan bagaimana Sqrt() dipanggil; diawali dengan nama Math. Sama dengan Console yang mengawali WriteLine().

Program berikut mendemonstrasikan beberapa fungsi trigonometrik C#, yang juga merupakan bagian dari pustaka matematika C#. Semua fungsi tersebut diterapkan pada data double. Program menampilkan sinus, kosinus, dan tangent untuk sudut (dalam radian) dari 0.1 sampai 1.0.

// Mendemonstrasikan Math.Sin(), Math.Cos(), dan Math.Tan().

using System;

class Trigonometri {

    static void Main() {

        Double theta; // sudut dalam radian

       

        for (theta = 0.1; theta <= 1.0; theta = theta + 0.1) {

            Console.WriteLine("Sinus dari " + theta + " adalah " +

                               Math.Sin(theta));

           

            Console.WriteLine("Kosinus dari " + theta + " adalah " +

                               Math.Cos(theta));

           

            Console.WriteLine("Tangent dari " + theta + " adalah " +

                               Math.Tan(theta));

           

            Console.WriteLine();

        }

    }

}

Berikut adalah keluaran program:

Sinus dari 0.1 adalah 0.0998334166468282

Kosinus dari 0.1 adalah 0.995004165278026

Tangent dari 0.1 adalah 0.100334672085451

Sinus dari 0.2 adalah 0.198669330795061

Kosinus dari 0.2 adalah 0.980066577841242

Tangent dari 0.2 adalah 0.202710035508673

Sinus dari 0.3 adalah 0.29552020666134

Kosinus dari 0.3 adalah 0.955336489125606

Tangent dari 0.3 adalah 0.309336249609623

Sinus dari 0.4 adalah 0.389418342308651

Kosinus dari 0.4 adalah 0.921060994002885

Tangent dari 0.4 adalah 0.422793218738162

Sinus dari 0.5 adalah 0.479425538604203

Kosinus dari 0.5 adalah 0.877582561890373

Tangent dari 0.5 adalah 0.54630248984379

Sinus dari 0.6 adalah 0.564642473395035

Kosinus dari 0.6 adalah 0.825335614909678

Tangent dari 0.6 adalah 0.684136808341692

Sinus dari 0.7 adalah 0.644217687237691

Kosinus dari 0.7 adalah 0.764842187284489

Tangent dari 0.7 adalah 0.842288380463079

Sinus dari 0.8 adalah 0.717356090899523

Kosinus dari 0.8 adalah 0.696706709347166

Tangent dari 0.8 adalah 1.02963855705036

Sinus dari 0.9 adalah 0.783326909627483

Kosinus dari 0.9 adalah 0.621609968270665

Tangent dari 0.9 adalah 1.26015821755034

Sinus dari 1 adalah 0.841470984807896

Kosinus dari 1 adalah 0.54030230586814

Tangent dari 1 adalah 1.5574077246549

Untuk menghitung sinus, kosinus, dan tangent, gunakan metode-metode pustaka standar Math.Sine(), Math.Cos(), dan Math.Tan(). Seperti Math.Sqrt(), semua metode trigonometrik dipanggil dengan sebuah argumen double dan menghasilkan nilai balik bertipe double. Sudut harus dalam radian.

Tipe Desimal

Yang paling menarik dari tipe data numerik dalam C# adalah tipe decimal, yang dimaksudkan untuk digunakan dalam kalkulasi moneter. Tipe decimal menggunakan 128 bit untuk merepresentasikan nilai di dalam rentang 1E-28 sampai 7.9E+28. Seperti Anda ketahui, aritmatika titik-mengambang sangat rentan terhadap berbagai error pembulatan ketika diterapkan pada nilai desimal. Tipe decimal mengeliminasi error tersebut dan dapat secara akurat merepresentasikan sampai dengan 28 posisi desimal. Kemampuan ini dipakai untuk merepresentasikan nilai desimal tanpa error pembulatan sehingga cocok untuk komputasi yang melibatkan uang.

Berikut disajikan suatu program yang menggunakan tipe decimal dalam kalkulasi finansial. Program ini menghitung harga yang telah didiskon dari harga awal dan persentase diskon.

// Menggunakan tipe decimal untuk menghitung diskon.

using System;

class GunakanDecimal {

    static void Main() {

        decimal harga;

        decimal diskon;

        decimal harga_diskon;

       

        // menghitung harga setelah diskon.

        harga = 19000.95m;

        diskon = 0.15m; // persen diskon adalah 15%

        harga_diskon = harga - (harga * diskon);

        Console.WriteLine("Harga Setelah Diskon: Rp." + harga_diskon);

    }

}

Keluaran program ditunjukkan di sini:

Harga Setelah Diskon: Rp.16150.8075

Di dalam program, perhatikan bahwa konstanta desimal diikuti dengan sufiks m. Ini perlu karena tanpa sufiks, nilai ini akan diinterpretasikan sebagai konstanta titik-mengambang standar, yang tidak kompatibel dengan tipe data decimal. Anda dapat menugaskan sebuah nilai integer, seperti 10, kepada variabel decimal tanpa menggunakan sufiks m. (Diskusi detil tentang konstanta numerik diberikan di akhir bab).

Berikut adalah contoh lain yang menggunakan tipe decimal. Program ini menghitung nilai masa depan dari sebuah investasi yang memiliki laju bunga tetap pada suatu periode (beberapa tahun).

/*

Menggunakan tipe decimal untuk menghitung

nilai masa depan dari suatu investasi.

*/

using System;

class NilaiMasaDepan {

    static void Main() {

        decimal investasi;

        decimal laju_bunga;

        int tahun, i;

        investasi = 1000.0M;

        laju_bunga = 0.07M;

        tahun = 10;

       

        Console.WriteLine("Investasi awal: Rp." + investasi);

        Console.WriteLine("Laju bunga: " + laju_bunga);

        Console.WriteLine("Selama " + tahun + " tahun");

       

        for (i = 0; i < tahun; i++)

            investasi = investasi + (investasi * laju_bunga);

        Console.WriteLine("Nilai masa depan adalah Rp." + investasi);

    }

}

Keluaran program ditampilkan di sini:

Investasi awal: Rp.1000.0

Laju bunga: 0.07

Selama 10 tahun

Nilai masa depan adalah Rp.1967.151357289565322490000

Perhatikan bahwa hasil yang didapatkan akurat dengan 21 dijit di belakang titik desimal, mungkin lebih dari yang Anda perlukan.

Karakter

Dalam C#, karakter bukan suatu kuantitas 8-bit seperti di dalam banyak bahasa pemrograman lainnya, seperti C++. C# menggunakan tipe karakter 16-bit yang dikenal dengan Unicode. Unicode mendefinisikan himpunan karakter yang cukup besar dalam merepresentasikan karakter dalam semua bahasa manusia. Meskipun banyak bahasa seperti, Indonesia, English, dan French menggunakan alfabet yang relatif sedikit, beberapa bahasa, seperti Chinese, menggunakan himpunan karakter yang tidak bida direpresentasikan hanya dengan 8 bit. Untuk mengatasi situasi ini, dalam C#, diberikan tipe char yang merupakan sebuah tipe tak-bertanda 16-bit dengan rentang 0 sampai 65,535. Himpunan karakter ASCII 8-bit standar adalah subhimpunan dari Unicode dengan rentang 0 sampai 127. Jadi, karakter-karakter ASCII masih merupakan karaker C# yang valid.

Variabel karakter dapat ditugasi sebuah nilai dengan mengapit karakter dengan dua kutip tunggal. Sebagai contoh, hal ini menugaskan X kepada variabel ch:

char ch;

ch = 'X';

Anda dapat menampilkan nilai char menggunakan statemen WriteLine(). Sebagai contoh, baris ini menampilkan nilai di dalam ch:

Console.WriteLine("Ini adalah ch: " + ch);

Meskipun char didefinisikan oleh C# sebagai sebuah tipe integer, tipe ini tidak dapat dengan bebas dicampur dengan integer pada semua kasus. Ini karena tidak adanya konversi tipe otomatis dari integer menjadi char. Sebagai contoh, fragmen berikut adalah tak-valid:

char ch;

ch = 88; // error, tak-valid

Alasannya adalah bahwa 88 adalah sebuah nilai integer, dan nilai itu tidak secara otomatis dikonversi menjadi sebuah char. Jika Anda mencoba mengkompilasi kode ini, Anda akan mendapatkan pesan error. Untuk membuat penugasan ini menjadi legal, Anda perlu menerapkan cast, yang akan didiskusikan nanti pada bab ini.

Tipe bool

Tipe bool merepresentasikan nilai true/false. C# mendefinisikan nilai true dan false menggunakan katakunci reservasi true dan false. Jadi, sebuah variabel atau ekspresi bertipe bool akan bernilai salah satu dari dua nilai tersebut. Di samping itu, tidak ada konversi yang didefinisikan antara bool dan nilai integer. Misalnya, 1 tidak dikonversi menjadi true, dan 0 tidak dikonversi menjadi false.

Berikut adalah sebuah program yang mendemonstrasikan tipe bool:

// Menggunakan nilai bool.

using System;

class DemoBool

{

    static void Main() {

        bool b;

       

        b = false;

        Console.WriteLine("b adalah " + b);

        b = true;

        Console.WriteLine("b adalah " + b);

       

        // Nilai bool dapat mengendalikan statemen if.

        if (b) Console.WriteLine("Ini dieksekusi.");

       

        b = false;

        if (b) Console.WriteLine("Ini tidak dieksekusi.");

       

        // Keluaran dari operator relasional adalah nilai bool.

        Console.WriteLine("10 > 9 adalah " + (10 > 9));

    }

}

Keluaran program ditampilkan di sini:

b adalah False

b adalah True

Ini dieksekusi.

10 > 9 adalah True

Ada tiga hal menarik yang perlu diperhatikan. Pertama, seperti Anda lihat, ketika suatu nilai bool ditampilkan dengan WriteLine(), “True” atau “False” ditampilkan. Kedua, nilai suatu variabel bool dapat dipakai untuk mengendalikan statemen if. Tidak diperlukan statemen if seperti ini:

if(b == true) ...

Ketiga, keluaran dari suatu operator relasional, seperti <, adalah sebuah nilai bool.  Ini mengapa ekspresi 10>9 menampilkan nilai “True”. Di samping itu, sepasang kurung untuk mengapit ekspresi 10>9 diperlukan karena operator + mempunyai derajat keutamaan yang lebih dari >.

Beberapa opsi Keluaran

Sampai di titik ini, ketika data ditampilkan menggunakan statemen WriteLine(), keluarannya ditampilkan menggunakan format default. Tetapi, Framework .NET mendefinisikan mekanisme pemformatan yang memberikan Anda kendali untuk bagaimana data ditampilkan. Meskipun I/O terformat dirangkum secara detil dalam buku ini, adalah hal yang bermanfaat untuk mengenalkan beberapa opsi pemformatan. Dengan opsi ini, Anda akan mampu menetapkan bagaimana tampilan keluaran menggunakan statemen WriteLine().

Ketika menampilkan runtun data, Anda dapat memisahkan setiap bagian data dengan tanda plus, seperti ditampilkan di sini:

Console.WriteLine("Anda memesan " + 2 + " item harga Rp." + 3 + " masing-masing.");

Meskipun cukup nyaman, penampilan informasi numerik dengan cara ini tidak memberikan Anda kendali dalam bagaimana menampilkan informasi. Sebagai contoh, untuk nilai titik-mengambang, Anda tidak dapat mengendalikan jumlah desimal yang akan ditampilkan. Perhatikan statemen berikut:

Console.WriteLine("Berikut adalah 10/3: " + 10.0/3.0);

menghasilkan keluaran ini:

Berikut adalah 10/3: 3.33333333333333

Meskipun ini baik untuk beberapa tujuan, menampilkan begitu banyak desimal di belakang titik desimal bisa jadi tidak cocok untuk tujuan tertentu. Sebagai contoh, dalam kalkulasi finansial, Anda biasanya hanya ingin menampilkan dua titik desimal di belakang titik desimal.

Untuk mengendalikan bagaimana data numerik diformat, Anda perlu menggunakan format kedua dari metode WriteLine(), seperti ditunjukkan di sini, yang membolehkan Anda untuk memformat informasi:

WriteLine(“string format”, arg0, arg1, ... , argN);

Dalam versi ini, argumen pada WriteLine() dipisahkan dengan koma dan bukan tanda +. string format memuat dua item: reguler, karakter yang akan ditampilkan, dan penspesifikasi format. Penspesifikasi format memiliki bentuk umum:

{argnum, width: fmt}

Di sini, argnum menspesifikasi jumlah argumen (mulai dari nol) yang akan ditampilkan. Lebar bidang minimum dispesifikasi oleh width, dan format dispesifikasi oleh fmt. width dan fmt bersifat opsional.

Selama eksekusi, ketika sebuah penspesifikasi format dijumpai di dalam string format, argumen terkait, yang dispesifikasi oleh argnum, diganti dan ditampilkan. Jadi, posisi dari spesifikasi format di dalam string format menentukan dimana data akan ditampilkan. Oleh karena itu, dalam bentuk sederhananya, penspesifikasi format mengindikasikan argumen mana yang akan ditampilkan. Sebagai contoh, {0} mengindikasikan arg0, {1} mengindikasikan arg1, dan seterusnya.

Dimulai dari contoh sederhana. Statemen

Console.WriteLine("Pebruari mempunyai {0} atau {1} hari.", 28, 29);

menghasilkan keluaran berikut:

Pebruari mempunyai 28 atau 29 hari.

Seperti yang Anda lihat, nilai 28 menggantikan {0}, dan 29 menggantikan {1}. Jadi, penspesifikasi format mengidentifikasi lokasi dimana argumen berurutan, dalam kasus ini 28 dan 29, ditampilkan di dalam string. Di samping itu, perhatikan nilai-nilai yang dipisahkan dengan koma, bukan dengan tanda +.

Berikut adalah variasi dari statemen sebelumnya yang menspesifikasi lebar bidang minimum:

Console.WriteLine("Pebruari mempunyai {0,10} atau {1,5} hari.", 28, 29);

menghasilkan keluaran berikut:

Pebruari mempunyai         28 atau              29 hari.

Seperti yang Anda lihat, spasi ditambahkan untuk mengisi bidang yang tidak dipakai.

Argumen yang berkaitan dengan perintah format tidak harus konstanta. Sebagai contoh, program ini menampilkan tabel kuadrat dan kubik, yang menggunakan perintah format dalam menampilkan nilai.

// Menggunakan perintah format.

using System;

class OpsiPenampilan {

    static void Main()

    {

        int i;

       

        Console.WriteLine("Nilai\tKuadrat\tKubik");

        for (i = 1; i < 10; i++)

            Console.WriteLine("{0}\t{1}\t{2}", i, i * i, i * i * i);

    }

}

Keluaran ditampilkan di sini:

Nilai   Kuadrat Kubik

1       1       1

2       4       8

3       9       27

4       16      64

5       25      125

6       36      216

7       49      343

8       64      512

9       81      729

Cara termudah menspesifikasi suatu format adalah menyediakan sebuah template yang akan digunakan WriteLine(). Untuk melakukannya, tunjukkan contoh format yang Anda inginkan menggunakan tanda # untuk menandai posisi dijit. Anda juga dapat menspesifikasi titik desimal dan koma. Sebagai contoh, berikut adalah cara yang lebih baik dalam menampilkan 10 dibagi dengan 3:

Console.WriteLine("Berikut adalah 10/3: {0:#.##}", 10.0/3.0);

Keluaran dari statemen di atas adalah

Berikut adalah 10/3: 3.33

Pada contoh tersebut, template yang dipakai adalah #.##, yang memberitahukan WriteLine() untuk menampilkan dua dijit di belakang titik desimal. Penting dipahami bahwa WriteLine() dapat menampilkan lebih dari satu dijit di depan titik desimal, jika diperlukan.

Berikut adalah satu contoh lain. Statemen

Console.WriteLine("{0:###,###.##}", 123456.56);

menghasilkan keluaran ini:

123,456.56

Jika Anda ingin menampilkan nilai moneter, gunakan penspesifikasi format C. Sebagai contoh,

decimal uang;

uang = 12323.09m;

Console.WriteLine("Uang saat ini adalah {0:C}", uang);

Keluarannya adalah (format dalam dollar Amerika):

Uang saat ini adalah $12,323.09

Format C dapat pula dipakai untuk memperbaiki keluaran dari program diskon harga yang telah diberikan sebelumnya:

// Menggunakan format C untuk menampilkan dollar dan cent.

using System;

class GunakanDecimal2

{

    static void Main() {

        decimal harga;

        decimal diskon;

        decimal harga_diskon;

      

        // Menghitung harga diskon.

        harga = 19.95m;

        diskon = 0.15m; // persen diskon 15%

        harga_diskon = harga - (harga * diskon);

        Console.WriteLine("Harga setelah diskon: {0:C}", harga_diskon);

    }

}

Berikut adalah keluaran program:

Harga setelah diskon: $16.96

Literal

Dalam C#, literal berarti nilai tetap yang direpresentasikan dalam format bacaan manusia. Sebagai contoh, angka 100 adalah sebuah literal. Literal dan kegunaannya telah digunakan dalam suatu format pada beberapa contoh program sebelumnya. Sekarang saatnya membahasnya secara formal.

Literal C# dapat berupa sembarang tipe sederhana. Cara setiap literal direpresentasikan bergantung pada tipenya. Seperti dijelaskan sebelumnya, literal string diapit dengan dua tanda kutip tunggal. Misalnya, ‘a’ dan ‘%’ keduanya adalah literal string.

Literal integer dispesifikasi sebagai angka tanpa komponen pecahan. Sebagai contoh, 10 dan -100 keduanya adalah literal integer. Literal titik-mengambang memerlukan titik desimal yang diikuti dengan komponen pecahan. Sebagai contoh, 11.123 adalah literal titik-mengambang. C# juga membolehkan Anda untuk menggunakan notasi saintifik bagi angka titik-mengambang.

Dalam C#, literal memiliki tipe. Pertanyaannya adalah tipe apakah literal numerik? Sebagai contoh, apakah tipe dari 12, 123987, atau 0.23? Untungnya, C# menspesifikasi beberapa aturan sederhana yang bisa menjawab pertanyaan ini.

Pertama, untuk literal integer, tipe literal adalah tipe integer terkecil yang bisa menampungnya, dimulai dari int. Jadi, sebuah literal integer adalah bertipe int, uint, long, atau ulong, bergantung pada nilainya. Kedua, literal titik-mengambang adalah bertipe double.

Jika tipe default C# bukanlah yang Anda inginkan untuk sebuah literal, Anda bisa menspesifikasi secara eksplisit tipenya dengan mencantumkan sufiks. Untuk menspesifikasi sebuah literal long, tempelkan l atau L. Sebagai contoh, 12 adalah sebuah int, tetapi 12L adalah sebuah long. Untuk menspesifikasi sebuah integer tak-bertanda, tempelkan u atau U. Jadi, 100 adalah sebuah int, tetapi 100U adalah uint. Untuk menspesifikasi integer long tak-bertanda, gunakan ul atau UL. Sebagai contoh, 984375UL bertipe ulong.

Untuk menspesifikasi literal float, tempelkan F atau f pada nilai. Sebagai contoh, 10.19F adalah bertipe float. Meskipun berlebihan, Anda dapat menspesifikasi literal double dengan menempelkan D atau d. (Seperti disebutkan sebelumnya, literal titik-mengambang secara default adalah double).

Untuk menspesifikasi literal decimal, nilai terkait diikuti dengan m atau M. Sebagai contoh, 9.9M adalah sebuah literal decimal.

Literal Heksadesimal

Seperti yang Anda ketahui, dalam pemrograman kadangkala lebih mudah untuk menggunakan sistem bilangan berbasis 16 menggantikan basis 10. Sistem bilangan basis 16 disebut dengan heksadesimal dan menggunakan dijit 0 sampai 9 dan huruf A sampai F (yang mewakili nilai 10, 11, 12, 13, 14, dan 15). Sebagai contoh, bilangan heksadesimal 10 adalah 16 dalam desimal. Karena frekuensi penggunaan angka heksadesimal yang sangat tinggi, C# membolehkan Anda untuk menspesifikasi literal integer dalam format heksadesimal. Literal heksadesimal harus diawali dengan 0x. Berikut adalah dua contoh literal heksadesimal:

hitung = 0xFF; // 255 dalam desimal

tambah = 0x1a; // 26 dalam desimal

Runtun Escape

Literal karakter yang diapit dengan dua kutip tunggal berlaku pada hampir semua karakter, kecuali bebera karakter, seperti carriage return. Selain itu, untuk beberapa karakter tertentu, kutip tunggal dan kutip ganda, memiliki makna spesial dalam C#, sehingga Anda tidak dapat menggunakannya secara langsung. Karena dua alasan ini, C# menyediakan beberapa runtun escape spesial, yang kadangkala dikenal pula sebagai konstanta karakter backslash, yang ditampilkan pada Tabel 2.2.

Sebagai contoh, statemen berikut menugasi ch dengan karakter tab:

ch = '\t';

Contoh selanjutnya menugaskan sebuah kutip tunggal pada ch:

ch = '\'';

Runtun escape	Deskripsi
\a	Alert (bell)
\b	Backspace
\f	Form feed
\n	New line (garis baru)
\r	Carriage return
\t	Tab horisontal
\v	Tab vertikal
\0	Null
\’	Kutip tunggal
\”	Kutip ganda
\\	Backslash

Tabel 2.2 Runtun escape

Literal String

C# mendukung satu lagi tipe literal: literal string. Literal string adalah himpunan karakter yang diapit oleh dua kutip ganda. Sebagai contoh,

“Ini adalah literal string”

adalah sebuah literal string. Anda telah melihat banyak literal string pada statemen WriteLine() pada beberapa program terdahulu. Di samping karakter normal, literal string dapat pula memuat satu atau lebih runtun escape. Sebagai contoh, perhatikan program berikut, yang menggunakan runtun escape \n dan \t.

// Demonstrasi runtun escape dalam string.

using System;

class DemoString

{

    static void Main() {

        Console.WriteLine("Baris Satu\nBaris Dua\nBaris Tiga");

        Console.WriteLine("Satu\tDua\tTiga");

        Console.WriteLine("Empat\tLima\tEnam");

       

        // Menampilkan kutip

        Console.WriteLine("\"Kenapa?\", Dia berujar.");

    }

}

Keluaran program adalah:

Baris Satu

Baris Dua

Baris Tiga

Satu    Dua     Tiga

Empat   Lima    Enam

"Kenapa?", Dia berujar.

Perhatikan bagaimana runtun escape \n dipakai untuk menghasilkan baris baru. Anda tidak perlu menggunakan beberapa statemen WriteLine() untuk mendapatkan keluaran banyak baris baru. Anda hanya perlu menyisipkan \n di dalam string panjang pada titik dimana Anda ingin baris baru diperlukan. Selain itu, perhatikan juga bagaimana tanda kutip ganda dihasilkan di dalam suatu string.

Selain format literal string yang baru saja dijelaskan, Anda juga dapat menspesifikasi literal string verbatim. Literal string verbatim diawali dengan @, yang diikuti oleh sebuah string yang dikutip. Jadi, Anda dapat menyertakan baris-baru, tab, dan lainnya, tetapi Anda tidak perlu menggunakan runtun escape. Satu-satunya pengecualian adalah bahwa untuk mendapatkan kutip ganda (“), Anda harus menggunakan dua kutip ganda secara berurutan (“”). Berikut adalah sebuah program yang mendemonstrasikan literal string verbatim:

// Demonstrasi literal string verbatim.

using System;

class Verbatim {

  static void Main() {

      Console.WriteLine(@"Ini adalah literal

string verbatim yang

ditempatkan pada beberapa baris.

");

      Console.WriteLine(@"Berikut adalah keluaran yang ditab:

1   2   3   4

5   6   7   8

");

      Console.WriteLine(@"Programer berkata, ""Saya suka C#.""");

  }

}

Keluaran program adalah:

Ini adalah literal

string verbatim yang

ditempatkan pada beberapa baris.

Berikut adalah keluaran yang ditab:

1   2   3   4

5   6   7   8

Programer berkata, "Saya suka C#."

Hal penting yang perlu diperhatikan dalam program tersebut adalah bahwa literal string verbatim ditampilkan persis sama dengan apa yang dituliskan di dalam program.

Keuntungan literal string verbatim adalah bahwa Anda dapat menentukan keluaran di dalam program Anda yang sama persis dengan apa tertampil pada layar. Namun, pada kasus string baris-jamak, identasi (pengaturan posisi) akan mengaburkan kemudahan pembacaan program. Karena alasan ini, semua program pada buku ini membatasi penggunaan literal string. Yang perlu Anda ingat adalah bahwa literal string verbatim bisa berguna pada banyak situasi pemformatan.

Satu hal terakhir: Jangan bingung dalam membedakan string dengan karakter. Literal karakter, seperti ‘X’, merepresentasikan huruf bertipe char. Literal string yang hanya memuat satu huruf, seperti “X”, tetap sebuah string.

Lebih Dekat Dengan Variabel

Variabel dideklarasikan menggunakan format statemen berikut:

tipe nama-var;

dimana tipe adalah tipe data variabel dan nama-var adalah namanya. Anda dapat mendeklarasikan sebuah variabel bertipe sembarang (yang valid). Adalah hal penting untuk memahami bahwa kapabilitas suatu variabel ditentukan oleh tipenya. Sebagai contoh, variabel bertipe bool tidak dapat dipakai untuk menyimpan nilai titik-mengambang. Selain itu, tipe suatu variabel tidak bisa diubah setelah pendeklarasiannya. Variabel bertipe int tidak bisa diubah menjadi bertipe char, misalnya.

Semua variabel dalam C# harus dideklarasikan sebelum digunakan. Sebagai aturan umum, hal ini diperlukan karena kompiler harus mengetahui tipe data sebuah variabel sebelum kompiler mengkompilasi sembarang statemen yang menggunakan variabel tersebut. Hal ini juga memampukan kompiler untuk melakukan pemeriksaan tipe.

C# mendefinisikan beberapa jenis variabel. Jenis variabel yang dipakai sejauh ini adalah variabel lokal karena dideklarasikan di dalam sebuah metode.

Menginisialisasi Variabel

Salah satu cara untuk memberikan nilai kepada sebuah variabel adalah melalui statemen penugasan, seperti yang Anda telah lakukan sebelumnya. Cara lainnya adalah dengan memberikan nilai awal ketika variabel tersebut dideklarasikan. Untuk melakukannya, nama variabel diikuti dengan tanda sama dengan dan nilai yang akan ditugaskan. Bentuk umum inisialisasi variabel ditampilkan di sini:

tipe nama-var = nilai;

Di sini, nilai adalah nilai yang akan diberikan kepada variabel ketika variabel itu diciptakan. nilai harus kompatibel dengan tipe yang dispesifikasi. Berikut diberikan beberapa contoh inisialisasi variabel:

int hitung = 10; // memberikan hitung nilai awal 10

char ch = 'X'; // menginisialisasi ch dengan huruf X

float f = 1.2F; // f diinisialisasi dengan 1.2

Ketika mendeklarasikan dua atau lebih variabel bertipe sama yang dipisahkan dengan koma, Anda dapat memberikannya nilai awal. Sebagai contoh,

int a, b = 8, c = 19, d; // b dan c mempunyai nilai awal

Pada kasus ini, hanya b dan c yang diinisialisasi.

Inisialisasi Dinamis

Meskipun contoh-contoh sebelumnya hanya menggunakan konstanta sebagai penginisialisasi, C# membolehkan variabel diinisialisasi secara dinamis, menggunakan sembarang ekspresi valid di titik dimana variabel tersebut dideklarasikan. Sebagai contoh, berikut adalah sebuah program pendek yang menghitung sisi miring dari sebuah segitiga, bila diberikan dua sisi lainnya.

// Demonstrasi inisialisasi dinamis.

using System;

class InisialDinamis {

    static void Main() {

        // Panjang kedua sisi.

        double s1 = 4.0;

        double s2 = 5.0;

       

        // Secara dinamis menginisialisasi sisi_miring.

        double sisi_miring = Math.Sqrt((s1 * s1) + (s2 * s2));

        Console.Write("Sisi miring suatu segitiga dengan kedua disi " +

                      s1 + " dan " + s2 + " adalah ");

        Console.WriteLine("{0:#.###}.", sisi_miring);

    }

}

Berikut adalah keluaran program:

Sisi miring suatu segitiga dengan kedua disi 4 dan 5 adalah 6.403.

Di sini, tiga variabel lokal, yaitu s1, s2, dan sisi_miring, dideklarasikan. Dua variabel pertama, s1 dan s2, diinisialisasi dengan konstanta. Namun, sisi_miring diinisialisasi secara dinamis dengan panjang sisi miring suatu segitiga. Perhatikan bahwa inisialisasi melibatkan pemanggilan Math.Sqrt(). Seperti yang telah dijelaskan, Anda dapat menggunakan sembarang ekspresi yang valid di titik inisialisasi. Karena pemanggilan terhadap Math.Sqrt() valid di titik tersebut, ia dapat dipakai di dalam inisialisasi sisi_miring.

Variabel Bertipe Implisit

Seperti yang telah dijelaskan, dalam C# semua variabel harus dideklarasikan. Normalnya, deklarasi mencakup tipe variabel, seperti int atau bool, diikuti dengan nama variabel. Namun, sejak C# 3.0, menjadi memungkinkan bagi kompiler dalam menentukan tipe suatu variabel lokal berdasarkan nilai yang dipakai untuk menginisialisasinya. Hal ini dikenal dengan variabel bertipe implisit.

Variabel bertipe implisit dideklarasikan menggunakan katakunci var, dan harus diinisialisasi. Kompiler menggunakan tipe penginisialisasi dalam menentukan tipe variabel. Berikut adalah sebuah contohnya:

var e = 2.7183;

Karena e diinisialisasi dengan literal titik-mengambang (secara default, double), maka tipe dari e adalah double. Jika e dideklarasikan seperti ini:

var e = 2.7183F;

maka e bertipe float.

Program berikut mendeklarasikan tipe variabel yang dideklarasikan secara implisit.

// Demonstrasi tipe variabel secara implisit.

using System;

class VariabelBertipeImplisit {

  static void Main() {

    // Berikut adalah variabel bertipe implisit.

    // Keduanya bertipe double karena ekspresi

    // penginisialisasi bertipe double.

    var s1 = 4.0;

    var s2 = 5.0;

    // Sekarang, sisi_miring bertipe implisit. Tipenya double

    // karena tipe nilai balik dari Sqrt() adalah double.

    var sisi_miring = Math.Sqrt( (s1 * s1) + (s2 * s2) );

    Console.Write("Sisi miring dari suatu segitiga dengan kedua sisi " +

                  s1 + " dan " + s2 + " adalah ");

    Console.WriteLine("{0:#.###}.", sisi_miring);

    // Statemen berikut tidak akan dikompilasi karena

    // s1 adalah sebuah double dan tidak dapat ditugasi nilai decimal.

    // s1 = 12.2M; // Error!

  }

}

Keluaran program sama dengan sebelumnya. Hal penting yang perlu ditekankan di sini adalah bahwa suatu variabel bertipe implisit tidak bisa diubah semena-mena. Perhatikan komentar ini di dalam program:

// s1 = 12.2M; // Error!

Penugasan ini tak valid karena s1 bertipe double. Jadi, ia tidak bisa ditugasi sebuah nilai decimal. Satu-satunya perbedaan antara variabel bertipe implisit dan variabel yang ditipe secara eksplisit adalah bagaimana tipe ditentukan. Begitu tipe telah ditentukan, variabel telah memiliki tipe, dan tipe ini tetap selama variabel itu eksis. Jadi, tipe dari s1 tidak dapat diubah selama ekskusi program.

Satu hal terakhir: Hanya boleh satu variabel bertipe implisit yang dapat dideklarasikan pada satu waktu. Oleh karena itu, deklarasi berikut:

var s1 = 4.0, s2 = 5.0; // Error!

adalah salah dan tidak bisa dikompilasi karena mencoba untuk mendeklarasikan s1 dan s2 pada waktu yang bersamaan.

Skop dan Usia Variabel

Sejauh ini, semua variabel yang dipakai dideklarasikan di awal metode Main(). Namun, C# membolehkan variabel lokal dideklarasikan di dalam sembarang blok. Blok diawali dengan kurung kurawal buka dan diakhiri dengan kurung kurawal tutup. Blok mendefinisikan skop. Jadi, setiap kali Anda memulai blok baru, itu artinya Anda menciptakan skop baru. Skop menentukan visibilitas nama-nama yang dikenali oleh bagian-bagian program Anda tanpa memerlukan kualifikasi. Skop juga menentukan usia variabel lokal.

Skop yang paling penting dalam C# adalah yang didefinisikan oleh suatu kelas dan yang didefinisikan oleh suatu metode. Diskusi tentang skop kelas (dan variabel yang dideklarasikan di dalamnya) dilakukan nanti pada buku ini. Untuk sekarang, hanya skop yang didefinisikan oleh metode yang akan dibahas.

Skop yang didefinisikan oleh metode diawali dengan kurung kurawal buka dan diakhiri dengan kurung kurawal tutunp. Namun, jika metode tersebut mempunyai parameter, parameter tersebut juga disertakan di dalam skop yang didefinisikan oleh metode.

Sebagai aturan umum, variabel lokal yang dideklarasikan di dalam sebuah skop tidak dikenali oleh kode yang didefinisikan di luar skop tersebut. Jadi, ketika Anda mendeklarasikan sebuah variabel di dalam suatu skop, maka Anda melindunginya dari akses atau modifikasi dari luar skop. Aturan skop merupakan fondasi bagi enkapsulasi.

Skop dapat dibuat bersarang. Ketika ini terjadi, skop sebelar luar mengapit skop sebelah dalam. Ini berarti bahwa variabel lokal yang dideklarasikan di dalam skop luar dapat dikenali oleh kode di dalam skop sebelah dalam. Tetapi tidak sebaliknya. Variabel lokal yang dideklarasikan di dalam skop sebelah dalam tidak dikenali oleh kode di luarnya (meski berada di dalam skop sebelah luar).

// Demonstrasi skop blok.

using System;

class DemoSkop {

    static void Main() {

        int x; // dikenali oleh semua kode di dalam Main()

       

        x = 10;

        if (x == 10)

        { // mulai skop baru

            int y = 20; // hanya dikenali di dalam blok ini

           

            // x dan y keduanya dikenali di sini.

            Console.WriteLine("x dan y: " + x + " " + y);

            x = y * 2;

        }

        // y = 100; // Error! y tidak dikenali di sini.

       

        // x masih dikenali di sini.

        Console.WriteLine("x adalah " + x);

    }

}

Keluaran program ditampilkan di sini:

x dan y: 10 20

x adalah 40

Seperti diindikasikan pada komentar, variabel x dideklarasikan di awal skop Main() dan dapat diakses (dikenali) oleh semua kode di dalam Main(). Di dalam blok if, y dideklarasikan. Karena blok mendefinisikan skop, y hanya dikenali oleh kode di dalam blok tersebut. Ini mengapa di luar blok tersebut, baris y = 100; tidak dikenali. Jika Anda menghapus simbol komentar //, maka error kompilasi akan terjadi karena y tidak di kenali di luar bloknya. Di dalam blok if, x dapat dipakai karena kode di dalam blok tersebut memiliki akses terhadap variabel tersebut.

Di dalam suatu blok, variabel dapat dideklarasikan dimanapun, tetapi hanya bisa diakses setelah titik pendeklarasiannya. Jadi, jika Anda mendefinisikan sebuah variabel di awal metode, maka variabel itu dapat diakses oleh semua kode di dalam metode tersebut. Sebaliknya, jika Anda mendeklarasikan variabel di akhir suatu blok, maka ia hanya menjadi variabel sia-sia, karena tidak ada kode yang dapat mengaksesnya.

Jika suatu deklarasi variabel melibatkan penginisialisasi, maka variabel tersebut akan diinisialiasi-ulang setiap kali blok yang memuatnya dimasuki program. Sebagai contoh, perhatikan program ini:

// Demonstrasi usia suatu variabel.

using System;

class VarInitDemo {

  static void Main() {

      int x;

      for(x = 0; x < 3; x++) {

          int y = -1; // y diinisialisasi setiap kali blok dimasuki

          Console.WriteLine("y adalah: " + y); // selalu menampilkan -1

         

          y = 100;

          Console.WriteLine("y sekarang menjadi: " + y);

      }

  }

}

Berikut adalah keluaran program:

y adalah: -1

y sekarang menjadi: 100

y adalah: -1

y sekarang menjadi: 100

y adalah: -1

y sekarang menjadi: 100

Seperti yang dapat Anda lihat, y selalu diinisialisasi-ulang dengan -1 setiap kali loop for dimasuki program. Meskipun y ditugasi nilai 100, nilai ini akan hilang.

Ada satu hal aneh dalam aturan skop C# yang bisa mengejutkan Anda: Meskipun blok bisa dibuat bersarang, tidak ada variabel yang dideklarasikan di dalam skop sebelah dalam yang dapat memiliki nama sama dengan variabel yang dideklarasikan oleh skop sebelah luar. Sebagai contoh, program berikut, yang mencoba mendeklarasikan dua variabel terpisah dengan nama sama, tidak akan berhasil dikompilasi.

/*

Program ini mencoba mendeklarasikan sebuah variabel

di dalam skop sebelah dalam dengan nama sama dengan

variabel yang didefinisikan di dalam skop sebelah luar.

*** Program ini tak akan bisa dikompilasi. ***

*/

using System;

class VariabelBersarang {

    static void Main() {

        int hitung;

        for (hitung = 0; hitung < 10; hitung = hitung + 1)

        {

            Console.WriteLine("Ini adalah hitung: " + hitung);

            int hitung; // ilegal!!!

            for (hitung = 0; hitung < 2; hitung++)

                Console.WriteLine("Program ini bermasalah!");

        }

    }

}

Jika Anda memiliki latar belakang pemrograman C/C++, maka Anda mengetahui tidak ada batasan nama seperti ini. Jadi, dalam C/C++ deklarasi hitung di dalam blok loop for sebelah dalam seutuhnya valid. Namun, dalam C/C++, deklarasi semacam itu akan menyembunyikan variabel sebelah luar. Perancang C# merasa bahwa jenis penyembunyian nama seperti ini dapat dengan mudah menyebabkan error pemrograman dan tidak mengijinkan penggunaannya.

Konversi Tipe dan Casting

Dalam pemrograman, adalah hal umum dijumpai untuk mengubah satu tipe variabel menjadi tipe lain. Sebagai contoh, Anda bisa jadi ingin menugaskan nilai int menjadi kepada sebuah variabel float, seperti ditunjukkan di sini:

int i;

float f;

i = 10;

f = i; // menugaskan int ke suatu float

Ketika beberapa tipe kompatibel dicampur di dalam suatu penugasan, nilai dari sisi sebelah kanan operator penugasan secara otomatis dikonversi menjadi tipe dari sisi sebelah kiri. Jadi, pada fragmen tersebut, nilai di dalam i dikonversi menjadi float dan kemudian ditugaskan kepada f. Namun, karena aturan pemeriksaan-tipe C#, tidak semua tipe kompatibel, dan jadi, tidak semua konversi secara implisit diijinkan. Sebagai contoh, bool dan int tidak kompatibel. Untungnya, masih dimungkinkan terjadinya konversi antara tipe-tipe tak-kompatibel menggunakan cast. Sebuah cast melakukan konversi eksplisit. Konversi tipe otomatis dan operasi cast didisikusikan di sini.

Konversi Otomatis

Ketika suatu tipe data ditugaskan kepada variabel bertipe lain, konversi tipe otomatis akan terjadi secara otomatis jika

·         Kedua tipe kompatibel.

·         Tipe tujuan memiliki rentang lebih besar dari tipe sumber.

Ketika kedua kondisi ini dipenuhi, konversi melebar akan terjadi. Sebagai contoh, tipe int selalu cukup besar untuk menampung nilai bertipe byte, dan kedua int dan byte merupakan tipe integer yang kompatibel, jadi konversi implisit bisa diterapkan.

Untuk konversi melebar, tipe-tipe numerik, termasuk tipe integer dan tipe titik-mengambang, adalah kompatibel satu sama lain. Sebagai contoh, program berikut valid karena konversi long menjadi double merupakan suatu konversi melebar yang secara otomatis dilakukan.

// Demonstrasi konversi implisit dari long ke double.

using System;

class LtoD {

    static void Main() {

        long L;

        double D;

      

        L = 100123285L;

        D = L;

       

        Console.WriteLine("L dan D: " + L + " " + D);

    }

}

Meskipun konversi implisit dari long menjadi double bisa dilakukan, konversi implisit dari double menjadi long tidak bisa dilakukan karena bukan merupakan konversi melebar. Jadi, versi berikut dari program sebelumnya menjadi tak-valid:

// *** Program ini tidak bisa dikompilasi. ***

using System;

class LtoD {

    static void Main() {

        long L;

        double D;

       

        D = 100123285.0;

        L = D; // Ilegal!!!

      

        Console.WriteLine("L dan D: " + L + " " + D);

    }

}

Selain pembatasan yang telah dijelaskan, konversi implisit antara decimal dan float atau double tidak bisa dilakukan, atau dari tipe numerik menjadi char atau double. Di samping itu, char dan bool tidak kompatibel satu sama lain.

Operasi Cast Atas Tipe Tak-Kompatibel

Meskipun konversi tipe implisit cukup membantu, operasi itu tidak bisa memenuhi semua kebutuhan pemrograman karena hanya bisa diterapkan pada konversi melebar di antara tipe-tipe kompatibel. Untuk kasus selain itu, Anda harus menerapkan cast. Sebuah cast adalah instruksi kepada kompiler untuk mengkonversi keluaran suatu ekspresi menjadi tipe yang diinginkan. Jadi, kompiler meminta dilakukan konversi tipe secara eksplisit. Operasi cast mempunyai bentuk umum:

(tipe-target) ekspresi

Di sini, tipe-target menspesifikasi tipe yang diinginkan. Sebagai contoh, diberikan

double x, y;

Jika Anda ingin tipe konversi x/y  menjadi int, Anda dapat menuliskan

(int) (x / y)

Di sini, meskipun x dan y bertipe double, operasi cast mengkonversi keluaran ekspresi menjadi int. Sepasang kurung yang mengapit x/y diperlukan. Karena jika kurung tidak digunakan, operasi cast hanya akan diterapkan pada x dan bukan pada keluaran pembagian. Operasi cast diperlukan di sini karena konversi implisit dari double menjadi int tidak bisa dilakukan.

Ketika operasi cast melibatkan konversi menyempit, informasi bisa hilang. Sebagai contoh, ketika operasi cast dilakukan terhadap long menjadi int, informasi bisa hilang jika nilai dari long lebih besar dari rentang sebuah int karena bit-bit signifikan akan terhapus. Ketika suatu nilai titik-mengambang dicast menjadi tipe integer, komponen pecahan akan hilang akibat pemotongan. Sebagai contoh, jika nilai 1.23 ditugaskan kepada sebuah integer, nilai yang dihasilkan adalah 1. Komponen pecahan 0.23 akan hilang.

Program berikut mendemonstrasikan beberapa konversi tipe yang memerlukan operasi cast. Program ini juga menunjukkan beberapa situasi dimana operasi cast dapat menyebabkan data hilang.

// Demonstrasi operasi cast.

using System;

class DemoCast {

  static void Main() {

    double x, y;

    byte b;

    int i;

    char ch;

    uint u;

    short s;

    long l;

    x = 10.0;

    y = 3.0;

    // Cast double menjadi int, komponen pecahan hilang.

    i = (int) (x / y);

    Console.WriteLine("Keluaran integer dari x / y: " + i);

    Console.WriteLine();

    // Cast int menjadi byte, tidak ada data hilang.

    i = 255;

    b = (byte) i;

    Console.WriteLine("b setelah penugasan 255: " + b +

                      " -- tidak data hilang.");

    // Cast int menjadi byte, data hilang.

    i = 257;

    b = (byte) i;

    Console.WriteLine("b setelah penugasan 257: " + b +

                      " -- data hilang.");

    Console.WriteLine();

    // Cast uint menjadi short, tidak ada data hilang.

    u = 32000;

    s = (short) u;

    Console.WriteLine("s setelah penugasan 32000: " + s +

                      " -- tidak ada data hilang.");

    // Cast uint menjadi short, data hilang.

    u = 64000;

    s = (short) u;

    Console.WriteLine("s setelah penugasan 64000: " + s +

                      " -- data hilang.");

    Console.WriteLine();

    // Cast long menjadi uint, tidak ada data hilang.

    l = 64000;

    u = (uint)l;

    Console.WriteLine("u setelah penugasan 64000: " + u +

                      " -- tidak ada data hilang.");

    // Cast dari long menjadi uint, data hilang.

    l = -12;

    u = (uint)l;

    Console.WriteLine("u setelah penugasan -12: " + u +

                      " -- data hilang.");

    Console.WriteLine();

    // Cast int menjadi char.

    b = 88; // kode ASCII untuk X

    ch = (char)b;

    Console.WriteLine("ch setelah penugasan 88: " + ch);

  }

}

Keluaran program ditampilkan di sini:

Keluaran integer dari x / y: 3

b setelah penugasan 255: 255 -- tidak data hilang.

b setelah penugasan 257: 1 -- data hilang.

s setelah penugasan 32000: 32000 -- tidak ada data hilang.

s setelah penugasan 64000: -1536 -- data hilang.

u setelah penugasan 64000: 64000 -- tidak ada data hilang.

u setelah penugasan -12: 4294967284 -- data hilang.

ch setelah penugasan 88: X

Akan diperiksa setiap penugasan. Operasi cast terhadap (x/y) menjadi int menghasilkan pemotongan komponen pecahan (fraksional), dan informasi hilang.

Tidak ada informasi yang hilang terjadi ketika b ditugasi nilai 255 karena sebuah byte dapat menampung nilai 255. Namun, ketika percobaan dilakukan untuk menugasi b dengan nilai 257, informasi hilang terjadi karena 257 melebihi rentang suatu byte. Pada kedua kasus, operasi cast dibutuhkan karena konversi implisit dari int menjadi byte tidak bisa dilakukan.

Ketika variabel short, s, ditugasi nilai 32,000 melalui variabel uint, u, tidak ada data yang hilang karena sebuah short dapat menampung nilai 32,000. Namun, dalam penugasan selanjutnya, u mempunyai nilai 64,000, yang berada di luar rentang sebuah short, dan data menjadi hilang. Pada kedua kasus, operasi cast diperlakukan karena konversi implisit dari uint menjadi short tidak bisa dilakukan.

Selanjutnya, u ditugasi nilai 64,000 melalui variabel long, l. Pada kasus ini, tidak ada data yang hilang karena 64,000 masih berada di dalam rentang sebuah uint.  Namun, ketika nilai -12 ditugaskan kepada u, data menjadi hilang karena sebuah uint tidak bisa menampung nilai negatif. Pada kedua kasus, operasi cast diperlukan karena konversi implisit dari long menjadi uint tidak bisa dilakukan.

Konversi Tipe Dalam Ekspresi

Selain terjadi di dalam penugasan, konversi tipe juga terjadi di dalam ekspresi. Di dalam suatu ekspresi, Anda dapat dengan bebas mencampur dua atau lebih berbagai tipe data berbeda sepanjang kompatibel satu sama lain. Sebagai contoh, Anda dapat mencampur short dan long di dalam sebuah ekspresi karena keduanya adalah tipe numerik. Ketika berbagai tipe data dicampur di dalam sebuah ekspresi, maka dikonversi menjadi tipe yang sama melalui basis operasi-demi-operasi.

Konversi dilakukan melalui aturan promosi tipe C#. Berikut adalah algoritma promosi tipe C#:

IF satu operand adalah decimal, THEN operand lain dipromosikan menjadi decimal (kecuali jika salah satu operand bertipe float atau double, pada kasus itu akan terjadi error).

ELSEIF satu operand bertipe double, maka operand kedua dipromosikan menjadi double.

ELSEIF satu operand bertipe float, maka operand kedua dipromosikan menjadi float.

ELSEIF satu operand bertipe ulong, maka operand kedua dipromosikan menjadi ulong (kecuali jika operand kedua bertipe sbyte, short, int, atau long, pada kasus tersebut akan terjadi error).

ELSEIF satu operand bertipe long, maka operand kedua dipromosikan menjadi long.

ELSEIF satu operand bertipe uint dan operand kedua bertipe sbyte, short, atau, int, maka kedua operand dikonversi menjadi long.

ELSEIF satu operand bertipe uint, maka operand kedua dipromosikan menjadi uint.

ELSE kedua operand dipromosikan menjadi int.

Adalah hal penting untuk dipahami bahwa promosi tipe hanya diterapkan pada nilai di dalam ekspresi yang sedang dievaluasi. Sebagai contoh, jika nilai dari sebuah variabel bertipe byte dipromosikan menjadi int di dalam suatu ekspresi, maka di luar ekspresi variabel tersebut masih sebuah byte. Promosi tipe hanya mempengaruhi evaluasi atas suatu ekspresi.

Promosi tipe dapat mengarah ke hasil yang tidak diinginkan. Sebagai contoh, ketika suatu operasi aritmatika melibatkan dua nilai byte, runtun berikut terjadi. Pertama, operand byte dipromosikan menjadi int, memberikan hasil int. Jadi, keluaran sebuah ekspresi yang melibatkan dua nilai byte akan menghasilkan sebuah int. Ini mungkin bukan apa yang Anda bayangkan. Perhatikan program berikut.

// Kejutan Promosi tipe!

using System;

class PromDemo

{

    static void Main()

    {

        byte b;

        b = 10;

        b = (byte)(b * b); // cast diperlukan!!

       

        Console.WriteLine("b: " + b);

    }

}

Di luar dugaan Anda, operasi cast terhadap byte diperlukan ketika menugaskan b * b kembali kepada b!. Alasannya adalah karena di dalam b * b, nilai b dipromosikan menjadi int ketika ekspresi tersebut dievaluasi. Jadi, b * b menghasilkan nilai int, yang tidak bisa ditugaskan ke variabel byte tanpa operasi cast.

Situasi yang sama terjadi pada char. Sebagai contoh, dalam fragmen berikut, operasi cast terhadap char diperlukan karena promosi atas ch1 dan ch2 menjadi int di dalam ekspresi

char ch1 = 'a', ch2 = 'b';

ch1 = (char) (ch1 + ch2);

Tanpa adanya operasi cast, hasil penjumlahan ch1 dan ch2 akan bertipe int, yang tidak bisa ditugaskan kepada variabel char.

Menggunakan Cast Dalam Ekspresi

Operasi cast dapat diterapkan pada bagian spesifik dari sebuah ekspresi panjang. Ini memberikan Anda kendali atas konversi tipe yang terjadi di dalam sebuah ekspresi yang sedang dievaluasi. Sebagai contoh, perhatikan program berikut. Program tersebut menampilkan beberapa akar kuadrat atas angka dari 1 sampai 10. Program juga menampilkan bagian bulat dan bagian pecahan dari setiap hasil, secara terpisah. Untuk melakukannya, program menggunakan operasi cast dalam mengkonversi hasil dari Math.Sqrt() menjadi int.

// Menggunakan cast di dalam sebuah ekspresi.

using System;

class CastExpr {

  static void Main() {

    double n;

    for(n = 1.0; n <= 10; n++) {

      Console.WriteLine("Akar kuadrat atas {0} adalah {1}",

                        n, Math.Sqrt(n));

   

      Console.WriteLine("Bagian angka bulat: {0}",

                        (int)Math.Sqrt(n));

  

      Console.WriteLine("Bagian pecahan: {0}",

                        Math.Sqrt(n) - (int)Math.Sqrt(n));

   

      Console.WriteLine();

    }

  }

}

Berikut adalah keluaran program:

Akar kuadrat atas 1 adalah 1

Bagian angka bulat: 1

Bagian pecahan: 0

Akar kuadrat atas 2 adalah 1.4142135623731

Bagian angka bulat: 1

Bagian pecahan: 0.414213562373095

Akar kuadrat atas 3 adalah 1.73205080756888

Bagian angka bulat: 1

Bagian pecahan: 0.732050807568877

Akar kuadrat atas 4 adalah 2

Bagian angka bulat: 2

Bagian pecahan: 0

Akar kuadrat atas 5 adalah 2.23606797749979

Bagian angka bulat: 2

Bagian pecahan: 0.23606797749979

Akar kuadrat atas 6 adalah 2.44948974278318

Bagian angka bulat: 2

Bagian pecahan: 0.449489742783178

Akar kuadrat atas 7 adalah 2.64575131106459

Bagian angka bulat: 2

Bagian pecahan: 0.645751311064591

Akar kuadrat atas 8 adalah 2.82842712474619

Bagian angka bulat: 2

Bagian pecahan: 0.82842712474619

Akar kuadrat atas 9 adalah 3

Bagian angka bulat: 3

Bagian pecahan: 0

Akar kuadrat atas 10 adalah 3.16227766016838

Bagian angka bulat: 3

Bagian pecahan: 0.16227766016838