Pemrograman D - Panduan Cepat
Bahasa pemrograman D merupakan bahasa pemrograman sistem multi paradigma berorientasi objek yang dikembangkan oleh Walter Bright dari Digital Mars. Pengembangannya dimulai pada tahun 1999 dan pertama kali dirilis pada tahun 2001. Versi utama D (1.0) dirilis pada tahun 2007. Saat ini, kami memiliki versi D2 dari D.
D adalah bahasa dengan sintaksis gaya C dan menggunakan pengetikan statis. Ada banyak fitur C dan C ++ di D tetapi juga ada beberapa fitur dari bahasa ini yang tidak termasuk bagian dari D. Beberapa tambahan penting untuk D termasuk,
- Pengujian unit
- Modul yang benar
- Pengumpulan sampah
- Array kelas satu
- Bebas dan terbuka
- Array asosiatif
- Array dinamis
- Kelas batin
- Closures
- Fungsi anonim
- Evaluasi malas
- Closures
Beberapa Paradigma
D adalah bahasa pemrograman multi paradigma. Berbagai paradigma meliputi,
- Imperative
- Berorientasi pada objek
- Pemrograman meta
- Functional
- Concurrent
Contoh
import std.stdio;
void main(string[] args) {
writeln("Hello World!");
}
Pembelajaran D
Hal terpenting yang harus dilakukan saat mempelajari D adalah fokus pada konsep dan tidak tersesat dalam detail teknis bahasa.
Tujuan belajar bahasa pemrograman adalah untuk menjadi programmer yang lebih baik; yaitu, menjadi lebih efektif dalam merancang dan menerapkan sistem baru dan memelihara yang lama.
Ruang Lingkup D
Pemrograman D memiliki beberapa fitur menarik dan situs pemrograman D resmi mengklaim bahwa D praktis, kuat, dan efisien. Pemrograman D menambahkan banyak fitur dalam bahasa inti yang telah disediakan oleh bahasa C dalam bentuk pustaka standar seperti fungsi array dan string yang dapat diubah ukurannya. D membuat bahasa kedua yang sangat baik untuk programmer menengah hingga mahir. D lebih baik dalam menangani memori dan mengelola pointer yang sering menyebabkan masalah di C ++.
Pemrograman D ditujukan terutama pada program baru yang mengonversi program yang sudah ada. Ini menyediakan pengujian dan verifikasi bawaan yang ideal untuk proyek besar baru yang akan ditulis dengan jutaan baris kode oleh tim besar.
Pengaturan Lingkungan Lokal untuk D
Jika Anda masih ingin mengatur lingkungan Anda untuk bahasa pemrograman D, Anda memerlukan dua software berikut yang tersedia di komputer Anda, (a) Text Editor, (b) D Compiler.
Editor Teks untuk Pemrograman D.
Ini akan digunakan untuk mengetik program Anda. Contoh beberapa editor termasuk Windows Notepad, perintah OS Edit, Brief, Epsilon, EMACS, dan vim atau vi.
Nama dan versi editor teks dapat berbeda pada sistem operasi yang berbeda. Misalnya, Notepad akan digunakan di Windows, dan vim atau vi dapat digunakan di windows serta Linux atau UNIX.
File yang Anda buat dengan editor Anda disebut file sumber dan berisi kode sumber program. File sumber untuk program D diberi nama dengan ekstensi ".d".
Sebelum memulai pemrograman Anda, pastikan Anda memiliki satu editor teks dan Anda memiliki cukup pengalaman untuk menulis program komputer, menyimpannya dalam sebuah file, membangunnya dan terakhir menjalankannya.
Penyusun D.
Implementasi D terkini dikompilasi langsung ke dalam kode mesin untuk eksekusi yang efisien.
Kami memiliki beberapa kompiler D yang tersedia dan mencakup berikut ini.
DMD - Kompiler Digital Mars D adalah kompiler D resmi oleh Walter Bright.
GDC - Sebuah front-end untuk GCC back-end, dibangun menggunakan kode sumber compiler DMD terbuka.
LDC - Sebuah kompiler berdasarkan front-end DMD yang menggunakan LLVM sebagai back-end kompilernya.
Kompiler berbeda di atas dapat diunduh dari unduhan D.
Kami akan menggunakan D versi 2 dan kami menyarankan untuk tidak mengunduh D1.
Mari kita memiliki program helloWorld.d sebagai berikut. Kami akan menggunakan ini sebagai program pertama yang kami jalankan pada platform yang Anda pilih.
import std.stdio;
void main(string[] args) {
writeln("Hello World!");
}
Kita bisa melihat outputnya sebagai berikut.
$ hello world
Instalasi D di Windows
Unduh penginstal windows .
Jalankan file yang dapat diunduh untuk menginstal D yang dapat dilakukan dengan mengikuti petunjuk di layar.
Sekarang kita dapat membangun dan menjalankan file iklan say helloWorld.d dengan beralih ke folder yang berisi file tersebut menggunakan cd dan kemudian menggunakan langkah-langkah berikut -
C:\DProgramming> DMD helloWorld.d
C:\DProgramming> helloWorld
Kita bisa melihat outputnya sebagai berikut.
hello world
C: \ DProgramming adalah folder, saya gunakan untuk menyimpan sampel saya. Anda dapat mengubahnya ke folder tempat Anda menyimpan program D.
Instalasi D di Ubuntu / Debian
Unduh penginstal debian .
Jalankan file yang dapat diunduh untuk menginstal D yang dapat dilakukan dengan mengikuti petunjuk di layar.
Sekarang kita dapat membangun dan menjalankan file iklan say helloWorld.d dengan beralih ke folder yang berisi file tersebut menggunakan cd dan kemudian menggunakan langkah-langkah berikut -
$ dmd helloWorld.d
$ ./helloWorld
Kita bisa melihat outputnya sebagai berikut.
$ hello world
Instalasi D di Mac OS X
Unduh penginstal Mac .
Jalankan file yang dapat diunduh untuk menginstal D yang dapat dilakukan dengan mengikuti petunjuk di layar.
Sekarang kita dapat membangun dan menjalankan file iklan say helloWorld.d dengan beralih ke folder yang berisi file tersebut menggunakan cd dan kemudian menggunakan langkah-langkah berikut -
$ dmd helloWorld.d $ ./helloWorld
Kita bisa melihat outputnya sebagai berikut.
$ hello world
Pemasangan D di Fedora
Unduh penginstal fedora .
Jalankan file yang dapat diunduh untuk menginstal D yang dapat dilakukan dengan mengikuti petunjuk di layar.
Sekarang kita dapat membangun dan menjalankan file iklan say helloWorld.d dengan beralih ke folder yang berisi file tersebut menggunakan cd dan kemudian menggunakan langkah-langkah berikut -
$ dmd helloWorld.d
$ ./helloWorld
Kita bisa melihat outputnya sebagai berikut.
$ hello world
Instalasi D pada OpenSUSE
Unduh penginstal OpenSUSE .
Jalankan file yang dapat diunduh untuk menginstal D yang dapat dilakukan dengan mengikuti petunjuk di layar.
Sekarang kita dapat membangun dan menjalankan file iklan say helloWorld.d dengan beralih ke folder yang berisi file tersebut menggunakan cd dan kemudian menggunakan langkah-langkah berikut -
$ dmd helloWorld.d $ ./helloWorld
Kita bisa melihat outputnya sebagai berikut.
$ hello world
D IDE
Kami memiliki dukungan IDE untuk D dalam bentuk plugin dalam banyak kasus. Ini termasuk,
Plugin Visual D adalah plugin untuk Visual Studio 2005-13
DDT adalah plugin eclipse yang menyediakan penyelesaian kode, debugging dengan GDB.
Penyelesaian kode Mono-D , refactoring dengan dmd / ldc / gdc support. Ini telah menjadi bagian dari GSoC 2012.
Code Blocks adalah IDE multi-platform yang mendukung pembuatan proyek D, penyorotan dan debugging.
D cukup mudah dipelajari dan mari kita mulai membuat program D pertama kita!
Program D Pertama
Mari kita tulis program D sederhana. Semua file D akan memiliki ekstensi .d. Jadi letakkan kode sumber berikut di file test.d.
import std.stdio;
/* My first program in D */
void main(string[] args) {
writeln("test!");
}
Dengan asumsi lingkungan D diatur dengan benar, mari jalankan pemrograman menggunakan -
$ dmd test.d
$ ./test
Kita bisa melihat outputnya sebagai berikut.
test
Sekarang mari kita lihat struktur dasar dari program D, sehingga akan mudah bagi Anda untuk memahami blok bangunan dasar dari bahasa pemrograman D.
Impor di D
Perpustakaan yang merupakan koleksi bagian program yang dapat digunakan kembali dapat tersedia untuk proyek kami dengan bantuan impor. Di sini kami mengimpor pustaka io standar yang menyediakan operasi I / O dasar. writeln yang digunakan dalam program di atas adalah fungsi di perpustakaan standar D. Ini digunakan untuk mencetak sebaris teks. Isi perpustakaan di D dikelompokkan ke dalam modul yang didasarkan pada jenis tugas yang ingin mereka lakukan. Satu-satunya modul yang digunakan program ini adalah std.stdio, yang menangani input dan output data.
Fungsi utama
Fungsi utama adalah memulai program dan menentukan urutan eksekusi dan bagaimana bagian lain dari program harus dijalankan.
Token di D
Program AD terdiri dari berbagai token dan token bisa berupa kata kunci, pengenal, konstanta, string literal, atau simbol. Misalnya, pernyataan D berikut terdiri dari empat token -
writeln("test!");
Token individu adalah -
writeln (
"test!"
)
;
Komentar
Komentar seperti teks pendukung dalam program D Anda dan diabaikan oleh kompilator. Komentar multi baris dimulai dengan / * dan diakhiri dengan karakter * / seperti yang ditunjukkan di bawah ini -
/* My first program in D */
Komentar tunggal ditulis menggunakan // di awal komentar.
// my first program in D
Pengenal
Pengenal AD adalah nama yang digunakan untuk mengidentifikasi variabel, fungsi, atau item lain yang ditentukan pengguna. Pengenal dimulai dengan huruf A sampai Z atau a sampai z atau garis bawah _ diikuti dengan nol atau lebih huruf, garis bawah, dan angka (0 sampai 9).
D tidak mengizinkan karakter tanda baca seperti @, $, dan% dalam pengenal. D adalah acase sensitivebahasa pemrograman. Jadi Manpower dan manpower adalah dua pengenal berbeda di D.Berikut beberapa contoh pengenal yang dapat diterima -
mohd zara abc move_name a_123
myname50 _temp j a23b9 retVal
Kata kunci
Daftar berikut menunjukkan beberapa dari kata-kata yang dipesan di D. Kata-kata yang dipesan ini tidak boleh digunakan sebagai konstanta atau variabel atau nama pengenal lainnya.
abstrak | alias | meluruskan | asm |
menegaskan | mobil | tubuh | bool |
byte | kasus | Pemeran | menangkap |
arang | kelas | const | terus |
dchar | debug | default | melimpahkan |
usang | melakukan | dua kali lipat | lain |
enum | ekspor | eksternal | Salah |
terakhir | akhirnya | mengapung | untuk |
untuk setiap | fungsi | pergi ke | jika |
impor | di | masuk | int |
antarmuka | invarian | adalah | panjang |
makro | mixin | modul | baru |
batal | di luar | mengesampingkan | paket |
pragma | pribadi | terlindung | publik |
nyata | ref | kembali | cakupan |
pendek | statis | struct | super |
beralih | disinkronkan | template | ini |
melemparkan | benar | mencoba | typeid |
jenis | ubyte | uint | ulong |
Persatuan | unittest | ushort | Versi: kapan |
kosong | wchar | sementara | dengan |
Spasi kosong di D
Sebuah baris yang hanya berisi spasi, kemungkinan dengan sebuah komentar, disebut sebagai baris kosong, dan kompilator D mengabaikannya sama sekali.
Spasi kosong adalah istilah yang digunakan di D untuk mendeskripsikan kosong, tab, karakter baris baru, dan komentar. Spasi putih memisahkan satu bagian pernyataan dari yang lain dan memungkinkan interpreter untuk mengidentifikasi di mana satu elemen dalam pernyataan, seperti int, berakhir dan elemen berikutnya dimulai. Oleh karena itu, dalam pernyataan berikut -
local age
Harus ada setidaknya satu karakter spasi (biasanya spasi) antara lokal dan usia agar penerjemah dapat membedakannya. Di sisi lain, dalam pernyataan berikut
int fruit = apples + oranges //get the total fruits
Tidak ada karakter spasi kosong yang diperlukan antara buah dan =, atau antara = dan apel, meskipun Anda bebas memasukkan beberapa jika Anda ingin agar dapat dibaca.
Variabel tidak lain adalah nama yang diberikan ke area penyimpanan yang dapat dimanipulasi oleh program kami. Setiap variabel di D memiliki tipe tertentu, yang menentukan ukuran dan tata letak memori variabel; kisaran nilai yang dapat disimpan dalam memori itu; dan set operasi yang dapat diterapkan ke variabel.
Nama variabel dapat terdiri dari huruf, angka, dan karakter garis bawah. Ini harus dimulai dengan huruf atau garis bawah. Huruf besar dan kecil berbeda karena D peka huruf besar / kecil. Berdasarkan tipe dasar yang dijelaskan pada bab sebelumnya, akan ada tipe variabel dasar berikut -
Sr.No. | Jenis & Deskripsi |
---|---|
1 | char Biasanya satu oktet (satu byte). Ini adalah tipe integer. |
2 | int Ukuran bilangan bulat paling alami untuk mesin. |
3 | float Nilai floating point presisi tunggal. |
4 | double Nilai floating point presisi ganda. |
5 | void Merupakan ketiadaan tipe. |
Bahasa pemrograman D juga memungkinkan untuk mendefinisikan berbagai jenis variabel lain seperti Enumerasi, Pointer, Array, Structure, Union, dll., Yang akan kita bahas pada bab-bab selanjutnya. Untuk bab ini, mari kita pelajari hanya tipe variabel dasar.
Definisi Variabel di D
Definisi variabel memberi tahu kompiler di mana dan berapa banyak ruang yang harus dibuat untuk variabel. Definisi variabel menentukan tipe data dan berisi daftar satu atau lebih variabel dari tipe itu sebagai berikut -
type variable_list;
Sini, type harus berupa tipe data D yang valid termasuk char, wchar, int, float, double, bool, atau objek yang ditentukan pengguna, dll., dan variable_listdapat terdiri dari satu atau lebih nama pengenal yang dipisahkan dengan koma. Beberapa pernyataan valid ditampilkan di sini -
int i, j, k;
char c, ch;
float f, salary;
double d;
Garis int i, j, k;keduanya mendeklarasikan dan mendefinisikan variabel i, j dan k; yang menginstruksikan kompilator untuk membuat variabel bernama i, j, dan k dengan tipe int.
Variabel dapat diinisialisasi (diberi nilai awal) dalam deklarasi mereka. Penginisialisasi terdiri dari tanda sama dengan diikuti dengan ekspresi konstan sebagai berikut -
type variable_name = value;
Contoh
extern int d = 3, f = 5; // declaration of d and f.
int d = 3, f = 5; // definition and initializing d and f.
byte z = 22; // definition and initializes z.
char x = 'x'; // the variable x has the value 'x'.
Ketika sebuah variabel dideklarasikan dalam D, itu selalu disetel ke 'penginisialisasi default', yang dapat diakses secara manual sebagai T.init dimana T adalah tipe (mis. int.init). Penginisialisasi default untuk tipe integer adalah 0, untuk Boolean false, dan untuk bilangan floating-point NaN.
Deklarasi Variabel di D
Deklarasi variabel memberikan jaminan kepada kompilator bahwa ada satu variabel yang ada dengan tipe dan nama yang diberikan sehingga kompilator melanjutkan kompilasi lebih lanjut tanpa memerlukan detail lengkap tentang variabel tersebut. Deklarasi variabel memiliki arti pada saat kompilasi saja, kompilator membutuhkan deklarasi variabel aktual pada saat menautkan program.
Contoh
Coba contoh berikut, di mana variabel telah dideklarasikan di awal program, tetapi ditentukan dan diinisialisasi di dalam fungsi utama -
import std.stdio;
int a = 10, b = 10;
int c;
float f;
int main () {
writeln("Value of a is : ", a);
/* variable re definition: */
int a, b;
int c;
float f;
/* Initialization */
a = 30;
b = 40;
writeln("Value of a is : ", a);
c = a + b;
writeln("Value of c is : ", c);
f = 70.0/3.0;
writeln("Value of f is : ", f);
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Value of a is : 10
Value of a is : 30
Value of c is : 70
Value of f is : 23.3333
Lvalues dan Rvalues di D
Ada dua jenis ekspresi di D -
lvalue - Ekspresi yang bernilai l dapat muncul sebagai sisi kiri atau kanan tugas.
rvalue - Ekspresi yang merupakan nilai r mungkin muncul di sisi kanan tetapi tidak di sisi kiri tugas.
Variabel adalah lvalues dan mungkin muncul di sisi kiri tugas. Literal numerik adalah nilai r sehingga mungkin tidak ditetapkan dan tidak dapat muncul di sisi kiri. Pernyataan berikut ini valid -
int g = 20;
Tetapi yang berikut ini bukan pernyataan yang valid dan akan menghasilkan kesalahan waktu kompilasi -
10 = 20;
Dalam bahasa pemrograman D, tipe data mengacu pada sistem ekstensif yang digunakan untuk mendeklarasikan variabel atau fungsi dari tipe yang berbeda. Jenis variabel menentukan berapa banyak ruang yang ditempati dalam penyimpanan dan bagaimana pola bit yang disimpan diinterpretasikan.
Jenis di D dapat diklasifikasikan sebagai berikut -
Sr.No. | Jenis & Deskripsi |
---|---|
1 | Basic Types Mereka adalah tipe aritmatika dan terdiri dari tiga tipe: (a) integer, (b) floating-point, dan (c) character. |
2 | Enumerated types Mereka lagi-lagi adalah tipe aritmatika. Mereka digunakan untuk mendefinisikan variabel yang hanya dapat diberikan nilai integer diskrit tertentu di seluruh program. |
3 | The type void Kekosongan penentu tipe menunjukkan bahwa tidak ada nilai yang tersedia. |
4 | Derived types Mereka termasuk (a) tipe Pointer, (b) tipe Array, (c) Tipe struktur, (d) tipe Union, dan (e) tipe Fungsi. |
Jenis array dan jenis struktur disebut secara kolektif sebagai jenis agregat. Tipe dari sebuah fungsi menentukan tipe dari nilai yang dikembalikan dari fungsi tersebut. Kita akan melihat tipe dasar di bagian selanjutnya sedangkan tipe lainnya akan dibahas di bab selanjutnya.
Jenis Integer
Tabel berikut memberikan daftar tipe integer standar dengan ukuran penyimpanan dan rentang nilainya -
Tipe | Ukuran penyimpanan | Rentang nilai |
---|---|---|
bool | 1 byte | salah atau benar |
byte | 1 byte | -128 hingga 127 |
ubyte | 1 byte | 0 sampai 255 |
int | 4 byte | -2.147.483.648 hingga 2.147.483.647 |
uint | 4 byte | 0 sampai 4.294.967.295 |
pendek | 2 byte | -32.768 hingga 32.767 |
ushort | 2 byte | 0 hingga 65.535 |
panjang | 8 byte | -9223372036854775808 hingga 9223372036854775807 |
ulong | 8 byte | 0 hingga 18446744073709551615 |
Untuk mendapatkan ukuran yang tepat dari sebuah tipe atau variabel, Anda dapat menggunakan sizeofoperator. Jenis ekspresi . (Sizeof) menghasilkan ukuran penyimpanan objek atau tipe dalam byte. Contoh berikut mendapatkan ukuran tipe int pada mesin apa pun -
import std.stdio;
int main() {
writeln("Length in bytes: ", ulong.sizeof);
return 0;
}
Ketika Anda mengkompilasi dan menjalankan program di atas, ini menghasilkan hasil sebagai berikut -
Length in bytes: 8
Jenis Titik Mengambang
Tabel berikut menyebutkan tipe titik apung standar dengan ukuran penyimpanan, rentang nilai, dan tujuannya -
Tipe | Ukuran penyimpanan | Rentang nilai | Tujuan |
---|---|---|---|
mengapung | 4 byte | 1.17549e-38 hingga 3.40282e + 38 | 6 tempat desimal |
dua kali lipat | 8 byte | 2.22507e-308 hingga 1.79769e + 308 | 15 tempat desimal |
nyata | 10 byte | 3.3621e-4932 hingga 1.18973e + 4932 | baik tipe floating point terbesar yang didukung perangkat keras, atau double; mana yang lebih besar |
ifloat | 4 byte | 1.17549e-38i hingga 3.40282e + 38i | tipe nilai imajiner dari float |
idouble | 8 byte | 2.22507e-308i hingga 1.79769e + 308i | tipe nilai imajiner ganda |
ireal | 10 byte | 3.3621e-4932 hingga 1.18973e + 4932 | jenis nilai imajiner nyata |
cfloat | 8 byte | 1.17549e-38 + 1.17549e-38i hingga 3.40282e + 38 + 3.40282e + 38i | tipe bilangan kompleks terbuat dari dua pelampung |
cdouble | 16 byte | 2.22507e-308 + 2.22507e-308i hingga 1.79769e + 308 + 1.79769e + 308i | jenis bilangan kompleks yang terbuat dari dua ganda |
creal | 20 byte | 3.3621e-4932 + 3.3621e-4932i hingga 1.18973e + 4932 + 1.18973e + 4932i | jenis bilangan kompleks yang terbuat dari dua real |
Contoh berikut mencetak ruang penyimpanan yang diambil oleh tipe float dan nilai jangkauannya -
import std.stdio;
int main() {
writeln("Length in bytes: ", float.sizeof);
return 0;
}
Ketika Anda mengkompilasi dan menjalankan program di atas, ini menghasilkan hasil sebagai berikut di Linux -
Length in bytes: 4
Jenis Karakter
Tabel berikut mencantumkan tipe karakter standar dengan ukuran penyimpanan dan tujuannya.
Tipe | Ukuran penyimpanan | Tujuan |
---|---|---|
arang | 1 byte | Unit kode UTF-8 |
wchar | 2 byte | Unit kode UTF-16 |
dchar | 4 byte | Unit kode UTF-32 dan titik kode Unicode |
Contoh berikut mencetak ruang penyimpanan yang diambil oleh tipe karakter.
import std.stdio;
int main() {
writeln("Length in bytes: ", char.sizeof);
return 0;
}
Ketika Anda mengkompilasi dan menjalankan program di atas, ini menghasilkan hasil sebagai berikut -
Length in bytes: 1
Jenis void
Jenis kekosongan menentukan bahwa tidak ada nilai yang tersedia. Ini digunakan dalam dua jenis situasi -
Sr.No. | Jenis & Deskripsi |
---|---|
1 | Function returns as void Ada berbagai fungsi di D yang tidak mengembalikan nilai atau bisa dibilang mereka mengembalikan kosong. Fungsi tanpa nilai pengembalian memiliki tipe pengembalian sebagai kosong. Sebagai contoh,void exit (int status); |
2 | Function arguments as void Ada berbagai fungsi di D yang tidak menerima parameter apa pun. Fungsi tanpa parameter dapat diterima sebagai kekosongan. Sebagai contoh,int rand(void); |
Jenis kekosongan mungkin belum Anda pahami saat ini, jadi mari kita lanjutkan dan kami akan membahas konsep-konsep ini di bab-bab selanjutnya.
Enumerasi digunakan untuk menentukan nilai konstanta bernama. Jenis enumerasi dideklarasikan menggunakanenum kata kunci.
The enum Sintaks
Bentuk paling sederhana dari definisi enum adalah sebagai berikut -
enum enum_name {
enumeration list
}
Dimana,
The enum_name menentukan nama jenis pencacahan.
Daftar enumerasi adalah daftar pengenal yang dipisahkan koma.
Setiap simbol dalam daftar pencacahan mewakili nilai integer, satu lebih besar dari simbol yang mendahuluinya. Secara default, nilai simbol pencacahan pertama adalah 0. Misalnya -
enum Days { sun, mon, tue, wed, thu, fri, sat };
Contoh
Contoh berikut menunjukkan penggunaan variabel enum -
import std.stdio;
enum Days { sun, mon, tue, wed, thu, fri, sat };
int main(string[] args) {
Days day;
day = Days.mon;
writefln("Current Day: %d", day);
writefln("Friday : %d", Days.fri);
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Current Day: 1
Friday : 5
Pada program di atas, kita dapat melihat bagaimana enumerasi dapat digunakan. Awalnya, kami membuat variabel bernama hari hari pencacahan yang ditentukan pengguna kami. Kemudian kami mengaturnya ke mon menggunakan operator titik. Kita perlu menggunakan metode writefln untuk mencetak nilai mon yang telah disimpan. Anda juga perlu menentukan jenisnya. Ini adalah tipe integer, oleh karena itu kami menggunakan% d untuk mencetak.
Dinamakan Enums Properties
Contoh di atas menggunakan nama Hari untuk pencacahan dan disebut enum bernama. Enum bernama ini memiliki properti berikut -
Init - Ini menginisialisasi nilai pertama dalam pencacahan.
min - Ini mengembalikan nilai terkecil dari pencacahan.
max - Ini mengembalikan nilai pencacahan terbesar.
sizeof - Ini mengembalikan ukuran penyimpanan untuk pencacahan.
Mari kita memodifikasi contoh sebelumnya untuk menggunakan properti.
import std.stdio;
// Initialized sun with value 1
enum Days { sun = 1, mon, tue, wed, thu, fri, sat };
int main(string[] args) {
writefln("Min : %d", Days.min);
writefln("Max : %d", Days.max);
writefln("Size of: %d", Days.sizeof);
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Min : 1
Max : 7
Size of: 4
Enum Anonim
Pencacahan tanpa nama disebut enum anonim. Contoh untukanonymous enum diberikan di bawah ini.
import std.stdio;
// Initialized sun with value 1
enum { sun , mon, tue, wed, thu, fri, sat };
int main(string[] args) {
writefln("Sunday : %d", sun);
writefln("Monday : %d", mon);
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Sunday : 0
Monday : 1
Enum anonim bekerja dengan cara yang hampir sama seperti enum bernama tetapi enum tersebut tidak memiliki properti max, min, dan sizeof.
Enum dengan Sintaks Tipe Basis
Sintaks untuk enumerasi dengan tipe dasar ditampilkan di bawah ini.
enum :baseType {
enumeration list
}
Beberapa tipe dasar termasuk long, int, dan string. Contoh penggunaan long ditunjukkan di bawah ini.
import std.stdio;
enum : string {
A = "hello",
B = "world",
}
int main(string[] args) {
writefln("A : %s", A);
writefln("B : %s", B);
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
A : hello
B : world
Lebih banyak fitur
Pencacahan di D menyediakan fitur seperti inisialisasi beberapa nilai dalam pencacahan dengan berbagai jenis. Contohnya ditunjukkan di bawah ini.
import std.stdio;
enum {
A = 1.2f, // A is 1.2f of type float
B, // B is 2.2f of type float
int C = 3, // C is 3 of type int
D // D is 4 of type int
}
int main(string[] args) {
writefln("A : %f", A);
writefln("B : %f", B);
writefln("C : %d", C);
writefln("D : %d", D);
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
A : 1.200000
B : 2.200000
C : 3
D : 4
Nilai konstanta yang diketik dalam program sebagai bagian dari kode sumber disebut literals.
Literal dapat berupa salah satu tipe data dasar dan dapat dibagi menjadi Angka Integer, Angka Titik Mengambang, Karakter, String, dan Nilai Boolean.
Sekali lagi, literal diperlakukan seperti variabel biasa kecuali nilainya tidak dapat dimodifikasi setelah definisinya.
Integer Literals
Literal integer dapat berupa salah satu dari jenis berikut -
Decimal menggunakan representasi angka normal dengan digit pertama tidak boleh 0 karena digit tersebut dicadangkan untuk menunjukkan sistem oktal. Ini tidak termasuk 0 sendiri: 0 adalah nol.
Octal menggunakan 0 sebagai awalan angka.
Binary menggunakan 0b atau 0B sebagai awalan.
Hexadecimal menggunakan 0x atau 0X sebagai awalan.
Literal integer juga dapat memiliki sufiks yang merupakan kombinasi dari U dan L, masing-masing untuk unsigned dan long. Sufiks dapat berupa huruf besar atau kecil dan dapat dalam urutan apa pun.
Jika Anda tidak menggunakan sufiks, kompilator itu sendiri memilih antara int, uint, long, dan ulong berdasarkan besarnya nilainya.
Berikut adalah beberapa contoh literal integer -
212 // Legal
215u // Legal
0xFeeL // Legal
078 // Illegal: 8 is not an octal digit
032UU // Illegal: cannot repeat a suffix
Berikut adalah contoh lain dari berbagai jenis literal integer -
85 // decimal
0213 // octal
0x4b // hexadecimal
30 // int
30u // unsigned int
30l // long
30ul // unsigned long
0b001 // binary
Literal Titik Mengambang
Literal floating point dapat ditentukan baik dalam sistem desimal seperti pada 1,568 atau dalam sistem heksadesimal seperti pada 0x91.bc.
Dalam sistem desimal, eksponen dapat direpresentasikan dengan menambahkan karakter e atau E dan angka setelah itu. Misalnya, 2.3e4 berarti "2,3 kali 10 pangkat 4". Karakter “+” dapat ditentukan sebelum nilai eksponen, tetapi tidak berpengaruh. Misalnya 2.3e4 dan 2.3e + 4 adalah sama.
Karakter “-” yang ditambahkan sebelum nilai eksponen mengubah artinya menjadi "dibagi 10 pangkat". Misalnya, 2.3e-2 berarti "2,3 dibagi 10 pangkat 2".
Dalam sistem heksadesimal, nilainya dimulai dengan 0x atau 0X. Eksponen ditentukan oleh p atau P, bukan e atau E. Eksponen tidak berarti "10 pangkat", tetapi "2 pangkat dari". Misalnya, P4 dalam 0xabc.defP4 berarti "abc.de dikalikan 2 pangkat 4".
Berikut beberapa contoh literal floating-point -
3.14159 // Legal
314159E-5L // Legal
510E // Illegal: incomplete exponent
210f // Illegal: no decimal or exponent
.e55 // Illegal: missing integer or fraction
0xabc.defP4 // Legal Hexa decimal with exponent
0xabc.defe4 // Legal Hexa decimal without exponent.
Secara default, tipe literal floating point adalah ganda. F dan F berarti float, dan penentu L berarti nyata.
Literal Boolean
Ada dua literal Boolean dan merupakan bagian dari kata kunci D standar -
Nilai true mewakili benar.
Nilai false mewakili salah.
Anda tidak boleh menganggap nilai benar sama dengan 1 dan nilai salah sama dengan 0.
Karakter Literal
Literal karakter diapit tanda kutip tunggal.
Literal karakter dapat berupa karakter biasa (mis., 'X'), urutan pelolosan (mis., '\ T'), karakter ASCII (mis., '\ X21'), karakter Unicode (mis., '\ U011e') atau sebagai karakter bernama (misalnya '\ ©', '\ ♥', '\ €').
Ada beberapa karakter di D ketika didahului oleh garis miring terbalik mereka akan memiliki arti khusus dan digunakan untuk mewakili seperti baris baru (\ n) atau tab (\ t). Di sini, Anda memiliki daftar beberapa kode urutan pelolosan tersebut -
Urutan pelarian | Berarti |
---|---|
\\ | \ karakter |
\ ' | 'karakter |
\ " | "karakter |
\? | ? karakter |
\Sebuah | Peringatan atau bel |
\ b | Menghapus |
\ f | Bentuk pakan |
\ n | Garis baru |
\ r | Kereta kembali |
\ t | Tab horizontal |
\ v | Tab vertikal |
Contoh berikut menunjukkan beberapa karakter escape sequence -
import std.stdio;
int main(string[] args) {
writefln("Hello\tWorld%c\n",'\x21');
writefln("Have a good day%c",'\x21');
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Hello World!
Have a good day!
String Literals
Literal string diapit tanda kutip ganda. Sebuah string berisi karakter yang mirip dengan literal karakter: karakter biasa, urutan escape, dan karakter universal.
Anda dapat memecah garis panjang menjadi beberapa baris menggunakan literal string dan memisahkannya menggunakan spasi putih.
Berikut beberapa contoh string literal -
import std.stdio;
int main(string[] args) {
writeln(q"MY_DELIMITER
Hello World
Have a good day
MY_DELIMITER");
writefln("Have a good day%c",'\x21');
auto str = q{int value = 20; ++value;};
writeln(str);
}
Pada contoh di atas, Anda dapat menemukan penggunaan q "MY_DELIMITER MY_DELIMITER" untuk mewakili karakter multi baris. Anda juga bisa melihat q {} untuk merepresentasikan pernyataan bahasa D itu sendiri.
Operator adalah simbol yang memberi tahu kompiler untuk melakukan manipulasi matematika atau logika tertentu. Bahasa D kaya akan operator bawaan dan menyediakan jenis operator berikut -
- Operator Aritmatika
- Operator Relasional
- Operator Logis
- Operator Bitwise
- Operator Penugasan
- Operator Misc
Bab ini menjelaskan aritmatika, relasional, logika, bitwise, penugasan, dan operator lain satu per satu.
Operator Aritmatika
Tabel berikut menunjukkan semua operator aritmatika yang didukung oleh bahasa D. Asumsikan variabelA memegang 10 dan variabel B memegang 20 lalu -
Tunjukkan Contoh
Operator | Deskripsi | Contoh |
---|---|---|
+ | Ia menambahkan dua operan. | A + B menghasilkan 30 |
- | Ini mengurangi operan kedua dari yang pertama. | A - B memberikan -10 |
* | Ini mengalikan kedua operan. | A * B menghasilkan 200 |
/ | Ini membagi pembilang dengan denumerator. | B / A menghasilkan 2 |
% | Ini mengembalikan sisa pembagian integer. | B% A menghasilkan 0 |
++ | Operator increment meningkatkan nilai integer satu. | A ++ menghasilkan 11 |
- | Operator penurunan menurunkan nilai integer satu. | A-- memberi 9 |
Operator Relasional
Tabel berikut menunjukkan semua operator relasional yang didukung oleh bahasa D. Asumsikan variabelA memegang 10 dan variabel B memegang 20, lalu -
Tunjukkan Contoh
Operator | Deskripsi | Contoh |
---|---|---|
== | Memeriksa apakah nilai dari dua operan sama atau tidak, jika ya maka kondisinya menjadi benar. | (A == B) tidak benar. |
! = | Memeriksa apakah nilai dari dua operan sama atau tidak, jika nilai tidak sama maka kondisi menjadi benar. | (A! = B) benar. |
> | Memeriksa apakah nilai operan kiri lebih besar dari nilai operan kanan, jika ya maka kondisi menjadi benar. | (A> B) tidak benar. |
< | Memeriksa apakah nilai operan kiri kurang dari nilai operan kanan, jika ya maka kondisinya menjadi benar. | (A <B) benar. |
> = | Memeriksa apakah nilai operan kiri lebih besar dari atau sama dengan nilai operan kanan, jika ya maka kondisi menjadi benar. | (A> = B) tidak benar. |
<= | Memeriksa apakah nilai operan kiri kurang dari atau sama dengan nilai operan kanan, jika ya maka kondisi menjadi benar. | (A <= B) benar. |
Operator Logis
Tabel berikut menunjukkan semua operator logika yang didukung oleh bahasa D. Asumsikan variabelA memegang 1 dan variabel B memegang 0, lalu -
Tunjukkan Contoh
Operator | Deskripsi | Contoh |
---|---|---|
&& | Ini disebut operator Logical AND. Jika kedua operan bukan nol, maka kondisi menjadi benar. | (A && B) salah. |
|| | Ini disebut Logical OR Operator. Jika salah satu dari dua operan bukan nol, maka kondisi menjadi benar. | (A || B) itu benar. |
! | Ini disebut Logical NOT Operator. Gunakan untuk membalikkan keadaan logis operannya. Jika kondisi benar maka operator NOT akan membuat salah. | ! (A && B) benar. |
Operator Bitwise
Operator bitwise bekerja pada bit dan melakukan operasi bit demi bit. Tabel kebenaran untuk &, |, dan ^ adalah sebagai berikut -
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Asumsikan jika A = 60; dan B = 13. Dalam format biner akan menjadi sebagai berikut -
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Operator Bitwise yang didukung oleh bahasa D tercantum dalam tabel berikut. Asumsikan variabel A memiliki 60 dan variabel B memiliki 13, maka -
Tunjukkan Contoh
Operator | Deskripsi | Contoh |
---|---|---|
& | Biner AND Operator menyalin sedikit ke hasil jika ada di kedua operan. | (A & B) akan memberikan 12, Berarti 0000 1100. |
| | Biner ATAU Operator menyalin sedikit jika ada di salah satu operan. | (A | B) memberikan 61. Berarti 0011 1101. |
^ | Operator Biner XOR menyalin bit jika diatur dalam satu operan tetapi tidak keduanya. | (A ^ B) memberikan 49. Berarti 0011 0001 |
~ | Operator Pelengkap Binary Ones adalah unary dan memiliki efek bit 'membalik'. | (~ A) memberikan -61. Berarti 1100 0011 dalam bentuk komplemen 2. |
<< | Operator Binary Left Shift. Nilai operan kiri dipindahkan ke kiri dengan jumlah bit yang ditentukan oleh operan kanan. | A << 2 memberikan 240. Berarti 1111 0000 |
>> | Operator Pergeseran Kanan Biner. Nilai operan kiri dipindahkan ke kanan dengan jumlah bit yang ditentukan oleh operan kanan. | A >> 2 memberikan 15. Berarti 0000 1111. |
Operator Penugasan
Operator tugas berikut didukung oleh bahasa D -
Tunjukkan Contoh
Operator | Deskripsi | Contoh |
---|---|---|
= | Ini adalah operator penugasan sederhana. Ini menetapkan nilai dari operan sisi kanan ke operan sisi kiri | C = A + B memberikan nilai A + B ke dalam C |
+ = | Ini adalah menambahkan DAN operator penugasan. Ini menambahkan operan kanan ke operan kiri dan menetapkan hasilnya ke operan kiri | C + = A ekivalen dengan C = C + A |
- = | Ini adalah pengurangan DAN operator penugasan. Ini mengurangi operan kanan dari operan kiri dan menetapkan hasilnya ke operan kiri. | C - = A ekivalen dengan C = C - A |
* = | Ini adalah kalikan DAN operator penugasan. Ini mengalikan operan kanan dengan operan kiri dan memberikan hasilnya ke operan kiri. | C * = A ekivalen dengan C = C * A |
/ = | Ini adalah operator pembagian DAN penugasan. Ini membagi operan kiri dengan operan kanan dan menetapkan hasilnya ke operan kiri. | C / = A ekivalen dengan C = C / A |
% = | Ini adalah modulus DAN operator penugasan. Dibutuhkan modulus menggunakan dua operan dan menetapkan hasilnya ke operan kiri. | C% = A setara dengan C = C% A |
<< = | Ini adalah shift kiri DAN operator penugasan. | C << = 2 sama dengan C = C << 2 |
>> = | Ini adalah shift kanan DAN operator penugasan. | C >> = 2 sama dengan C = C >> 2 |
& = | Ini bitwise AND operator penugasan. | C & = 2 sama dengan C = C & 2 |
^ = | Ini bitwise eksklusif OR dan operator penugasan. | C ^ = 2 sama dengan C = C ^ 2 |
| = | Ini termasuk OR dan operator penugasan termasuk bitwise | C | = 2 sama dengan C = C | 2 |
Operator Miscillaneous - Sizeof dan Ternary
Ada beberapa operator penting lainnya termasuk sizeof dan ? : didukung oleh Bahasa D.
Tunjukkan Contoh
Operator | Deskripsi | Contoh |
---|---|---|
ukuran dari() | Mengembalikan ukuran variabel. | sizeof (a), di mana a adalah integer, mengembalikan 4. |
& | Menampilkan alamat variabel. | &Sebuah; memberikan alamat sebenarnya dari variabel tersebut. |
* | Pointer ke variabel. | *Sebuah; memberikan pointer ke variabel. |
? : | Ekspresi Bersyarat | Jika kondisi benar maka nilai X: Jika tidak nilai Y. |
Operator Diutamakan di D
Prioritas operator menentukan pengelompokan istilah dalam ekspresi. Ini memengaruhi bagaimana ekspresi dievaluasi. Operator tertentu didahulukan dari yang lain.
Misalnya, operator perkalian memiliki prioritas yang lebih tinggi daripada operator penjumlahan.
Mari kita perhatikan ungkapan
x = 7 + 3 * 2.
Di sini, x ditetapkan 13, bukan 20. Alasan sederhananya adalah, operator * memiliki prioritas lebih tinggi dari +, maka 3 * 2 dihitung terlebih dahulu dan kemudian hasilnya ditambahkan ke 7.
Di sini, operator dengan prioritas tertinggi muncul di bagian atas tabel, operator dengan prioritas terendah muncul di bagian bawah. Dalam ekspresi, operator dengan prioritas lebih tinggi dievaluasi terlebih dahulu.
Tunjukkan Contoh
Kategori | Operator | Asosiatif |
---|---|---|
Postfix | () [] ->. ++ - - | Kiri ke kanan |
Unary | + -! ~ ++ - - (tipe) * & sizeof | Kanan ke kiri |
Perkalian | * /% | Kiri ke kanan |
Aditif | + - | Kiri ke kanan |
Bergeser | << >> | Kiri ke kanan |
Relasional | <<=>> = | Kiri ke kanan |
Persamaan | ==! = | Kiri ke kanan |
Bitwise DAN | & | Kiri ke kanan |
Bitwise XOR | ^ | Kiri ke kanan |
Bitwise ATAU | | | Kiri ke kanan |
DAN logis | && | Left to right |
Logical OR | || | Left to right |
Conditional | ?: | Right to left |
Assignment | = += -= *= /= %=>>= <<= &= ^= |= | Right to left |
Comma | , | Left to right |
There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.
Programming languages provide various control structures that allow more complicated execution paths.
A loop statement executes a statement or group of statements multiple times. The following general form of a loop statement in mostly used in the programming languages −
D programming language provides the following types of loop to handle looping requirements. Click the following links to check their detail.
Sr.No. | Loop Type & Description |
---|---|
1 | while loop It repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body. |
2 | for loop It executes a sequence of statements multiple times and abbreviates the code that manages the loop variable. |
3 | do...while loop Like a while statement, except that it tests the condition at the end of the loop body. |
4 | nested loops You can use one or more loop inside any another while, for, or do..while loop. |
Loop Control Statements
Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.
D supports the following control statements −
Sr.No. | Control Statement & Description |
---|---|
1 | break statement Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch. |
2 | continue statement Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating. |
The Infinite Loop
A loop becomes infinite loop if a condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty.
import std.stdio;
int main () {
for( ; ; ) {
writefln("This loop will run forever.");
}
return 0;
}
When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but D programmers more commonly use the for(;;) construct to signify an infinite loop.
NOTE − You can terminate an infinite loop by pressing Ctrl + C keys.
The decision making structures contain condition to be evaluated along with the two sets of statements to be executed. One set of statements is executed if the condition it true and another set of statements is executed if the condition is false.
The following is the general form of a typical decision making structure found in most of the programming languages −
D programming language assumes any non-zero and non-null values as true, and if it is either zero or null, then it is assumed as false value.
D programming language provides the following types of decision making statements.
Sr.No. | Statement & Description |
---|---|
1 | if statement An if statement consists of a boolean expression followed by one or more statements. |
2 | if...else statement An if statement can be followed by an optional else statement, which executes when the boolean expression is false. |
3 | nested if statements You can use one if or else if statement inside another if or else if statement(s). |
4 | switch statement A switch statement allows a variable to be tested for equality against a list of values. |
5 | nested switch statements You can use one switch statement inside another switch statement(s). |
The ? : Operator in D
We have covered conditional operator ? : in previous chapter which can be used to replace if...else statements. It has the following general form
Exp1 ? Exp2 : Exp3;
Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon.
The value of a ? expression is determined as follows −
Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire ? expression.
If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression.
This chapter describes the functions used in D programming.
Function Definition in D
A basic function definition consists of a function header and a function body.
Sintaksis
return_type function_name( parameter list ) {
body of the function
}
Inilah semua bagian dari sebuah fungsi -
Return Type- Suatu fungsi dapat mengembalikan nilai. Itureturn_typeadalah tipe data dari nilai yang dikembalikan fungsi. Beberapa fungsi melakukan operasi yang diinginkan tanpa mengembalikan nilai. Dalam kasus ini, return_type adalah kata kuncivoid.
Function Name- Ini adalah nama sebenarnya dari fungsinya. Nama fungsi dan daftar parameter bersama-sama membentuk tanda tangan fungsi.
Parameters- Parameter seperti placeholder. Saat suatu fungsi dipanggil, Anda meneruskan nilai ke parameter. Nilai ini disebut sebagai parameter atau argumen aktual. Daftar parameter mengacu pada jenis, urutan, dan jumlah parameter suatu fungsi. Parameter bersifat opsional; artinya, suatu fungsi mungkin tidak berisi parameter.
Function Body - Badan fungsi berisi kumpulan pernyataan yang menentukan apa yang dilakukan fungsi.
Memanggil Fungsi
Anda dapat memanggil fungsi sebagai berikut -
function_name(parameter_values)
Jenis Fungsi di D
Pemrograman D mendukung berbagai fungsi dan mereka tercantum di bawah ini.
- Fungsi Murni
- Fungsi Nothrow
- Fungsi Ref
- Fungsi Otomatis
- Fungsi Variadic
- Fungsi Inout
- Fungsi Properti
Berbagai fungsi dijelaskan di bawah ini.
Fungsi Murni
Fungsi murni adalah fungsi yang tidak dapat mengakses status global atau statis, dapat berubah kecuali melalui argumennya. Ini dapat mengaktifkan pengoptimalan berdasarkan fakta bahwa fungsi murni dijamin tidak akan mengubah apa pun yang tidak diteruskan padanya, dan dalam kasus di mana kompilator dapat menjamin bahwa fungsi murni tidak dapat mengubah argumennya, ia dapat mengaktifkan kemurnian fungsional penuh, yang adalah, jaminan bahwa fungsi tersebut akan selalu mengembalikan hasil yang sama untuk argumen yang sama).
import std.stdio;
int x = 10;
immutable int y = 30;
const int* p;
pure int purefunc(int i,const char* q,immutable int* s) {
//writeln("Simple print"); //cannot call impure function 'writeln'
debug writeln("in foo()"); // ok, impure code allowed in debug statement
// x = i; // error, modifying global state
// i = x; // error, reading mutable global state
// i = *p; // error, reading const global state
i = y; // ok, reading immutable global state
auto myvar = new int; // Can use the new expression:
return i;
}
void main() {
writeln("Value returned from pure function : ",purefunc(x,null,null));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Value returned from pure function : 30
Fungsi Nothrow
Fungsi Nothrow tidak menampilkan pengecualian apa pun yang diturunkan dari Exception kelas. Fungsi kedua sisi adalah kovarian dengan fungsi lempar.
Nothrow menjamin bahwa suatu fungsi tidak mengeluarkan pengecualian apa pun.
import std.stdio;
int add(int a, int b) nothrow {
//writeln("adding"); This will fail because writeln may throw
int result;
try {
writeln("adding"); // compiles
result = a + b;
} catch (Exception error) { // catches all exceptions
}
return result;
}
void main() {
writeln("Added value is ", add(10,20));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
adding
Added value is 30
Fungsi Ref
Fungsi ref memungkinkan fungsi untuk kembali dengan referensi. Ini analog dengan parameter fungsi ref.
import std.stdio;
ref int greater(ref int first, ref int second) {
return (first > second) ? first : second;
}
void main() {
int a = 1;
int b = 2;
greater(a, b) += 10;
writefln("a: %s, b: %s", a, b);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
a: 1, b: 12
Fungsi Otomatis
Fungsi otomatis dapat mengembalikan nilai jenis apa pun. Tidak ada batasan jenis apa yang akan dikembalikan. Contoh sederhana untuk fungsi tipe otomatis diberikan di bawah ini.
import std.stdio;
auto add(int first, double second) {
double result = first + second;
return result;
}
void main() {
int a = 1;
double b = 2.5;
writeln("add(a,b) = ", add(a, b));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
add(a,b) = 3.5
Fungsi Variadic
Fungsi variadiac adalah fungsi di mana jumlah parameter untuk suatu fungsi ditentukan dalam runtime. Di C, ada batasan untuk memiliki setidaknya satu parameter. Namun dalam pemrograman D, tidak ada batasan seperti itu. Contoh sederhana ditunjukkan di bawah ini.
import std.stdio;
import core.vararg;
void printargs(int x, ...) {
for (int i = 0; i < _arguments.length; i++) {
write(_arguments[i]);
if (_arguments[i] == typeid(int)) {
int j = va_arg!(int)(_argptr);
writefln("\t%d", j);
} else if (_arguments[i] == typeid(long)) {
long j = va_arg!(long)(_argptr);
writefln("\t%d", j);
} else if (_arguments[i] == typeid(double)) {
double d = va_arg!(double)(_argptr);
writefln("\t%g", d);
}
}
}
void main() {
printargs(1, 2, 3L, 4.5);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
int 2
long 3
double 4.5
Fungsi Inout
Inout dapat digunakan baik untuk parameter dan jenis fungsi kembalian. Ini seperti template untuk mutable, const, dan immutable. Atribut mutabilitas disimpulkan dari parameter. Berarti, inout mentransfer atribut mutabilitas yang disimpulkan ke tipe pengembalian. Contoh sederhana yang menunjukkan bagaimana mutabilitas berubah ditunjukkan di bawah ini.
import std.stdio;
inout(char)[] qoutedWord(inout(char)[] phrase) {
return '"' ~ phrase ~ '"';
}
void main() {
char[] a = "test a".dup;
a = qoutedWord(a);
writeln(typeof(qoutedWord(a)).stringof," ", a);
const(char)[] b = "test b";
b = qoutedWord(b);
writeln(typeof(qoutedWord(b)).stringof," ", b);
immutable(char)[] c = "test c";
c = qoutedWord(c);
writeln(typeof(qoutedWord(c)).stringof," ", c);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
char[] "test a"
const(char)[] "test b"
string "test c"
Fungsi Properti
Properti memungkinkan penggunaan fungsi anggota seperti variabel anggota. Ini menggunakan kata kunci @property. Properti ditautkan dengan fungsi terkait yang mengembalikan nilai berdasarkan persyaratan. Contoh sederhana untuk properti ditunjukkan di bawah ini.
import std.stdio;
struct Rectangle {
double width;
double height;
double area() const @property {
return width*height;
}
void area(double newArea) @property {
auto multiplier = newArea / area;
width *= multiplier;
writeln("Value set!");
}
}
void main() {
auto rectangle = Rectangle(20,10);
writeln("The area is ", rectangle.area);
rectangle.area(300);
writeln("Modified width is ", rectangle.width);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
The area is 200
Value set!
Modified width is 30
Karakter adalah blok bangunan string. Simbol apa pun dari sistem penulisan disebut karakter: huruf abjad, angka, tanda baca, karakter spasi, dll. Yang membingungkan, blok penyusun karakter itu sendiri disebut karakter juga.
Nilai integer dari huruf kecil a adalah 97 dan nilai integer dari angka 1 adalah 49. Nilai-nilai ini telah ditetapkan hanya oleh konvensi ketika tabel ASCII telah dirancang.
Tabel berikut menyebutkan tipe karakter standar dengan ukuran dan tujuan penyimpanannya.
Karakter diwakili oleh tipe karakter, yang hanya dapat menampung 256 nilai berbeda. Jika Anda terbiasa dengan tipe karakter dari bahasa lain, Anda mungkin sudah tahu bahwa itu tidak cukup besar untuk mendukung simbol banyak sistem penulisan.
Tipe | Ukuran penyimpanan | Tujuan |
---|---|---|
arang | 1 byte | Unit kode UTF-8 |
wchar | 2 byte | Unit kode UTF-16 |
dchar | 4 byte | Unit kode UTF-32 dan titik kode Unicode |
Beberapa fungsi karakter yang berguna tercantum di bawah ini -
isLower - Menentukan apakah karakter huruf kecil?
isUpper - Menentukan apakah karakter huruf besar?
isAlpha - Menentukan apakah karakter alfanumerik Unicode (umumnya, huruf atau angka)?
isWhite - Menentukan apakah karakter spasi?
toLower - Ini menghasilkan huruf kecil dari karakter yang diberikan.
toUpper - Ini menghasilkan huruf besar dari karakter yang diberikan.
import std.stdio;
import std.uni;
void main() {
writeln("Is ğ lowercase? ", isLower('ğ'));
writeln("Is Ş lowercase? ", isLower('Ş'));
writeln("Is İ uppercase? ", isUpper('İ'));
writeln("Is ç uppercase? ", isUpper('ç'));
writeln("Is z alphanumeric? ", isAlpha('z'));
writeln("Is new-line whitespace? ", isWhite('\n'));
writeln("Is underline whitespace? ", isWhite('_'));
writeln("The lowercase of Ğ: ", toLower('Ğ'));
writeln("The lowercase of İ: ", toLower('İ'));
writeln("The uppercase of ş: ", toUpper('ş'));
writeln("The uppercase of ı: ", toUpper('ı'));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Is ğ lowercase? true
Is Ş lowercase? false
Is İ uppercase? true
Is ç uppercase? false
Is z alphanumeric? true
Is new-line whitespace? true
Is underline whitespace? false
The lowercase of Ğ: ğ
The lowercase of İ: i
The uppercase of ş: Ş
The uppercase of ı: I
Membaca Karakter di D
Kita bisa membaca karakter menggunakan readf seperti gambar di bawah ini.
readf(" %s", &letter);
Karena pemrograman D mendukung unicode, untuk membaca karakter unicode, kita perlu membaca dua kali dan menulis dua kali untuk mendapatkan hasil yang diharapkan. Ini tidak berfungsi pada kompilator online. Contohnya ditunjukkan di bawah ini.
import std.stdio;
void main() {
char firstCode;
char secondCode;
write("Please enter a letter: ");
readf(" %s", &firstCode);
readf(" %s", &secondCode);
writeln("The letter that has been read: ", firstCode, secondCode);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Please enter a letter: ğ
The letter that has been read: ğ
D menyediakan dua jenis representasi string berikut -
- Array karakter
- String bahasa inti
Array Karakter
Kami dapat mewakili array karakter dalam salah satu dari dua bentuk seperti yang ditunjukkan di bawah ini. Formulir pertama memberikan ukuran secara langsung dan formulir kedua menggunakan metode dup yang membuat salinan string "Selamat pagi" yang dapat ditulis.
char[9] greeting1 = "Hello all";
char[] greeting2 = "Good morning".dup;
Contoh
Berikut adalah contoh sederhana menggunakan formulir larik karakter sederhana di atas.
import std.stdio;
void main(string[] args) {
char[9] greeting1 = "Hello all";
writefln("%s",greeting1);
char[] greeting2 = "Good morning".dup;
writefln("%s",greeting2);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan sesuatu sebagai berikut -
Hello all
Good morning
String Bahasa Inti
String merupakan bawaan dari bahasa inti D. String ini dapat dioperasikan dengan array karakter yang ditunjukkan di atas. Contoh berikut menunjukkan representasi string sederhana.
string greeting1 = "Hello all";
Contoh
import std.stdio;
void main(string[] args) {
string greeting1 = "Hello all";
writefln("%s",greeting1);
char[] greeting2 = "Good morning".dup;
writefln("%s",greeting2);
string greeting3 = greeting1;
writefln("%s",greeting3);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan sesuatu sebagai berikut -
Hello all
Good morning
Hello all
Penggabungan String
Rangkaian string dalam pemrograman D menggunakan simbol tilde (~).
Contoh
import std.stdio;
void main(string[] args) {
string greeting1 = "Good";
char[] greeting2 = "morning".dup;
char[] greeting3 = greeting1~" "~greeting2;
writefln("%s",greeting3);
string greeting4 = "morning";
string greeting5 = greeting1~" "~greeting4;
writefln("%s",greeting5);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan sesuatu sebagai berikut -
Good morning
Good morning
Panjang String
Panjang string dalam byte dapat diambil dengan bantuan fungsi panjang.
Contoh
import std.stdio;
void main(string[] args) {
string greeting1 = "Good";
writefln("Length of string greeting1 is %d",greeting1.length);
char[] greeting2 = "morning".dup;
writefln("Length of string greeting2 is %d",greeting2.length);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Length of string greeting1 is 4
Length of string greeting2 is 7
Perbandingan String
Perbandingan string cukup mudah dalam pemrograman D. Anda dapat menggunakan operator ==, <, dan> untuk perbandingan string.
Contoh
import std.stdio;
void main() {
string s1 = "Hello";
string s2 = "World";
string s3 = "World";
if (s2 == s3) {
writeln("s2: ",s2," and S3: ",s3, " are the same!");
}
if (s1 < s2) {
writeln("'", s1, "' comes before '", s2, "'.");
} else {
writeln("'", s2, "' comes before '", s1, "'.");
}
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan sesuatu sebagai berikut -
s2: World and S3: World are the same!
'Hello' comes before 'World'.
Mengganti String
Kita bisa mengganti string menggunakan string [].
Contoh
import std.stdio;
import std.string;
void main() {
char[] s1 = "hello world ".dup;
char[] s2 = "sample".dup;
s1[6..12] = s2[0..6];
writeln(s1);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan sesuatu sebagai berikut -
hello sample
Metode Indeks
Metode indeks untuk lokasi substring dalam string termasuk indexOf dan lastIndexOf dijelaskan dalam contoh berikut.
Contoh
import std.stdio;
import std.string;
void main() {
char[] s1 = "hello World ".dup;
writeln("indexOf of llo in hello is ",std.string.indexOf(s1,"llo"));
writeln(s1);
writeln("lastIndexOf of O in hello is " ,std.string.lastIndexOf(s1,"O",CaseSensitive.no));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
indexOf.of llo in hello is 2
hello World
lastIndexOf of O in hello is 7
Menangani Kasus
Metode yang digunakan untuk mengubah kasus ditunjukkan pada contoh berikut.
Contoh
import std.stdio;
import std.string;
void main() {
char[] s1 = "hello World ".dup;
writeln("Capitalized string of s1 is ",capitalize(s1));
writeln("Uppercase string of s1 is ",toUpper(s1));
writeln("Lowercase string of s1 is ",toLower(s1));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Capitalized string of s1 is Hello world
Uppercase string of s1 is HELLO WORLD
Lowercase string of s1 is hello world
Membatasi Karakter
Karakter pembatas dalam string ditunjukkan pada contoh berikut.
Contoh
import std.stdio;
import std.string;
void main() {
string s = "H123Hello1";
string result = munch(s, "0123456789H");
writeln("Restrict trailing characters:",result);
result = squeeze(s, "0123456789H");
writeln("Restrict leading characters:",result);
s = " Hello World ";
writeln("Stripping leading and trailing whitespace:",strip(s));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Restrict trailing characters:H123H
Restrict leading characters:ello1
Stripping leading and trailing whitespace:Hello World
Bahasa pemrograman D menyediakan struktur data yang diberi nama arrays, yang menyimpan kumpulan elemen berurutan ukuran tetap dari tipe yang sama. Array digunakan untuk menyimpan kumpulan data. Seringkali lebih berguna untuk memikirkan sebuah array sebagai kumpulan variabel dari tipe yang sama.
Alih-alih mendeklarasikan variabel individual, seperti number0, number1, ..., dan number99, Anda mendeklarasikan satu variabel array seperti bilangan dan menggunakan bilangan [0], bilangan [1], dan ..., bilangan [99] untuk mewakili variabel individu. Elemen tertentu dalam array diakses oleh indeks.
Semua array terdiri dari lokasi memori yang berdekatan. Alamat terendah sesuai dengan elemen pertama dan alamat tertinggi untuk elemen terakhir.
Mendeklarasikan Array
Untuk mendeklarasikan sebuah array dalam bahasa pemrograman D, pemrogram menentukan jenis elemen dan jumlah elemen yang dibutuhkan oleh sebuah array sebagai berikut:
type arrayName [ arraySize ];
Ini disebut larik berdimensi tunggal. The arraySize harus menjadi konstan lebih besar bilangan bulat dari nol dan jenis dapat setiap pemrograman D tipe data bahasa yang valid. Misalnya, untuk mendeklarasikan array 10 elemen yang disebut balance of type double, gunakan pernyataan ini -
double balance[10];
Menginisialisasi Array
Anda dapat menginisialisasi elemen larik bahasa pemrograman D baik satu per satu atau menggunakan satu pernyataan sebagai berikut
double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];
Jumlah nilai antara tanda kurung siku [] di sisi kanan tidak boleh lebih besar dari jumlah elemen yang Anda nyatakan untuk larik di antara tanda kurung siku []. Contoh berikut menetapkan satu elemen dari array -
Jika Anda menghilangkan ukuran array, array yang cukup besar untuk menampung inisialisasi akan dibuat. Karena itu, jika Anda menulis
double balance[] = [1000.0, 2.0, 3.4, 17.0, 50.0];
maka Anda akan membuat larik yang persis sama seperti yang Anda lakukan pada contoh sebelumnya.
balance[4] = 50.0;
Pernyataan di atas memberikan nomor elemen ke-5 dalam array nilai 50.0. Array dengan indeks ke-4 akan menjadi ke-5, yaitu elemen terakhir karena semua array memiliki 0 sebagai indeks dari elemen pertamanya yang disebut juga dengan indeks dasar. Representaion bergambar berikut menunjukkan larik yang sama yang kita diskusikan di atas -
Mengakses Elemen Array
Sebuah elemen diakses dengan mengindeks nama array. Ini dilakukan dengan menempatkan indeks elemen dalam tanda kurung siku setelah nama array. Misalnya -
double salary = balance[9];
Pernyataan di atas mengambil elemen ke- 10 dari array dan memberikan nilai ke variabel gaji . Contoh berikut mengimplementasikan deklarasi, penugasan, dan mengakses array -
import std.stdio;
void main() {
int n[ 10 ]; // n is an array of 10 integers
// initialize elements of array n to 0
for ( int i = 0; i < 10; i++ ) {
n[ i ] = i + 100; // set element at location i to i + 100
}
writeln("Element \t Value");
// output each array element's value
for ( int j = 0; j < 10; j++ ) {
writeln(j," \t ",n[j]);
}
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Element Value
0 100
1 101
2 102
3 103
4 104
5 105
6 106
7 107
8 108
9 109
Array Statis versus Array Dinamis
Jika panjang array ditentukan saat menulis program, array itu adalah array statis. Ketika panjangnya bisa berubah selama eksekusi program, array itu adalah array dinamis.
Mendefinisikan array dinamis lebih sederhana daripada mendefinisikan array dengan panjang tetap karena menghilangkan panjang membuat array dinamis -
int[] dynamicArray;
Properti Array
Berikut adalah properti dari array -
Sr.No. | Deskripsi properti |
---|---|
1 | .init Array statis mengembalikan literal array dengan setiap elemen literal menjadi properti .init dari tipe elemen array. |
2 | .sizeof Larik statis mengembalikan panjang larik dikalikan dengan jumlah byte per elemen larik, sedangkan larik dinamis mengembalikan ukuran referensi larik dinamis, yaitu 8 pada build 32-bit dan 16 pada build 64-bit. |
3 | .length Array statis mengembalikan jumlah elemen dalam larik sedangkan larik dinamis digunakan untuk mendapatkan / mengatur jumlah elemen dalam larik. Panjang adalah tipe size_t. |
4 | .ptr Mengembalikan pointer ke elemen pertama dari array. |
5 | .dup Buat larik dinamis dengan ukuran yang sama dan salin isi larik ke dalamnya. |
6 | .idup Buat larik dinamis dengan ukuran yang sama dan salin isi larik ke dalamnya. Salinan diketik sebagai tidak dapat diubah. |
7 | .reverse Membalikkan urutan elemen dalam larik. Mengembalikan larik. |
8 | .sort Mengurutkan sesuai urutan elemen dalam array. Mengembalikan larik. |
Contoh
Contoh berikut menjelaskan berbagai properti dari sebuah array -
import std.stdio;
void main() {
int n[ 5 ]; // n is an array of 5 integers
// initialize elements of array n to 0
for ( int i = 0; i < 5; i++ ) {
n[ i ] = i + 100; // set element at location i to i + 100
}
writeln("Initialized value:",n.init);
writeln("Length: ",n.length);
writeln("Size of: ",n.sizeof);
writeln("Pointer:",n.ptr);
writeln("Duplicate Array: ",n.dup);
writeln("iDuplicate Array: ",n.idup);
n = n.reverse.dup;
writeln("Reversed Array: ",n);
writeln("Sorted Array: ",n.sort);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Initialized value:[0, 0, 0, 0, 0]
Length: 5
Size of: 20
Pointer:7FFF5A373920
Duplicate Array: [100, 101, 102, 103, 104]
iDuplicate Array: [100, 101, 102, 103, 104]
Reversed Array: [104, 103, 102, 101, 100]
Sorted Array: [100, 101, 102, 103, 104]
Array Multi Dimensi di D
Pemrograman D memungkinkan array multidimensi. Berikut adalah bentuk umum dari deklarasi array multidimensi -
type name[size1][size2]...[sizeN];
Contoh
Deklarasi berikut membuat 5 dimensi. 10. 4 larik bilangan bulat -
int threedim[5][10][4];
Array Dua Dimensi di D
Bentuk paling sederhana dari larik multidimensi adalah larik dua dimensi. Array dua dimensi, pada dasarnya, adalah daftar array satu dimensi. Untuk mendeklarasikan larik bilangan bulat dua dimensi dengan ukuran [x, y] Anda akan menulis sintaks sebagai berikut -
type arrayName [ x ][ y ];
Dimana type dapat berupa tipe data pemrograman D yang valid dan arrayName akan menjadi pengenal pemrograman D yang valid.
Dimana tipe dapat berupa tipe data pemrograman D yang valid dan arrayName adalah pengidentifikasi pemrograman D yang valid.
Array dua dimensi dapat dianggap sebagai tabel, yang memiliki jumlah baris x dan jumlah kolom y. Array dua dimensia berisi tiga baris dan empat kolom dapat ditampilkan seperti di bawah ini -
Jadi, setiap elemen dalam array a diidentifikasi oleh suatu elemen sebagai a[ i ][ j ], dimana a adalah nama larik, dan i dan j adalah subskrip yang secara unik mengidentifikasi setiap elemen dalam a.
Menginisialisasi Array Dua Dimensi
Array multidimensi dapat diinisialisasi dengan menentukan nilai bracketing untuk setiap baris. Larik berikut memiliki 3 baris dan setiap baris memiliki 4 kolom.
int a[3][4] = [
[0, 1, 2, 3] , /* initializers for row indexed by 0 */
[4, 5, 6, 7] , /* initializers for row indexed by 1 */
[8, 9, 10, 11] /* initializers for row indexed by 2 */
];
Tanda kurung kurawal, yang menunjukkan baris yang diinginkan, bersifat opsional. Inisialisasi berikut ini setara dengan contoh sebelumnya -
int a[3][4] = [0,1,2,3,4,5,6,7,8,9,10,11];
Mengakses Elemen Array Dua Dimensi
Sebuah elemen dalam array 2 dimensi diakses menggunakan subskrip, artinya indeks baris dan indeks kolom dari array. Sebagai contoh
int val = a[2][3];
Pernyataan di atas mengambil elemen ke-4 dari baris ke-3 dari larik. Anda dapat memverifikasinya di digram di atas.
import std.stdio;
void main () {
// an array with 5 rows and 2 columns.
int a[5][2] = [ [0,0], [1,2], [2,4], [3,6],[4,8]];
// output each array element's value
for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 2; j++ ) {
writeln( "a[" , i , "][" , j , "]: ",a[i][j]);
}
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
a[0][0]: 0
a[0][1]: 0
a[1][0]: 1
a[1][1]: 2
a[2][0]: 2
a[2][1]: 4
a[3][0]: 3
a[3][1]: 6
a[4][0]: 4
a[4][1]: 8
Operasi Array Umum di D
Berikut adalah berbagai operasi yang dilakukan pada array -
Mengiris Array
Kami sering menggunakan bagian dari sebuah array dan slicing array seringkali cukup membantu. Contoh sederhana untuk mengiris array ditunjukkan di bawah ini.
import std.stdio;
void main () {
// an array with 5 elements.
double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];
double[] b;
b = a[1..3];
writeln(b);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
[2, 3.4]
Menyalin Array
Kami juga menggunakan array penyalinan. Contoh sederhana untuk menyalin array ditunjukkan di bawah ini.
import std.stdio;
void main () {
// an array with 5 elements.
double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];
double b[5];
writeln("Array a:",a);
writeln("Array b:",b);
b[] = a; // the 5 elements of a[5] are copied into b[5]
writeln("Array b:",b);
b[] = a[]; // the 5 elements of a[3] are copied into b[5]
writeln("Array b:",b);
b[1..2] = a[0..1]; // same as b[1] = a[0]
writeln("Array b:",b);
b[0..2] = a[1..3]; // same as b[0] = a[1], b[1] = a[2]
writeln("Array b:",b);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Array a:[1000, 2, 3.4, 17, 50]
Array b:[nan, nan, nan, nan, nan]
Array b:[1000, 2, 3.4, 17, 50]
Array b:[1000, 2, 3.4, 17, 50]
Array b:[1000, 1000, 3.4, 17, 50]
Array b:[2, 3.4, 3.4, 17, 50]
Pengaturan Array
Contoh sederhana untuk mengatur nilai dalam array ditunjukkan di bawah ini.
import std.stdio;
void main () {
// an array with 5 elements.
double a[5];
a[] = 5;
writeln("Array a:",a);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Array a:[5, 5, 5, 5, 5]
Penggabungan Array
Contoh sederhana untuk penggabungan dua larik ditunjukkan di bawah ini.
import std.stdio;
void main () {
// an array with 5 elements.
double a[5] = 5;
double b[5] = 10;
double [] c;
c = a~b;
writeln("Array c: ",c);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Array c: [5, 5, 5, 5, 5, 10, 10, 10, 10, 10]
Array asosiatif memiliki indeks yang tidak harus berupa bilangan bulat, dan dapat diisi secara jarang. Indeks untuk array asosiatif disebutKey, dan tipenya disebut KeyType.
Array asosiatif dideklarasikan dengan menempatkan KeyType dalam [] deklarasi array. Contoh sederhana untuk array asosiatif ditunjukkan di bawah ini.
import std.stdio;
void main () {
int[string] e; // associative array b of ints that are
e["test"] = 3;
writeln(e["test"]);
string[string] f;
f["test"] = "Tuts";
writeln(f["test"]);
writeln(f);
f.remove("test");
writeln(f);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
3
Tuts
["test":"Tuts"]
[]
Menginisialisasi Array Asosiatif
Inisialisasi sederhana dari array asosiatif ditunjukkan di bawah ini.
import std.stdio;
void main () {
int[string] days =
[ "Monday" : 0,
"Tuesday" : 1,
"Wednesday" : 2,
"Thursday" : 3,
"Friday" : 4,
"Saturday" : 5,
"Sunday" : 6 ];
writeln(days["Tuesday"]);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
1
Properti Array Asosiatif
Berikut adalah properti dari array asosiatif -
Sr.No. | Deskripsi properti |
---|---|
1 | .sizeof Mengembalikan ukuran referensi ke array asosiatif; itu adalah 4 dalam versi 32-bit dan 8 pada versi 64-bit. |
2 | .length Mengembalikan jumlah nilai dalam array asosiatif. Tidak seperti array dinamis, ini hanya-baca. |
3 | .dup Buat array asosiatif baru dengan ukuran yang sama dan salin konten dari array asosiatif ke dalamnya. |
4 | .keys Mengembalikan larik dinamis, yang elemen-elemennya merupakan kunci dalam larik asosiatif. |
5 | .values Mengembalikan larik dinamis, yang elemennya adalah nilai dalam larik asosiatif. |
6 | .rehash Mengatur ulang array asosiatif sehingga pencarian lebih efisien. rehash efektif ketika, misalnya, program selesai memuat tabel simbol dan sekarang membutuhkan pencarian cepat di dalamnya. Mengembalikan referensi ke larik yang diatur ulang. |
7 | .byKey() Mengembalikan delegasi yang cocok untuk digunakan sebagai Agregat ke ForeachStatement yang akan mengulangi kunci dari array asosiatif. |
8 | .byValue() Mengembalikan delegasi yang cocok untuk digunakan sebagai Agregat ke ForeachStatement yang akan mengulangi nilai dari array asosiatif. |
9 | .get(Key key, lazy Value defVal) Mencari kunci; jika ada mengembalikan nilai yang sesuai yang lain mengevaluasi dan mengembalikan defVal. |
10 | .remove(Key key) Menghapus objek untuk kunci. |
Contoh
Contoh penggunaan properti di atas ditunjukkan di bawah ini.
import std.stdio;
void main () {
int[string] array1;
array1["test"] = 3;
array1["test2"] = 20;
writeln("sizeof: ",array1.sizeof);
writeln("length: ",array1.length);
writeln("dup: ",array1.dup);
array1.rehash;
writeln("rehashed: ",array1);
writeln("keys: ",array1.keys);
writeln("values: ",array1.values);
foreach (key; array1.byKey) {
writeln("by key: ",key);
}
foreach (value; array1.byValue) {
writeln("by value ",value);
}
writeln("get value for key test: ",array1.get("test",10));
writeln("get value for key test3: ",array1.get("test3",10));
array1.remove("test");
writeln(array1);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
sizeof: 8
length: 2
dup: ["test":3, "test2":20]
rehashed: ["test":3, "test2":20]
keys: ["test", "test2"]
values: [3, 20]
by key: test
by key: test2
by value 3
by value 20
get value for key test: 3
get value for key test3: 10
["test2":20]
Petunjuk pemrograman D mudah dan menyenangkan untuk dipelajari. Beberapa tugas pemrograman D dilakukan lebih mudah dengan pointer, dan tugas pemrograman D lainnya, seperti alokasi memori dinamis, tidak dapat dilakukan tanpanya. Penunjuk sederhana ditunjukkan di bawah ini.
Bukannya langsung menunjuk ke variabel, penunjuk menunjuk ke alamat variabel. Seperti yang Anda ketahui, setiap variabel adalah lokasi memori dan setiap lokasi memori memiliki alamat yang ditentukan yang dapat diakses menggunakan operator ampersand (&) yang menunjukkan alamat dalam memori. Pertimbangkan berikut ini yang mencetak alamat variabel yang ditentukan -
import std.stdio;
void main () {
int var1;
writeln("Address of var1 variable: ",&var1);
char var2[10];
writeln("Address of var2 variable: ",&var2);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Address of var1 variable: 7FFF52691928
Address of var2 variable: 7FFF52691930
Apa Itu Pointer?
SEBUAH pointeradalah variabel yang nilainya adalah alamat variabel lain. Seperti variabel atau konstanta lainnya, Anda harus mendeklarasikan sebuah pointer sebelum Anda dapat mengerjakannya. Bentuk umum dari deklarasi variabel pointer adalah -
type *var-name;
Sini, typeadalah tipe dasar pointer; itu harus merupakan jenis pemrograman yang valid danvar-nameadalah nama variabel penunjuk. Tanda bintang yang Anda gunakan untuk menyatakan penunjuk adalah tanda bintang yang sama dengan yang Anda gunakan untuk perkalian. Namun; dalam pernyataan ini tanda bintang digunakan untuk menunjuk variabel sebagai penunjuk. Berikut adalah deklarasi pointer yang valid -
int *ip; // pointer to an integer
double *dp; // pointer to a double
float *fp; // pointer to a float
char *ch // pointer to character
Tipe data sebenarnya dari nilai semua pointer, apakah integer, float, karakter, atau sebaliknya, adalah sama, angka heksadesimal panjang yang mewakili alamat memori. Satu-satunya perbedaan antara pointer dari tipe data yang berbeda adalah tipe data dari variabel atau konstanta yang ditunjuk pointer.
Menggunakan Pointer dalam pemrograman D.
Ada beberapa operasi penting, ketika kita sering menggunakan pointer.
kami mendefinisikan variabel pointer
menetapkan alamat variabel ke pointer
terakhir akses nilai di alamat yang tersedia di variabel pointer.
Ini dilakukan dengan menggunakan operator unary *yang mengembalikan nilai variabel yang terletak di alamat yang ditentukan oleh operannya. Contoh berikut memanfaatkan operasi ini -
import std.stdio;
void main () {
int var = 20; // actual variable declaration.
int *ip; // pointer variable
ip = &var; // store address of var in pointer variable
writeln("Value of var variable: ",var);
writeln("Address stored in ip variable: ",ip);
writeln("Value of *ip variable: ",*ip);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Value of var variable: 20
Address stored in ip variable: 7FFF5FB7E930
Value of *ip variable: 20
Pointer Null
Itu selalu merupakan praktik yang baik untuk menetapkan pointer NULL ke variabel pointer jika Anda tidak memiliki alamat yang tepat untuk ditetapkan. Ini dilakukan pada saat deklarasi variabel. Sebuah pointer yang diberikan null disebut anull penunjuk.
Pointer null adalah konstanta dengan nilai nol yang ditentukan di beberapa pustaka standar, termasuk iostream. Pertimbangkan program berikut -
import std.stdio;
void main () {
int *ptr = null;
writeln("The value of ptr is " , ptr) ;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
The value of ptr is null
Di sebagian besar sistem operasi, program tidak diizinkan untuk mengakses memori di alamat 0 karena memori tersebut dicadangkan oleh sistem operasi. Namun; alamat memori 0 memiliki arti khusus; itu menandakan bahwa penunjuk tidak dimaksudkan untuk menunjuk ke lokasi memori yang dapat diakses.
Secara konvensi, jika sebuah pointer berisi nilai null (nol), itu dianggap tidak mengarah ke apa-apa. Untuk memeriksa pointer nol Anda dapat menggunakan pernyataan if sebagai berikut -
if(ptr) // succeeds if p is not null
if(!ptr) // succeeds if p is null
Jadi, jika semua pointer yang tidak digunakan diberi nilai null dan Anda menghindari penggunaan pointer null, Anda dapat menghindari penyalahgunaan yang tidak disengaja dari pointer yang tidak diinisialisasi. Sering kali, variabel yang tidak diinisialisasi menyimpan beberapa nilai sampah dan menjadi sulit untuk men-debug program.
Aritmatika Pointer
Ada empat operator aritmatika yang dapat digunakan pada pointer: ++, -, +, dan -
Untuk memahami aritmatika pointer, mari kita pertimbangkan pointer integer bernama ptr, yang menunjuk ke alamat 1000. Dengan asumsi bilangan bulat 32-bit, mari kita lakukan operasi aritmatik berikut pada penunjuk -
ptr++
lalu ptrakan menunjuk ke lokasi 1004 karena setiap kali ptr bertambah, ia menunjuk ke bilangan bulat berikutnya. Operasi ini akan memindahkan penunjuk ke lokasi memori berikutnya tanpa memengaruhi nilai sebenarnya di lokasi memori.
Jika ptr menunjuk ke karakter yang beralamat 1000, kemudian operasi di atas menunjuk ke lokasi 1001 karena karakter berikutnya akan tersedia di 1001.
Menambahkan Pointer
Kami lebih suka menggunakan pointer dalam program kami daripada array karena pointer variabel bisa bertambah, tidak seperti nama array yang tidak bisa bertambah karena itu adalah pointer konstan. Program berikut menambah penunjuk variabel untuk mengakses setiap elemen berikutnya dari array -
import std.stdio;
const int MAX = 3;
void main () {
int var[MAX] = [10, 100, 200];
int *ptr = &var[0];
for (int i = 0; i < MAX; i++, ptr++) {
writeln("Address of var[" , i , "] = ",ptr);
writeln("Value of var[" , i , "] = ",*ptr);
}
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Address of var[0] = 18FDBC
Value of var[0] = 10
Address of var[1] = 18FDC0
Value of var[1] = 100
Address of var[2] = 18FDC4
Value of var[2] = 200
Pointer vs Array
Pointer dan array sangat terkait. Namun, pointer dan array tidak sepenuhnya dapat dipertukarkan. Misalnya, pertimbangkan program berikut -
import std.stdio;
const int MAX = 3;
void main () {
int var[MAX] = [10, 100, 200];
int *ptr = &var[0];
var.ptr[2] = 290;
ptr[0] = 220;
for (int i = 0; i < MAX; i++, ptr++) {
writeln("Address of var[" , i , "] = ",ptr);
writeln("Value of var[" , i , "] = ",*ptr);
}
}
Pada program di atas, Anda dapat melihat var.ptr [2] untuk menyetel elemen kedua dan ptr [0] yang digunakan untuk menyetel elemen ke nol. Operator increment dapat digunakan dengan ptr tetapi tidak dengan var.
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Address of var[0] = 18FDBC
Value of var[0] = 220
Address of var[1] = 18FDC0
Value of var[1] = 100
Address of var[2] = 18FDC4
Value of var[2] = 290
Pointer ke Pointer
Sebuah penunjuk ke penunjuk adalah bentuk dari beberapa tipuan atau rangkaian penunjuk. Biasanya, pointer berisi alamat variabel. Saat kita mendefinisikan sebuah pointer ke sebuah pointer, pointer pertama berisi alamat dari pointer kedua, yang menunjuk ke lokasi yang berisi nilai sebenarnya seperti yang ditunjukkan di bawah ini.
Variabel yang merupakan penunjuk ke penunjuk harus dinyatakan seperti itu. Ini dilakukan dengan menempatkan asterisk tambahan di depan namanya. Sebagai contoh, berikut adalah sintaks untuk mendeklarasikan pointer ke pointer tipe int -
int **var;
Ketika nilai target secara tidak langsung diarahkan oleh penunjuk ke penunjuk, maka untuk mengakses nilai tersebut mengharuskan operator tanda bintang diterapkan dua kali, seperti yang ditunjukkan di bawah ini dalam contoh -
import std.stdio;
const int MAX = 3;
void main () {
int var = 3000;
writeln("Value of var :" , var);
int *ptr = &var;
writeln("Value available at *ptr :" ,*ptr);
int **pptr = &ptr;
writeln("Value available at **pptr :",**pptr);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Value of var :3000
Value available at *ptr :3000
Value available at **pptr :3000
Meneruskan Pointer ke Functions
D memungkinkan Anda untuk memberikan pointer ke suatu fungsi. Untuk melakukannya, ini cukup mendeklarasikan parameter fungsi sebagai tipe pointer.
Contoh sederhana berikut meneruskan pointer ke suatu fungsi.
import std.stdio;
void main () {
// an int array with 5 elements.
int balance[5] = [1000, 2, 3, 17, 50];
double avg;
avg = getAverage( &balance[0], 5 ) ;
writeln("Average is :" , avg);
}
double getAverage(int *arr, int size) {
int i;
double avg, sum = 0;
for (i = 0; i < size; ++i) {
sum += arr[i];
}
avg = sum/size;
return avg;
}
Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut -
Average is :214.4
Kembalikan Pointer dari Functions
Perhatikan fungsi berikut, yang mengembalikan 10 angka menggunakan pointer, artinya alamat elemen array pertama.
import std.stdio;
void main () {
int *p = getNumber();
for ( int i = 0; i < 10; i++ ) {
writeln("*(p + " , i , ") : ",*(p + i));
}
}
int * getNumber( ) {
static int r [10];
for (int i = 0; i < 10; ++i) {
r[i] = i;
}
return &r[0];
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
*(p + 0) : 0
*(p + 1) : 1
*(p + 2) : 2
*(p + 3) : 3
*(p + 4) : 4
*(p + 5) : 5
*(p + 6) : 6
*(p + 7) : 7
*(p + 8) : 8
*(p + 9) : 9
Pointer ke Array
Nama array adalah penunjuk konstan ke elemen pertama dari array. Oleh karena itu, dalam deklarasi -
double balance[50];
balanceadalah penunjuk ke & keseimbangan [0], yang merupakan alamat elemen pertama keseimbangan larik. Jadi, fragmen program berikut menetapkanp alamat elemen pertama balance -
double *p;
double balance[10];
p = balance;
Adalah legal untuk menggunakan nama array sebagai pointer konstan, dan sebaliknya. Oleh karena itu, * (balance + 4) adalah cara yang sah untuk mengakses data secara seimbang [4].
Setelah Anda menyimpan alamat elemen pertama dalam p, Anda dapat mengakses elemen array menggunakan * p, * (p + 1), * (p + 2) dan seterusnya. Contoh berikut menunjukkan semua konsep yang dibahas di atas -
import std.stdio;
void main () {
// an array with 5 elements.
double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];
double *p;
p = &balance[0];
// output each array element's value
writeln("Array values using pointer " );
for ( int i = 0; i < 5; i++ ) {
writeln( "*(p + ", i, ") : ", *(p + i));
}
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Array values using pointer
*(p + 0) : 1000
*(p + 1) : 2
*(p + 2) : 3.4
*(p + 3) : 17
*(p + 4) : 50
Tupel digunakan untuk menggabungkan beberapa nilai sebagai satu objek. Tupel berisi urutan elemen. Elemen dapat berupa tipe, ekspresi, atau alias. Jumlah dan elemen tupel ditetapkan pada waktu kompilasi dan tidak dapat diubah pada waktu proses.
Tupel memiliki karakteristik baik struct maupun array. Elemen tupel bisa dari berbagai jenis seperti struct. Elemen dapat diakses melalui pengindeksan seperti array. Mereka diimplementasikan sebagai fitur perpustakaan oleh template Tuple dari modul std.typecons. Tuple menggunakan TypeTuple dari modul std.typetuple untuk beberapa operasinya.
Tuple Menggunakan tuple ()
Tupel bisa dibangun dengan fungsi tuple (). Anggota tupel diakses oleh nilai indeks. Contohnya ditunjukkan di bawah ini.
Contoh
import std.stdio;
import std.typecons;
void main() {
auto myTuple = tuple(1, "Tuts");
writeln(myTuple);
writeln(myTuple[0]);
writeln(myTuple[1]);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Tuple!(int, string)(1, "Tuts")
1
Tuts
Tuple menggunakan Tuple Template
Tuple juga bisa dibangun langsung oleh template Tuple daripada fungsi tuple (). Jenis dan nama setiap anggota ditentukan sebagai dua parameter templat yang berurutan. Dimungkinkan untuk mengakses anggota berdasarkan properti saat dibuat menggunakan templat.
import std.stdio;
import std.typecons;
void main() {
auto myTuple = Tuple!(int, "id",string, "value")(1, "Tuts");
writeln(myTuple);
writeln("by index 0 : ", myTuple[0]);
writeln("by .id : ", myTuple.id);
writeln("by index 1 : ", myTuple[1]);
writeln("by .value ", myTuple.value);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut
Tuple!(int, "id", string, "value")(1, "Tuts")
by index 0 : 1
by .id : 1
by index 1 : Tuts
by .value Tuts
Memperluas Parameter Properti dan Fungsi
Anggota Tuple dapat diperluas baik dengan properti .expand atau dengan mengiris. Nilai yang diperluas / diiris ini dapat diteruskan sebagai daftar argumen fungsi. Contohnya ditunjukkan di bawah ini.
Contoh
import std.stdio;
import std.typecons;
void method1(int a, string b, float c, char d) {
writeln("method 1 ",a,"\t",b,"\t",c,"\t",d);
}
void method2(int a, float b, char c) {
writeln("method 2 ",a,"\t",b,"\t",c);
}
void main() {
auto myTuple = tuple(5, "my string", 3.3, 'r');
writeln("method1 call 1");
method1(myTuple[]);
writeln("method1 call 2");
method1(myTuple.expand);
writeln("method2 call 1");
method2(myTuple[0], myTuple[$-2..$]);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
method1 call 1
method 1 5 my string 3.3 r
method1 call 2
method 1 5 my string 3.3 r
method2 call 1
method 2 5 3.3 r
TypeTuple
TypeTuple didefinisikan dalam modul std.typetuple. Daftar nilai dan jenis yang dipisahkan koma. Contoh sederhana menggunakan TypeTuple diberikan di bawah ini. TypeTuple digunakan untuk membuat daftar argumen, daftar template, dan daftar literal array.
import std.stdio;
import std.typecons;
import std.typetuple;
alias TypeTuple!(int, long) TL;
void method1(int a, string b, float c, char d) {
writeln("method 1 ",a,"\t",b,"\t",c,"\t",d);
}
void method2(TL tl) {
writeln(tl[0],"\t", tl[1] );
}
void main() {
auto arguments = TypeTuple!(5, "my string", 3.3,'r');
method1(arguments);
method2(5, 6L);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
method 1 5 my string 3.3 r
5 6
Itu structure adalah tipe data lain yang ditentukan pengguna yang tersedia dalam pemrograman D, yang memungkinkan Anda untuk menggabungkan item data dari berbagai jenis.
Struktur digunakan untuk merepresentasikan record. Misalkan Anda ingin melacak buku Anda di perpustakaan. Anda mungkin ingin melacak atribut berikut tentang setiap buku -
- Title
- Author
- Subject
- ID Buku
Mendefinisikan Struktur
Untuk menentukan struktur, Anda harus menggunakan structpernyataan. Pernyataan struct mendefinisikan tipe data baru, dengan lebih dari satu anggota untuk program Anda. Format pernyataan struct adalah ini -
struct [structure tag] {
member definition;
member definition;
...
member definition;
} [one or more structure variables];
Itu structure tagbersifat opsional dan setiap definisi anggota adalah definisi variabel normal, seperti int i; atau float f; atau definisi variabel valid lainnya. Di akhir definisi struktur sebelum titik koma, Anda dapat menentukan satu atau beberapa variabel struktur yang bersifat opsional. Inilah cara Anda mendeklarasikan struktur Buku -
struct Books {
char [] title;
char [] author;
char [] subject;
int book_id;
};
Mengakses Anggota Struktur
Untuk mengakses anggota struktur mana pun, Anda menggunakan member access operator (.). Operator akses anggota dikodekan sebagai periode antara nama variabel struktur dan anggota struktur yang ingin kita akses. Anda akan menggunakanstructkata kunci untuk mendefinisikan variabel jenis struktur. Contoh berikut menjelaskan penggunaan struktur -
import std.stdio;
struct Books {
char [] title;
char [] author;
char [] subject;
int book_id;
};
void main( ) {
Books Book1; /* Declare Book1 of type Book */
Books Book2; /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "D Programming".dup;
Book1.author = "Raj".dup;
Book1.subject = "D Programming Tutorial".dup;
Book1.book_id = 6495407;
/* book 2 specification */
Book2.title = "D Programming".dup;
Book2.author = "Raj".dup;
Book2.subject = "D Programming Tutorial".dup;
Book2.book_id = 6495700;
/* print Book1 info */
writeln( "Book 1 title : ", Book1.title);
writeln( "Book 1 author : ", Book1.author);
writeln( "Book 1 subject : ", Book1.subject);
writeln( "Book 1 book_id : ", Book1.book_id);
/* print Book2 info */
writeln( "Book 2 title : ", Book2.title);
writeln( "Book 2 author : ", Book2.author);
writeln( "Book 2 subject : ", Book2.subject);
writeln( "Book 2 book_id : ", Book2.book_id);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Book 1 title : D Programming
Book 1 author : Raj
Book 1 subject : D Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : D Programming
Book 2 author : Raj
Book 2 subject : D Programming Tutorial
Book 2 book_id : 6495700
Struktur sebagai Argumen Fungsi
Anda dapat mengirimkan struktur sebagai argumen fungsi dengan cara yang sangat mirip seperti Anda meneruskan variabel atau penunjuk lainnya. Anda akan mengakses variabel struktur dengan cara yang sama seperti yang Anda akses pada contoh di atas -
import std.stdio;
struct Books {
char [] title;
char [] author;
char [] subject;
int book_id;
};
void main( ) {
Books Book1; /* Declare Book1 of type Book */
Books Book2; /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "D Programming".dup;
Book1.author = "Raj".dup;
Book1.subject = "D Programming Tutorial".dup;
Book1.book_id = 6495407;
/* book 2 specification */
Book2.title = "D Programming".dup;
Book2.author = "Raj".dup;
Book2.subject = "D Programming Tutorial".dup;
Book2.book_id = 6495700;
/* print Book1 info */
printBook( Book1 );
/* Print Book2 info */
printBook( Book2 );
}
void printBook( Books book ) {
writeln( "Book title : ", book.title);
writeln( "Book author : ", book.author);
writeln( "Book subject : ", book.subject);
writeln( "Book book_id : ", book.book_id);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Book title : D Programming
Book author : Raj
Book subject : D Programming Tutorial
Book book_id : 6495407
Book title : D Programming
Book author : Raj
Book subject : D Programming Tutorial
Book book_id : 6495700
Structs Initialization
Struktur bisa diinisialisasi dalam dua bentuk, satu menggunakan konstrutor dan lainnya menggunakan format {}. Contohnya ditunjukkan di bawah ini.
Contoh
import std.stdio;
struct Books {
char [] title;
char [] subject = "Empty".dup;
int book_id = -1;
char [] author = "Raj".dup;
};
void main( ) {
Books Book1 = Books("D Programming".dup, "D Programming Tutorial".dup, 6495407 );
printBook( Book1 );
Books Book2 = Books("D Programming".dup,
"D Programming Tutorial".dup, 6495407,"Raj".dup );
printBook( Book2 );
Books Book3 = {title:"Obj C programming".dup, book_id : 1001};
printBook( Book3 );
}
void printBook( Books book ) {
writeln( "Book title : ", book.title);
writeln( "Book author : ", book.author);
writeln( "Book subject : ", book.subject);
writeln( "Book book_id : ", book.book_id);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Book title : D Programming
Book author : Raj
Book subject : D Programming Tutorial
Book book_id : 6495407
Book title : D Programming
Book author : Raj
Book subject : D Programming Tutorial
Book book_id : 6495407
Book title : Obj C programming
Book author : Raj
Book subject : Empty
Book book_id : 1001
Anggota Statis
Variabel statis diinisialisasi hanya sekali. Misalnya, untuk memiliki id unik untuk buku, kita dapat menjadikan book_id sebagai statis dan menambah id buku. Contohnya ditunjukkan di bawah ini.
Contoh
import std.stdio;
struct Books {
char [] title;
char [] subject = "Empty".dup;
int book_id;
char [] author = "Raj".dup;
static int id = 1000;
};
void main( ) {
Books Book1 = Books("D Programming".dup, "D Programming Tutorial".dup,++Books.id );
printBook( Book1 );
Books Book2 = Books("D Programming".dup, "D Programming Tutorial".dup,++Books.id);
printBook( Book2 );
Books Book3 = {title:"Obj C programming".dup, book_id:++Books.id};
printBook( Book3 );
}
void printBook( Books book ) {
writeln( "Book title : ", book.title);
writeln( "Book author : ", book.author);
writeln( "Book subject : ", book.subject);
writeln( "Book book_id : ", book.book_id);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Book title : D Programming
Book author : Raj
Book subject : D Programming Tutorial
Book book_id : 1001
Book title : D Programming
Book author : Raj
Book subject : D Programming Tutorial
Book book_id : 1002
Book title : Obj C programming
Book author : Raj
Book subject : Empty
Book book_id : 1003
SEBUAH unionadalah tipe data khusus yang tersedia di D yang memungkinkan Anda menyimpan tipe data berbeda di lokasi memori yang sama. Anda dapat menentukan serikat dengan banyak anggota, tetapi hanya satu anggota yang dapat berisi nilai pada waktu tertentu. Serikat pekerja menyediakan cara yang efisien untuk menggunakan lokasi memori yang sama untuk berbagai tujuan.
Mendefinisikan Serikat di D
Untuk mendefinisikan serikat, Anda harus menggunakan pernyataan serikat dengan cara yang sangat mirip seperti yang Anda lakukan saat mendefinisikan struktur. Pernyataan serikat mendefinisikan tipe data baru, dengan lebih dari satu anggota untuk program Anda. Format pernyataan serikat adalah sebagai berikut -
union [union tag] {
member definition;
member definition;
...
member definition;
} [one or more union variables];
Itu union tagbersifat opsional dan setiap definisi anggota adalah definisi variabel normal, seperti int i; atau float f; atau definisi variabel valid lainnya. Di akhir definisi gabungan, sebelum titik koma terakhir, Anda dapat menentukan satu atau lebih variabel gabungan tetapi ini opsional. Berikut adalah cara Anda mendefinisikan tipe gabungan bernama Data yang memiliki tiga anggotai, f, dan str -
union Data {
int i;
float f;
char str[20];
} data;
Variabel dari Datatype dapat menyimpan integer, bilangan floating-point, atau string karakter. Ini berarti satu variabel (lokasi memori yang sama) dapat digunakan untuk menyimpan berbagai jenis data. Anda dapat menggunakan tipe data bawaan atau yang ditentukan pengguna di dalam serikat berdasarkan kebutuhan Anda.
Memori yang ditempati oleh serikat pekerja akan cukup besar untuk menampung anggota serikat terbesar. Sebagai contoh, pada contoh di atas, tipe Data akan menempati ruang memori 20 byte karena ini adalah ruang maksimum yang dapat ditempati oleh karakter string. Contoh berikut menampilkan ukuran memori total yang ditempati oleh gabungan di atas -
import std.stdio;
union Data {
int i;
float f;
char str[20];
};
int main( ) {
Data data;
writeln( "Memory size occupied by data : ", data.sizeof);
return 0;
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Memory size occupied by data : 20
Mengakses Anggota Serikat
Untuk mengakses anggota serikat mana pun, kami menggunakan member access operator (.). Operator akses anggota dikodekan sebagai periode antara nama variabel serikat dan anggota serikat yang ingin kita akses. Anda akan menggunakan kata kunci union untuk mendefinisikan variabel tipe union.
Contoh
Contoh berikut menjelaskan penggunaan union -
import std.stdio;
union Data {
int i;
float f;
char str[13];
};
void main( ) {
Data data;
data.i = 10;
data.f = 220.5;
data.str = "D Programming".dup;
writeln( "size of : ", data.sizeof);
writeln( "data.i : ", data.i);
writeln( "data.f : ", data.f);
writeln( "data.str : ", data.str);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
size of : 16
data.i : 1917853764
data.f : 4.12236e+30
data.str : D Programming
Di sini, Anda dapat melihat nilai dari i dan f anggota serikat rusak karena nilai akhir yang ditetapkan ke variabel telah menempati lokasi memori dan ini adalah alasan mengapa nilai str anggota dicetak dengan sangat baik.
Sekarang mari kita lihat contoh yang sama sekali lagi di mana kita akan menggunakan satu variabel pada satu waktu yang merupakan tujuan utama memiliki penyatuan -
Contoh Modifikasi
import std.stdio;
union Data {
int i;
float f;
char str[13];
};
void main( ) {
Data data;
writeln( "size of : ", data.sizeof);
data.i = 10;
writeln( "data.i : ", data.i);
data.f = 220.5;
writeln( "data.f : ", data.f);
data.str = "D Programming".dup;
writeln( "data.str : ", data.str);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
size of : 16
data.i : 10
data.f : 220.5
data.str : D Programming
Di sini, semua anggota dicetak dengan sangat baik karena satu anggota digunakan pada satu waktu.
Rentang adalah abstraksi dari akses elemen. Abstraksi ini memungkinkan penggunaan sejumlah besar algoritme pada sejumlah besar jenis wadah. Rentang menekankan bagaimana elemen kontainer diakses, berbeda dengan bagaimana kontainer diimplementasikan. Rentang adalah konsep yang sangat sederhana yang didasarkan pada apakah suatu tipe mendefinisikan set fungsi anggota tertentu.
Rentang adalah bagian integral dari irisan D. D adalah implementasi dari rentang RandomAccessRange yang paling kuat, dan ada banyak fitur rentang di Phobos. Banyak algoritma Phobos mengembalikan objek jarak temporer. Misalnya, filter () memilih elemen yang lebih besar dari 10 dalam kode berikut sebenarnya mengembalikan objek rentang, bukan larik.
Rentang angka
Rentang angka cukup umum digunakan dan rentang angka ini berjenis int. Beberapa contoh rentang angka ditampilkan di bawah ini -
// Example 1
foreach (value; 3..7)
// Example 2
int[] slice = array[5..10];
Phobos Ranges
Rentang yang terkait dengan struct dan antarmuka kelas adalah rentang phobos. Phobos adalah runtime resmi dan pustaka standar yang disertakan dengan kompiler bahasa D.
Ada berbagai jenis rentang yang meliputi -
- InputRange
- ForwardRange
- BidirectionalRange
- RandomAccessRange
- OutputRange
InputRange
Rentang paling sederhana adalah rentang input. Rentang lainnya membawa lebih banyak persyaratan di atas rentang yang menjadi dasarnya. Ada tiga fungsi yang dibutuhkan InputRange -
empty- Ini menentukan apakah kisaran tersebut kosong; itu harus mengembalikan nilai true ketika kisaran dianggap kosong; false jika tidak.
front - Ini memberikan akses ke elemen di awal rentang.
popFront() - Mempersingkat jarak dari awal dengan menghilangkan elemen pertama.
Contoh
import std.stdio;
import std.string;
struct Student {
string name;
int number;
string toString() const {
return format("%s(%s)", name, number);
}
}
struct School {
Student[] students;
}
struct StudentRange {
Student[] students;
this(School school) {
this.students = school.students;
}
@property bool empty() const {
return students.length == 0;
}
@property ref Student front() {
return students[0];
}
void popFront() {
students = students[1 .. $];
}
}
void main() {
auto school = School([ Student("Raj", 1), Student("John", 2), Student("Ram", 3)]);
auto range = StudentRange(school);
writeln(range);
writeln(school.students.length);
writeln(range.front);
range.popFront;
writeln(range.empty);
writeln(range);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
[Raj(1), John(2), Ram(3)]
3
Raj(1)
false
[John(2), Ram(3)]
ForwardRange
ForwardRange juga memerlukan bagian fungsi anggota simpan dari tiga fungsi InputRange lainnya dan mengembalikan salinan rentang saat fungsi simpan dipanggil.
import std.array;
import std.stdio;
import std.string;
import std.range;
struct FibonacciSeries {
int first = 0;
int second = 1;
enum empty = false; // infinite range
@property int front() const {
return first;
}
void popFront() {
int third = first + second;
first = second;
second = third;
}
@property FibonacciSeries save() const {
return this;
}
}
void report(T)(const dchar[] title, const ref T range) {
writefln("%s: %s", title, range.take(5));
}
void main() {
auto range = FibonacciSeries();
report("Original range", range);
range.popFrontN(2);
report("After removing two elements", range);
auto theCopy = range.save;
report("The copy", theCopy);
range.popFrontN(3);
report("After removing three more elements", range);
report("The copy", theCopy);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Original range: [0, 1, 1, 2, 3]
After removing two elements: [1, 2, 3, 5, 8]
The copy: [1, 2, 3, 5, 8]
After removing three more elements: [5, 8, 13, 21, 34]
The copy: [1, 2, 3, 5, 8]
BidirectionalRange
BidirectionalRange juga menyediakan dua fungsi anggota di atas fungsi anggota ForwardRange. Fungsi belakang yang mirip dengan depan, menyediakan akses ke elemen terakhir dari jangkauan. Fungsi popBack mirip dengan fungsi popFront dan menghapus elemen terakhir dari rentang.
Contoh
import std.array;
import std.stdio;
import std.string;
struct Reversed {
int[] range;
this(int[] range) {
this.range = range;
}
@property bool empty() const {
return range.empty;
}
@property int front() const {
return range.back; // reverse
}
@property int back() const {
return range.front; // reverse
}
void popFront() {
range.popBack();
}
void popBack() {
range.popFront();
}
}
void main() {
writeln(Reversed([ 1, 2, 3]));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
[3, 2, 1]
RandomAccessRange tak terbatas
opIndex () juga diperlukan jika dibandingkan dengan ForwardRange. Selain itu, nilai fungsi kosong akan diketahui pada waktu kompilasi sebagai false. Contoh sederhana dijelaskan dengan rentang kotak ditunjukkan di bawah ini.
import std.array;
import std.stdio;
import std.string;
import std.range;
import std.algorithm;
class SquaresRange {
int first;
this(int first = 0) {
this.first = first;
}
enum empty = false;
@property int front() const {
return opIndex(0);
}
void popFront() {
++first;
}
@property SquaresRange save() const {
return new SquaresRange(first);
}
int opIndex(size_t index) const {
/* This function operates at constant time */
immutable integerValue = first + cast(int)index;
return integerValue * integerValue;
}
}
bool are_lastTwoDigitsSame(int value) {
/* Must have at least two digits */
if (value < 10) {
return false;
}
/* Last two digits must be divisible by 11 */
immutable lastTwoDigits = value % 100;
return (lastTwoDigits % 11) == 0;
}
void main() {
auto squares = new SquaresRange();
writeln(squares[5]);
writeln(squares[10]);
squares.popFrontN(5);
writeln(squares[0]);
writeln(squares.take(50).filter!are_lastTwoDigitsSame);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
25
100
25
[100, 144, 400, 900, 1444, 1600, 2500]
Hingga RandomAccessRange
opIndex () dan panjang juga diperlukan jika dibandingkan dengan rentang dua arah. Ini dijelaskan dengan bantuan contoh detail yang menggunakan deret Fibonacci dan contoh Rentang Kuadrat yang digunakan sebelumnya. Contoh ini bekerja dengan baik pada kompilator D normal tetapi tidak bekerja pada kompilator online.
Contoh
import std.array;
import std.stdio;
import std.string;
import std.range;
import std.algorithm;
struct FibonacciSeries {
int first = 0;
int second = 1;
enum empty = false; // infinite range
@property int front() const {
return first;
}
void popFront() {
int third = first + second;
first = second;
second = third;
}
@property FibonacciSeries save() const {
return this;
}
}
void report(T)(const dchar[] title, const ref T range) {
writefln("%40s: %s", title, range.take(5));
}
class SquaresRange {
int first;
this(int first = 0) {
this.first = first;
}
enum empty = false;
@property int front() const {
return opIndex(0);
}
void popFront() {
++first;
}
@property SquaresRange save() const {
return new SquaresRange(first);
}
int opIndex(size_t index) const {
/* This function operates at constant time */
immutable integerValue = first + cast(int)index;
return integerValue * integerValue;
}
}
bool are_lastTwoDigitsSame(int value) {
/* Must have at least two digits */
if (value < 10) {
return false;
}
/* Last two digits must be divisible by 11 */
immutable lastTwoDigits = value % 100;
return (lastTwoDigits % 11) == 0;
}
struct Together {
const(int)[][] slices;
this(const(int)[][] slices ...) {
this.slices = slices.dup;
clearFront();
clearBack();
}
private void clearFront() {
while (!slices.empty && slices.front.empty) {
slices.popFront();
}
}
private void clearBack() {
while (!slices.empty && slices.back.empty) {
slices.popBack();
}
}
@property bool empty() const {
return slices.empty;
}
@property int front() const {
return slices.front.front;
}
void popFront() {
slices.front.popFront();
clearFront();
}
@property Together save() const {
return Together(slices.dup);
}
@property int back() const {
return slices.back.back;
}
void popBack() {
slices.back.popBack();
clearBack();
}
@property size_t length() const {
return reduce!((a, b) => a + b.length)(size_t.init, slices);
}
int opIndex(size_t index) const {
/* Save the index for the error message */
immutable originalIndex = index;
foreach (slice; slices) {
if (slice.length > index) {
return slice[index];
} else {
index -= slice.length;
}
}
throw new Exception(
format("Invalid index: %s (length: %s)", originalIndex, this.length));
}
}
void main() {
auto range = Together(FibonacciSeries().take(10).array, [ 777, 888 ],
(new SquaresRange()).take(5).array);
writeln(range.save);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 777, 888, 0, 1, 4, 9, 16]
OutputRange
OutputRange mewakili keluaran elemen yang dialirkan, mirip dengan mengirim karakter ke stdout. OutputRange membutuhkan dukungan untuk operasi put (range, element). put () adalah fungsi yang didefinisikan dalam modul std.range. Ini menentukan kapabilitas rentang dan elemen pada waktu kompilasi dan menggunakan metode yang paling tepat untuk digunakan untuk mengeluarkan elemen. Contoh sederhana ditunjukkan di bawah ini.
import std.algorithm;
import std.stdio;
struct MultiFile {
string delimiter;
File[] files;
this(string delimiter, string[] fileNames ...) {
this.delimiter = delimiter;
/* stdout is always included */
this.files ~= stdout;
/* A File object for each file name */
foreach (fileName; fileNames) {
this.files ~= File(fileName, "w");
}
}
void put(T)(T element) {
foreach (file; files) {
file.write(element, delimiter);
}
}
}
void main() {
auto output = MultiFile("\n", "output_0", "output_1");
copy([ 1, 2, 3], output);
copy([ "red", "blue", "green" ], output);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
[1, 2, 3]
["red", "blue", "green"]
Alias, sesuai namanya memberikan nama alternatif untuk nama yang sudah ada. Sintaks untuk alias ditampilkan di bawah ini.
alias new_name = existing_name;
Berikut ini adalah sintaks yang lebih lama, kalau-kalau Anda merujuk beberapa contoh format yang lebih lama. Sangat tidak disarankan untuk menggunakan ini.
alias existing_name new_name;
Ada juga sintaks lain yang digunakan dengan ekspresi dan diberikan di bawah ini di mana kita bisa langsung menggunakan nama alias sebagai pengganti ekspresi.
alias expression alias_name ;
Seperti yang Anda ketahui, typedef menambahkan kemampuan untuk membuat tipe baru. Alias dapat melakukan pekerjaan typedef dan bahkan lebih. Contoh sederhana untuk menggunakan alias ditampilkan di bawah ini yang menggunakan header std.conv yang menyediakan kemampuan konversi tipe.
import std.stdio;
import std.conv:to;
alias to!(string) toString;
void main() {
int a = 10;
string s = "Test"~toString(a);
writeln(s);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Test10
Dalam contoh di atas alih-alih menggunakan to! String (a), kami menetapkannya ke nama alias toString sehingga lebih nyaman dan lebih sederhana untuk dipahami.
Alias untuk Tuple
Mari kita lihat contoh lain di mana kita dapat mengatur nama alias untuk Tuple.
import std.stdio;
import std.typetuple;
alias TypeTuple!(int, long) TL;
void method1(TL tl) {
writeln(tl[0],"\t", tl[1] );
}
void main() {
method1(5, 6L);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
5 6
Dalam contoh di atas, tipe tupel ditugaskan ke variabel alias dan menyederhanakan definisi metode dan akses variabel. Jenis akses ini bahkan lebih berguna ketika kami mencoba menggunakan kembali tupel jenis tersebut.
Alias untuk Tipe Data
Sering kali, kami mungkin mendefinisikan tipe data umum yang perlu digunakan di seluruh aplikasi. Ketika beberapa programmer membuat kode aplikasi, ini bisa menjadi kasus di mana satu orang menggunakan int, double lainnya, dan seterusnya. Untuk menghindari konflik seperti itu, kami sering menggunakan tipe untuk tipe data. Contoh sederhana ditunjukkan di bawah ini.
Contoh
import std.stdio;
alias int myAppNumber;
alias string myAppString;
void main() {
myAppNumber i = 10;
myAppString s = "TestString";
writeln(i,s);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
10TestString
Alias untuk Variabel Kelas
Seringkali ada persyaratan di mana kita perlu mengakses variabel anggota superclass di subclass, ini dapat dilakukan dengan alias, mungkin dengan nama yang berbeda.
Jika Anda baru mengenal konsep kelas dan warisan, lihat tutorial tentang kelas dan warisan sebelum memulai dengan bagian ini.
Contoh
Contoh sederhana ditunjukkan di bawah ini.
import std.stdio;
class Shape {
int area;
}
class Square : Shape {
string name() const @property {
return "Square";
}
alias Shape.area squareArea;
}
void main() {
auto square = new Square;
square.squareArea = 42;
writeln(square.name);
writeln(square.squareArea);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Square
42
Alias ini
Alias ini memberikan kemampuan konversi tipe otomatis dari tipe yang ditentukan pengguna. Sintaksnya ditampilkan di bawah ini di mana kata kunci alias dan ini ditulis di kedua sisi variabel anggota atau fungsi anggota.
alias member_variable_or_member_function this;
Contoh
Contoh ditunjukkan di bawah ini untuk menunjukkan kekuatan alias ini.
import std.stdio;
struct Rectangle {
long length;
long breadth;
double value() const @property {
return cast(double) length * breadth;
}
alias value this;
}
double volume(double rectangle, double height) {
return rectangle * height;
}
void main() {
auto rectangle = Rectangle(2, 3);
writeln(volume(rectangle, 5));
}
Dalam contoh di atas, Anda dapat melihat bahwa struct persegi panjang diubah menjadi nilai ganda dengan bantuan alias metode ini.
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
30
Mixin adalah struct yang memungkinkan pencampuran kode yang dihasilkan ke dalam kode sumber. Mixin dapat dari jenis berikut -
- String Mixins
- Mixins Template
- Ruang nama mixin
String Mixins
D memiliki kemampuan untuk memasukkan kode sebagai string selama string tersebut diketahui pada saat kompilasi. Sintaks dari campuran string ditampilkan di bawah ini -
mixin (compile_time_generated_string)
Contoh
Contoh sederhana untuk mixin string ditunjukkan di bawah ini.
import std.stdio;
void main() {
mixin(`writeln("Hello World!");`);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Hello World!
Berikut adalah contoh lain di mana kita dapat melewatkan string dalam waktu kompilasi sehingga mixin dapat menggunakan fungsi untuk menggunakan kembali kode. Itu ditunjukkan di bawah ini.
import std.stdio;
string print(string s) {
return `writeln("` ~ s ~ `");`;
}
void main() {
mixin (print("str1"));
mixin (print("str2"));
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
str1
str2
Mixins Template
Template D menentukan pola kode umum, agar kompiler dapat menghasilkan instance aktual dari pola itu. Template dapat menghasilkan fungsi, struct, unions, class, interface, dan kode D legal lainnya. Sintaks mixin template seperti yang ditunjukkan di bawah ini.
mixin a_template!(template_parameters)
Contoh sederhana untuk mixin string ditunjukkan di bawah ini di mana kita membuat template dengan class Department dan mixin yang membuat template dan karenanya membuat fungsi setName dan printNames tersedia untuk sekolah struktur.
Contoh
import std.stdio;
template Department(T, size_t count) {
T[count] names;
void setName(size_t index, T name) {
names[index] = name;
}
void printNames() {
writeln("The names");
foreach (i, name; names) {
writeln(i," : ", name);
}
}
}
struct College {
mixin Department!(string, 2);
}
void main() {
auto college = College();
college.setName(0, "name1");
college.setName(1, "name2");
college.printNames();
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
The names
0 : name1
1 : name2
Ruang Nama Mixin
Ruang nama mixin digunakan untuk menghindari ambiguitas di mixin template. Misalnya, bisa ada dua variabel, satu didefinisikan secara eksplisit di main dan yang lain dicampur masuk. Ketika nama yang dicampur sama dengan nama yang ada di lingkup sekitarnya, maka nama yang ada di lingkup sekitarnya akan bekas. Contoh ini ditunjukkan di bawah.
Contoh
import std.stdio;
template Person() {
string name;
void print() {
writeln(name);
}
}
void main() {
string name;
mixin Person a;
name = "name 1";
writeln(name);
a.name = "name 2";
print();
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
name 1
name 2
Modul adalah blok bangunan D. Mereka didasarkan pada konsep sederhana. Setiap file sumber adalah modul. Karenanya, file tunggal tempat kami menulis program adalah modul individual. Secara default, nama modul sama dengan nama filenya tanpa ekstensi .d.
Ketika ditentukan secara eksplisit, nama modul ditentukan oleh kata kunci modul, yang harus muncul sebagai baris non-komentar pertama di file sumber. Misalnya, asumsikan bahwa nama file sumber adalah "karyawan.d". Kemudian nama modul ditentukan oleh kata kunci modul diikuti oleh karyawan . Seperti yang ditunjukkan di bawah ini.
module employee;
class Employee {
// Class definition goes here.
}
Garis modul adalah opsional. Jika tidak ditentukan, itu sama dengan nama file tanpa ekstensi .d.
Nama File dan Modul
D mendukung Unicode dalam kode sumber dan nama modul. Namun, dukungan Unicode untuk sistem file bervariasi. Misalnya, meskipun sebagian besar sistem file Linux mendukung Unicode, nama file dalam sistem file Windows mungkin tidak membedakan antara huruf kecil dan huruf besar. Selain itu, sebagian besar sistem file membatasi karakter yang dapat digunakan dalam nama file dan direktori. Untuk alasan portabilitas, saya menganjurkan agar Anda hanya menggunakan huruf kecil ASCII dalam nama file. Misalnya, "employee.d" akan menjadi nama file yang cocok untuk kelas bernama employee.
Karenanya, nama modul juga akan terdiri dari huruf ASCII -
module employee; // Module name consisting of ASCII letters
class eëmployëë { }
Paket D
Kombinasi dari modul terkait disebut paket. Paket D juga merupakan konsep yang sederhana: File sumber yang berada di dalam direktori yang sama dianggap milik paket yang sama. Nama direktori menjadi nama paket, yang juga harus ditentukan sebagai bagian pertama dari nama modul.
Misalnya, jika "employee.d" dan "office.d" ada di dalam direktori "company", maka menentukan nama direktori bersama dengan nama modul membuatnya menjadi bagian dari paket yang sama -
module company.employee;
class Employee { }
Demikian pula, untuk modul kantor -
module company.office;
class Office { }
Karena nama paket sesuai dengan nama direktori, nama paket modul yang lebih dalam dari satu tingkat direktori harus mencerminkan hierarki itu. Misalnya, jika direktori "perusahaan" menyertakan direktori "cabang", nama modul di dalam direktori itu juga akan menyertakan cabang.
module company.branch.employee;
Menggunakan Modul dalam Program
Kata kunci import, yang telah kami gunakan di hampir setiap program sejauh ini, adalah untuk memperkenalkan modul ke modul saat ini -
import std.stdio;
Nama modul mungkin berisi nama paket juga. Misalnya, std. bagian di atas menunjukkan bahwa stdio adalah modul yang merupakan bagian dari paket std.
Lokasi Modul
Kompilator menemukan file modul dengan mengubah nama paket dan modul langsung ke direktori dan nama file.
Misalnya, dua modul karyawan dan kantor masing-masing akan ditempatkan sebagai "perusahaan / karyawan.d" dan "hewan / kantor.d" (atau "perusahaan \ karyawan.d" dan "perusahaan \ kantor.d", bergantung pada sistem file) untuk perusahaan.pekerja dan perusahaan.kantor.
Nama Modul Panjang dan Pendek
Nama-nama yang digunakan dalam program dapat dieja dengan modul dan nama paket seperti yang ditunjukkan di bawah ini.
import company.employee;
auto employee0 = Employee();
auto employee1 = company.employee.Employee();
Nama yang panjang biasanya tidak diperlukan tetapi terkadang ada konflik nama. Misalnya, ketika mengacu pada nama yang muncul di lebih dari satu modul, kompilator tidak dapat memutuskan yang mana yang dimaksud. Program berikut mengeja nama panjang untuk membedakan antara dua struct karyawan terpisah yang didefinisikan dalam dua modul terpisah: perusahaan dan perguruan tinggi. .
Modul karyawan pertama di perusahaan folder adalah sebagai berikut.
module company.employee;
import std.stdio;
class Employee {
public:
string str;
void print() {
writeln("Company Employee: ",str);
}
}
Modul karyawan kedua di folder college adalah sebagai berikut.
module college.employee;
import std.stdio;
class Employee {
public:
string str;
void print() {
writeln("College Employee: ",str);
}
}
Modul utama di hello.d harus disimpan di folder yang berisi folder kampus dan perusahaan. Itu adalah sebagai berikut.
import company.employee;
import college.employee;
import std.stdio;
void main() {
auto myemployee1 = new company.employee.Employee();
myemployee1.str = "emp1";
myemployee1.print();
auto myemployee2 = new college.employee.Employee();
myemployee2.str = "emp2";
myemployee2.print();
}
Kata kunci import tidak cukup untuk membuat modul menjadi bagian dari program. Ini hanya menyediakan fitur modul di dalam modul saat ini. Sebanyak itu hanya diperlukan untuk mengkompilasi kode.
Untuk program di atas yang akan dibangun, "perusahaan / karyawan.d" dan "perguruan tinggi / karyawan.d" juga harus ditentukan pada baris kompilasi.
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
$ dmd hello.d company/employee.d college/employee.d -ofhello.amx
$ ./hello.amx
Company Employee: emp1
College Employee: emp2
Template adalah dasar dari pemrograman generik, yang melibatkan penulisan kode dengan cara yang tidak bergantung pada jenis tertentu.
Templat adalah cetak biru atau rumus untuk membuat kelas atau fungsi generik.
Template adalah fitur yang memungkinkan untuk mendeskripsikan kode sebagai pola, agar kompilator menghasilkan kode program secara otomatis. Bagian dari kode sumber mungkin diserahkan kepada kompiler untuk diisi sampai bagian itu benar-benar digunakan dalam program. Kompilator mengisi bagian yang hilang.
Template Fungsi
Mendefinisikan sebuah fungsi sebagai templat meninggalkan satu atau lebih tipe yang digunakannya sebagai tidak ditentukan, untuk disimpulkan nanti oleh kompilator. Jenis yang dibiarkan tidak ditentukan ditentukan dalam daftar parameter template, yang berada di antara nama fungsi dan daftar parameter fungsi. Oleh karena itu, templat fungsi memiliki dua daftar parameter -
- daftar parameter template
- daftar parameter fungsi
import std.stdio;
void print(T)(T value) {
writefln("%s", value);
}
void main() {
print(42);
print(1.2);
print("test");
}
Jika kita mengkompilasi dan menjalankan kode di atas, ini akan menghasilkan hasil sebagai berikut -
42
1.2
test
Template Fungsi dengan Beberapa Jenis Parameter
Mungkin ada beberapa jenis parameter. Mereka diperlihatkan dalam contoh berikut.
import std.stdio;
void print(T1, T2)(T1 value1, T2 value2) {
writefln(" %s %s", value1, value2);
}
void main() {
print(42, "Test");
print(1.2, 33);
}
Jika kita mengkompilasi dan menjalankan kode di atas, ini akan menghasilkan hasil sebagai berikut -
42 Test
1.2 33
Template Kelas
Sama seperti kita dapat mendefinisikan template fungsi, kita juga dapat mendefinisikan template kelas. Contoh berikut mendefinisikan class Stack dan mengimplementasikan metode umum untuk mendorong dan memunculkan elemen dari stack.
import std.stdio;
import std.string;
class Stack(T) {
private:
T[] elements;
public:
void push(T element) {
elements ~= element;
}
void pop() {
--elements.length;
}
T top() const @property {
return elements[$ - 1];
}
size_t length() const @property {
return elements.length;
}
}
void main() {
auto stack = new Stack!string;
stack.push("Test1");
stack.push("Test2");
writeln(stack.top);
writeln(stack.length);
stack.pop;
writeln(stack.top);
writeln(stack.length);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Test2
2
Test1
1
Kami sering menggunakan variabel yang dapat berubah tetapi ada banyak kesempatan mutabilitas tidak diperlukan. Variabel yang tidak dapat diubah dapat digunakan dalam kasus seperti itu. Beberapa contoh diberikan di bawah ini di mana variabel yang tidak dapat diubah dapat digunakan.
Dalam kasus konstanta matematika seperti pi yang tidak pernah berubah.
Dalam kasus array di mana kita ingin mempertahankan nilai dan itu bukan persyaratan mutasi.
Keabadian memungkinkan untuk memahami apakah variabel tidak dapat diubah atau dapat berubah menjamin bahwa operasi tertentu tidak mengubah variabel tertentu. Ini juga mengurangi risiko jenis kesalahan program tertentu. Konsep kekekalan D diwakili oleh kata kunci konstan dan konstan. Meskipun kedua kata itu sendiri memiliki arti yang mirip, tanggung jawab mereka dalam program berbeda dan terkadang tidak sesuai.
Konsep kekekalan D diwakili oleh kata kunci konstan dan konstan. Meskipun kedua kata itu sendiri memiliki arti yang mirip, tanggung jawab mereka dalam program berbeda dan terkadang tidak sesuai.
Jenis Variabel Tidak Berubah di D
Ada tiga jenis variabel penentu yang tidak pernah bisa dimutasi.
- konstanta enum
- variabel yang tidak dapat diubah
- variabel const
enum Konstanta di D
Konstanta enum memungkinkan untuk menghubungkan nilai konstan dengan nama yang bermakna. Contoh sederhana ditunjukkan di bawah ini.
Contoh
import std.stdio;
enum Day{
Sunday = 1,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday
}
void main() {
Day day;
day = Day.Sunday;
if (day == Day.Sunday) {
writeln("The day is Sunday");
}
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
The day is Sunday
Variabel Tidak Berubah di D
Variabel yang tidak dapat diubah dapat ditentukan selama pelaksanaan program. Ini hanya mengarahkan kompiler yang setelah inisialisasi, itu menjadi tidak dapat diubah. Contoh sederhana ditunjukkan di bawah ini.
Contoh
import std.stdio;
import std.random;
void main() {
int min = 1;
int max = 10;
immutable number = uniform(min, max + 1);
// cannot modify immutable expression number
// number = 34;
typeof(number) value = 100;
writeln(typeof(number).stringof, number);
writeln(typeof(value).stringof, value);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
immutable(int)4
immutable(int)100
Anda dapat melihat pada contoh di atas bagaimana dimungkinkan untuk mentransfer tipe data ke variabel lain dan menggunakan stringof saat mencetak.
Variabel Const di D
Variabel Const tidak dapat dimodifikasi seperti tidak dapat diubah. Variabel yang tidak dapat diubah dapat diteruskan ke fungsi sebagai parameter yang tidak dapat diubah dan oleh karena itu disarankan untuk menggunakan yang tidak dapat diubah melalui const. Contoh yang sama yang digunakan sebelumnya dimodifikasi untuk const seperti yang ditunjukkan di bawah ini.
Contoh
import std.stdio;
import std.random;
void main() {
int min = 1;
int max = 10;
const number = uniform(min, max + 1);
// cannot modify const expression number|
// number = 34;
typeof(number) value = 100;
writeln(typeof(number).stringof, number);
writeln(typeof(value).stringof, value);
}
Jika kita mengkompilasi dan menjalankan kode di atas, ini akan menghasilkan hasil sebagai berikut -
const(int)7
const(int)100
Parameter yang Tidak Berubah di D
const menghapus informasi tentang apakah variabel asli dapat berubah atau tidak dapat diubah dan karenanya menggunakan tidak dapat diubah membuatnya meneruskan fungsi lain dengan tipe asli dipertahankan. Contoh sederhana ditunjukkan di bawah ini.
Contoh
import std.stdio;
void print(immutable int[] array) {
foreach (i, element; array) {
writefln("%s: %s", i, element);
}
}
void main() {
immutable int[] array = [ 1, 2 ];
print(array);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
0: 1
1: 2
File diwakili oleh File struct dari modul std.stdio. File mewakili urutan byte, tidak masalah apakah itu file teks atau file biner.
Bahasa pemrograman D menyediakan akses pada fungsi tingkat tinggi serta panggilan tingkat rendah (tingkat OS) untuk menangani file di perangkat penyimpanan Anda.
Membuka File di D
Aliran input dan output standar stdin dan stdout sudah terbuka ketika program mulai berjalan. Mereka siap digunakan. Di sisi lain, file harus dibuka terlebih dahulu dengan menentukan nama file dan hak akses yang diperlukan.
File file = File(filepath, "mode");
Sini, filename adalah string literal, yang Anda gunakan untuk memberi nama file dan akses mode dapat memiliki salah satu dari nilai berikut -
Sr.No. | Mode & Deskripsi |
---|---|
1 | r Membuka file teks yang ada untuk tujuan membaca. |
2 | w Membuka file teks untuk menulis, jika tidak ada maka file baru dibuat. Di sini program Anda akan mulai menulis konten dari awal file. |
3 | a Membuka file teks untuk menulis dalam mode appending, jika tidak ada maka file baru dibuat. Di sini program Anda akan mulai menambahkan konten di konten file yang sudah ada. |
4 | r+ Membuka file teks untuk membaca dan menulis keduanya. |
5 | w+ Membuka file teks untuk membaca dan menulis keduanya. Ini pertama-tama memotong file menjadi panjang nol jika ada jika tidak membuat file jika tidak ada. |
6 | a+ Membuka file teks untuk membaca dan menulis keduanya. Ini membuat file jika tidak ada. Pembacaan akan dimulai dari awal tetapi tulisan hanya dapat ditambahkan. |
Menutup File di D
Untuk menutup file, gunakan fungsi file.close () tempat file menyimpan referensi file. Prototipe dari fungsi ini adalah -
file.close();
File apa pun yang telah dibuka oleh program harus ditutup ketika program selesai menggunakan file itu. Dalam kebanyakan kasus, file tidak perlu ditutup secara eksplisit; mereka ditutup secara otomatis saat objek File dihentikan.
Menulis File di D
file.writeln digunakan untuk menulis ke file yang terbuka.
file.writeln("hello");
import std.stdio;
import std.file;
void main() {
File file = File("test.txt", "w");
file.writeln("hello");
file.close();
}
Ketika kode di atas dikompilasi dan dijalankan, itu membuat file baru test.txt di direktori yang telah dimulai (di direktori kerja program).
Membaca File di D
Metode berikut membaca satu baris dari file -
string s = file.readln();
Contoh lengkap membaca dan menulis ditunjukkan di bawah ini.
import std.stdio;
import std.file;
void main() {
File file = File("test.txt", "w");
file.writeln("hello");
file.close();
file = File("test.txt", "r");
string s = file.readln();
writeln(s);
file.close();
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
hello
Berikut adalah contoh lain untuk membaca file hingga akhir file.
import std.stdio;
import std.string;
void main() {
File file = File("test.txt", "w");
file.writeln("hello");
file.writeln("world");
file.close();
file = File("test.txt", "r");
while (!file.eof()) {
string line = chomp(file.readln());
writeln("line -", line);
}
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
line -hello
line -world
line -
Anda dapat melihat pada contoh di atas baris ketiga kosong karena writeln membawanya ke baris berikutnya setelah dijalankan.
Concurrency adalah membuat program berjalan di beberapa utas sekaligus. Contoh program konkuren adalah server web yang merespons banyak klien pada waktu yang sama. Konkurensi mudah dengan penyampaian pesan tetapi sangat sulit untuk ditulis jika didasarkan pada berbagi data.
Data yang dilewatkan di antara utas disebut pesan. Pesan dapat terdiri dari semua jenis dan sejumlah variabel. Setiap utas memiliki id, yang digunakan untuk menentukan penerima pesan. Setiap utas yang memulai utas lain disebut pemilik utas baru.
Memulai Thread di D
Fungsi spawn () mengambil pointer sebagai parameter dan memulai utas baru dari fungsi itu. Setiap operasi yang dilakukan oleh fungsi itu, termasuk fungsi lain yang mungkin dipanggil, akan dijalankan di thread baru. Pemilik dan pekerja sama-sama mulai mengeksekusi secara terpisah seolah-olah mereka adalah program independen.
Contoh
import std.stdio;
import std.stdio;
import std.concurrency;
import core.thread;
void worker(int a) {
foreach (i; 0 .. 4) {
Thread.sleep(1);
writeln("Worker Thread ",a + i);
}
}
void main() {
foreach (i; 1 .. 4) {
Thread.sleep(2);
writeln("Main Thread ",i);
spawn(≈worker, i * 5);
}
writeln("main is done.");
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
Main Thread 1
Worker Thread 5
Main Thread 2
Worker Thread 6
Worker Thread 10
Main Thread 3
main is done.
Worker Thread 7
Worker Thread 11
Worker Thread 15
Worker Thread 8
Worker Thread 12
Worker Thread 16
Worker Thread 13
Worker Thread 17
Worker Thread 18
Pengidentifikasi Benang di D
The thisTid variabel yang tersedia secara global pada tingkat modul selalu id dari thread saat ini. Anda juga dapat menerima threadId saat pemijahan dipanggil. Contohnya ditunjukkan di bawah ini.
Contoh
import std.stdio;
import std.concurrency;
void printTid(string tag) {
writefln("%s: %s, address: %s", tag, thisTid, &thisTid);
}
void worker() {
printTid("Worker");
}
void main() {
Tid myWorker = spawn(&worker);
printTid("Owner ");
writeln(myWorker);
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
Owner : Tid(std.concurrency.MessageBox), address: 10C71A59C
Worker: Tid(std.concurrency.MessageBox), address: 10C71A59C
Tid(std.concurrency.MessageBox)
Message Passing in D
Fungsi send () mengirim pesan dan fungsi acceptOnly () menunggu pesan dari jenis tertentu. Ada fungsi lain bernama prioritySend (), accept (), dan acceptTimeout (), yang akan dijelaskan nanti.
Pemilik dalam program berikut mengirimkan pekerjanya pesan jenis int dan menunggu pesan dari pekerja berjenis double. Utas terus mengirim pesan bolak-balik sampai pemilik mengirim int negatif. Contohnya ditunjukkan di bawah ini.
Contoh
import std.stdio;
import std.concurrency;
import core.thread;
import std.conv;
void workerFunc(Tid tid) {
int value = 0;
while (value >= 0) {
value = receiveOnly!int();
auto result = to!double(value) * 5; tid.send(result);
}
}
void main() {
Tid worker = spawn(&workerFunc,thisTid);
foreach (value; 5 .. 10) {
worker.send(value);
auto result = receiveOnly!double();
writefln("sent: %s, received: %s", value, result);
}
worker.send(-1);
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
sent: 5, received: 25
sent: 6, received: 30
sent: 7, received: 35
sent: 8, received: 40
sent: 9, received: 45
Message Passing dengan Wait in D
Contoh sederhana dengan pesan yang lewat dengan menunggu ditunjukkan di bawah ini.
import std.stdio;
import std.concurrency;
import core.thread;
import std.conv;
void workerFunc(Tid tid) {
Thread.sleep(dur!("msecs")( 500 ),);
tid.send("hello");
}
void main() {
spawn(&workerFunc,thisTid);
writeln("Waiting for a message");
bool received = false;
while (!received) {
received = receiveTimeout(dur!("msecs")( 100 ), (string message) {
writeln("received: ", message);
});
if (!received) {
writeln("... no message yet");
}
}
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
Waiting for a message
... no message yet
... no message yet
... no message yet
... no message yet
received: hello
Pengecualian adalah masalah yang muncul selama menjalankan program. Pengecualian AD adalah respons terhadap keadaan luar biasa yang muncul saat program berjalan, seperti upaya untuk membagi dengan nol.
Pengecualian memberikan cara untuk mentransfer kontrol dari satu bagian program ke program lainnya. Penanganan pengecualian D dibangun di atas tiga kata kuncitry, catch, dan throw.
throw- Sebuah program mengeluarkan pengecualian ketika masalah muncul. Ini dilakukan dengan menggunakanthrow kata kunci.
catch- Program menangkap pengecualian dengan penangan pengecualian di tempat dalam program di mana Anda ingin menangani masalah. Itucatch kata kunci menunjukkan penangkapan pengecualian.
try - A tryblok mengidentifikasi blok kode yang pengecualian tertentu diaktifkan. Ini diikuti oleh satu atau lebih blok tangkapan.
Dengan asumsi blok akan memunculkan pengecualian, metode menangkap pengecualian menggunakan kombinasi dari try dan catchkata kunci. Sebuah blok coba / tangkap ditempatkan di sekitar kode yang mungkin menghasilkan pengecualian. Kode dalam blok coba / tangkap disebut sebagai kode yang dilindungi, dan sintaks untuk menggunakan coba / tangkap terlihat seperti berikut -
try {
// protected code
}
catch( ExceptionName e1 ) {
// catch block
}
catch( ExceptionName e2 ) {
// catch block
}
catch( ExceptionName eN ) {
// catch block
}
Anda dapat membuat daftar beberapa catch pernyataan untuk menangkap jenis pengecualian yang berbeda jika Anda try blok menimbulkan lebih dari satu pengecualian dalam situasi yang berbeda.
Melempar Pengecualian di D
Pengecualian dapat dilakukan di mana saja dalam blok kode menggunakan throwpernyataan. Operand pernyataan lemparan menentukan tipe untuk pengecualian dan bisa berupa ekspresi apa pun dan tipe hasil ekspresi menentukan jenis pengecualian yang dilemparkan.
Contoh berikut memunculkan pengecualian saat membagi dengan kondisi nol terjadi -
Contoh
double division(int a, int b) {
if( b == 0 ) {
throw new Exception("Division by zero condition!");
}
return (a/b);
}
Menangkap Pengecualian di D
Itu catch blokir mengikuti tryblok menangkap pengecualian apa pun. Anda dapat menentukan jenis pengecualian apa yang ingin Anda tangkap dan ini ditentukan oleh deklarasi pengecualian yang muncul dalam tanda kurung setelah kata kunci catch.
try {
// protected code
}
catch( ExceptionName e ) {
// code to handle ExceptionName exception
}
Kode di atas menangkap pengecualian ExceptionNameTipe. Jika Anda ingin menentukan bahwa blok catch harus menangani semua jenis pengecualian yang dilemparkan dalam blok percobaan, Anda harus meletakkan elipsis, ..., di antara tanda kurung yang melampirkan deklarasi pengecualian sebagai berikut -
try {
// protected code
}
catch(...) {
// code to handle any exception
}
Contoh berikut menampilkan pembagian dengan pengecualian nol. Itu tertangkap di blok tangkapan.
import std.stdio;
import std.string;
string division(int a, int b) {
string result = "";
try {
if( b == 0 ) {
throw new Exception("Cannot divide by zero!");
} else {
result = format("%s",a/b);
}
} catch (Exception e) {
result = e.msg;
}
return result;
}
void main () {
int x = 50;
int y = 0;
writeln(division(x, y));
y = 10;
writeln(division(x, y));
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
Cannot divide by zero!
5
Pemrograman kontrak dalam pemrograman D difokuskan pada penyediaan cara penanganan kesalahan yang sederhana dan dapat dimengerti. Pemrograman kontrak di D diimplementasikan oleh tiga jenis blok kode -
- blok tubuh
- di blok
- keluar blok
Body Block di D
Blok tubuh berisi kode fungsionalitas eksekusi yang sebenarnya. Blok masuk dan keluar bersifat opsional sedangkan blok badan bersifat wajib. Sintaks sederhana ditampilkan di bawah ini.
return_type function_name(function_params)
in {
// in block
}
out (result) {
// in block
}
body {
// actual function block
}
Di Blokir untuk Kondisi Awal di D
Dalam blok adalah untuk kondisi awal sederhana yang memverifikasi apakah parameter masukan dapat diterima dan dalam jangkauan yang dapat ditangani oleh kode. Manfaat dari blok in adalah bahwa semua kondisi entri dapat disimpan bersama dan terpisah dari badan fungsi yang sebenarnya. Prasyarat sederhana untuk memvalidasi kata sandi untuk panjang minimumnya ditunjukkan di bawah ini.
import std.stdio;
import std.string;
bool isValid(string password)
in {
assert(password.length>=5);
}
body {
// other conditions
return true;
}
void main() {
writeln(isValid("password"));
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
true
Blok Keluar untuk Kondisi Pos di D
Blok keluar menangani nilai yang dikembalikan dari fungsi. Ini memvalidasi nilai kembali dalam kisaran yang diharapkan. Contoh sederhana yang berisi baik masuk dan keluar ditunjukkan di bawah ini yang mengubah bulan, tahun menjadi bentuk usia desimal gabungan.
import std.stdio;
import std.string;
double getAge(double months,double years)
in {
assert(months >= 0);
assert(months <= 12);
}
out (result) {
assert(result>=years);
}
body {
return years + months/12;
}
void main () {
writeln(getAge(10,12));
}
Ketika kode di atas dikompilasi dan dijalankan, ia membaca file yang dibuat di bagian sebelumnya dan menghasilkan hasil sebagai berikut -
12.8333
Kompilasi bersyarat adalah proses memilih kode mana yang akan dikompilasi dan kode mana yang tidak akan dikompilasi mirip dengan #if / #else / #endif di C dan C ++. Pernyataan apa pun yang tidak dikompilasi masih harus benar secara sintaksis.
Kompilasi bersyarat melibatkan pemeriksaan kondisi yang dapat dievaluasi pada waktu kompilasi. Pernyataan bersyarat waktu proses seperti if, for, while bukan fitur kompilasi bersyarat. Fitur D berikut dimaksudkan untuk kompilasi bersyarat -
- debug
- version
- statis jika
Pernyataan Debug di D
The men-debug berguna selama pengembangan program. Ekspresi dan pernyataan yang ditandai sebagai debug dikompilasi ke dalam program hanya jika sakelar kompilator -debug diaktifkan.
debug a_conditionally_compiled_expression;
debug {
// ... conditionally compiled code ...
} else {
// ... code that is compiled otherwise ...
}
Klausa else bersifat opsional. Baik ekspresi tunggal dan blok kode di atas dikompilasi hanya jika sakelar kompilator -debug diaktifkan.
Alih-alih dihapus seluruhnya, garis-garis tersebut dapat ditandai sebagai debug.
debug writefln("%s debug only statement", value);
Baris seperti itu disertakan dalam program hanya jika sakelar kompilator -debug diaktifkan.
dmd test.d -oftest -w -debug
Pernyataan Debug (tag) di D
Pernyataan debug dapat diberi nama (tag) untuk dimasukkan dalam program secara selektif.
debug(mytag) writefln("%s not found", value);
Baris seperti itu disertakan dalam program hanya jika sakelar kompilator -debug diaktifkan.
dmd test.d -oftest -w -debug = mytag
Blok debug dapat memiliki tag juga.
debug(mytag) {
//
}
Dimungkinkan untuk mengaktifkan lebih dari satu tag debug pada satu waktu.
dmd test.d -oftest -w -debug = mytag1 -debug = mytag2
Pernyataan Debug (level) di D
Terkadang lebih berguna untuk mengaitkan pernyataan debug dengan tingkat numerik. Meningkatkan level dapat memberikan informasi yang lebih detail.
import std.stdio;
void myFunction() {
debug(1) writeln("debug1");
debug(2) writeln("debug2");
}
void main() {
myFunction();
}
Ekspresi debug dan blok yang lebih rendah dari atau sama dengan level yang ditentukan akan dikompilasi.
$ dmd test.d -oftest -w -debug = 1 $ ./test
debug1
Pernyataan Versi (tag) dan Versi (level) di D
Versi mirip dengan debug dan digunakan dengan cara yang sama. Klausa else bersifat opsional. Meskipun versi berfungsi pada dasarnya sama dengan debug, memiliki kata kunci terpisah membantu membedakan penggunaan yang tidak terkait. Seperti debug, lebih dari satu versi dapat diaktifkan.
import std.stdio;
void myFunction() {
version(1) writeln("version1");
version(2) writeln("version2");
}
void main() {
myFunction();
}
Ekspresi debug dan blok yang lebih rendah dari atau sama dengan level yang ditentukan akan dikompilasi.
$ dmd test.d -oftest -w -version = 1 $ ./test
version1
Statis jika
Statis if adalah waktu kompilasi yang setara dengan pernyataan if. Sama seperti pernyataan if, statik if mengambil ekspresi logis dan mengevaluasinya. Berbeda dengan pernyataan if, statik if bukan tentang aliran eksekusi; sebaliknya, ini menentukan apakah sepotong kode harus disertakan dalam program atau tidak.
Ekspresi if tidak terkait dengan operator is yang telah kita lihat sebelumnya, baik secara sintaksis maupun semantik. Itu dievaluasi pada waktu kompilasi. Ini menghasilkan nilai int, baik 0 atau 1; bergantung pada ekspresi yang ditentukan dalam tanda kurung. Meskipun ekspresi yang dibutuhkan bukanlah ekspresi logis, ekspresi is itu sendiri digunakan sebagai ekspresi logis waktu kompilasi. Ini sangat berguna terutama dalam batasan kondisi dan template statis.
import std.stdio;
enum Days {
sun,
mon,
tue,
wed,
thu,
fri,
sat
};
void myFunction(T)(T mytemplate) {
static if (is (T == class)) {
writeln("This is a class type");
} else static if (is (T == enum)) {
writeln("This is an enum type");
}
}
void main() {
Days day;
myFunction(day);
}
Saat kita kompilasi dan jalankan kita akan mendapatkan beberapa output sebagai berikut.
This is an enum type
Kelas adalah fitur utama dari pemrograman D yang mendukung pemrograman berorientasi objek dan sering disebut tipe yang ditentukan pengguna.
Kelas digunakan untuk menentukan bentuk objek dan menggabungkan representasi data dan metode untuk memanipulasi data ke dalam satu paket yang rapi. Data dan fungsi di dalam kelas disebut anggota kelas.
Definisi Kelas D
Saat Anda menentukan kelas, Anda menentukan cetak biru untuk tipe data. Ini tidak benar-benar mendefinisikan data apa pun, tetapi mendefinisikan apa arti nama kelas, yaitu, apa objek kelas akan terdiri dan operasi apa yang dapat dilakukan pada objek semacam itu.
Definisi kelas dimulai dengan kata kunci classdiikuti dengan nama kelas; dan badan kelas, diapit oleh sepasang kurung kurawal. Definisi kelas harus diikuti oleh titik koma atau daftar deklarasi. Misalnya, kami mendefinisikan tipe data Kotak menggunakan kata kunciclass sebagai berikut -
class Box {
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
}
Kata kunci publicmenentukan atribut akses dari anggota kelas yang mengikutinya. Anggota publik dapat diakses dari luar kelas di mana saja dalam lingkup objek kelas. Anda juga dapat menentukan anggota kelas sebagaiprivate atau protected yang akan kita bahas di sub-bagian.
Mendefinisikan Objek D.
Sebuah kelas menyediakan cetak biru untuk objek, jadi pada dasarnya sebuah objek dibuat dari sebuah kelas. Anda mendeklarasikan objek kelas dengan jenis deklarasi yang persis sama dengan yang Anda deklarasikan variabel tipe dasar. Pernyataan berikut mendeklarasikan dua objek kelas Box -
Box Box1; // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
Kedua objek Box1 dan Box2 memiliki salinan anggota datanya sendiri.
Mengakses Anggota Data
Anggota data publik dari objek kelas dapat diakses menggunakan operator akses anggota langsung (.). Mari kita coba contoh berikut untuk memperjelas semuanya -
import std.stdio;
class Box {
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
}
void main() {
Box box1 = new Box(); // Declare Box1 of type Box
Box box2 = new Box(); // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
box1.height = 5.0;
box1.length = 6.0;
box1.breadth = 7.0;
// box 2 specification
box2.height = 10.0;
box2.length = 12.0;
box2.breadth = 13.0;
// volume of box 1
volume = box1.height * box1.length * box1.breadth;
writeln("Volume of Box1 : ",volume);
// volume of box 2
volume = box2.height * box2.length * box2.breadth;
writeln("Volume of Box2 : ", volume);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Volume of Box1 : 210
Volume of Box2 : 1560
Penting untuk dicatat bahwa anggota pribadi dan dilindungi tidak dapat diakses secara langsung menggunakan operator akses anggota langsung (.). Sebentar lagi Anda akan mempelajari bagaimana anggota pribadi dan dilindungi dapat diakses.
Kelas dan Objek di D
Sejauh ini, Anda memiliki gagasan yang sangat mendasar tentang Kelas dan Objek D. Ada konsep menarik lebih lanjut terkait dengan Kelas dan Objek D yang akan kita bahas dalam berbagai sub-bagian di bawah ini -
Sr.No. | Konsep & Deskripsi |
---|---|
1 | Fungsi anggota kelas Fungsi anggota kelas adalah fungsi yang memiliki definisi atau prototipe-nya di dalam definisi kelas seperti variabel lainnya. |
2 | Pengubah akses kelas Seorang anggota kelas dapat didefinisikan sebagai publik, pribadi atau dilindungi. Secara default, anggota akan dianggap sebagai pribadi. |
3 | Pembuat & perusak Konstruktor kelas adalah fungsi khusus dalam kelas yang dipanggil ketika objek baru kelas dibuat. Penghancur juga merupakan fungsi khusus yang dipanggil ketika objek yang dibuat dihapus. |
4 | Penunjuk ini di D Setiap objek memiliki penunjuk khusus this yang menunjuk ke objek itu sendiri. |
5 | Pointer ke kelas D. Penunjuk ke kelas dilakukan dengan cara yang persis sama dengan penunjuk ke struktur. Sebenarnya kelas hanyalah sebuah struktur dengan fungsi di dalamnya. |
6 | Anggota statis kelas Baik anggota data dan anggota fungsi kelas dapat dideklarasikan sebagai statis. |
Salah satu konsep terpenting dalam pemrograman berorientasi objek adalah pewarisan. Inheritance memungkinkan untuk menentukan kelas dalam istilah kelas lain, yang membuatnya lebih mudah untuk membuat dan memelihara aplikasi. Ini juga memberikan kesempatan untuk menggunakan kembali fungsionalitas kode dan waktu implementasi yang cepat.
Saat membuat kelas, daripada menulis anggota data dan fungsi anggota yang benar-benar baru, pemrogram dapat menetapkan bahwa kelas baru harus mewarisi anggota kelas yang sudah ada. Kelas yang ada ini disebutbase kelas, dan kelas baru disebut sebagai derived kelas.
Gagasan tentang warisan mengimplementasikan adalah sebuah hubungan. Misalnya mamalia IS-A binatang, anjing IS-A mamalia maka anjing IS-A binatang begitu juga dan seterusnya.
Kelas Dasar dan Kelas Turunan di D
Sebuah kelas dapat diturunkan dari lebih dari satu kelas, yang berarti ia dapat mewarisi data dan fungsi dari beberapa kelas dasar. Untuk mendefinisikan kelas turunan, kami menggunakan daftar turunan kelas untuk menentukan kelas dasar. Sebuah daftar derivasi kelas menamai satu atau lebih kelas dasar dan memiliki bentuk -
class derived-class: base-class
Pertimbangkan kelas dasar Shape dan kelas turunannya Rectangle sebagai berikut -
import std.stdio;
// Base class
class Shape {
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}
protected:
int width;
int height;
}
// Derived class
class Rectangle: Shape {
public:
int getArea() {
return (width * height);
}
}
void main() {
Rectangle Rect = new Rectangle();
Rect.setWidth(5);
Rect.setHeight(7);
// Print the area of the object.
writeln("Total area: ", Rect.getArea());
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Total area: 35
Kontrol Akses dan Warisan
Kelas turunan dapat mengakses semua anggota non-privat dari kelas dasarnya. Jadi anggota kelas dasar yang seharusnya tidak dapat diakses oleh fungsi anggota dari kelas turunan harus dideklarasikan sebagai pribadi di kelas dasar.
Kelas turunan mewarisi semua metode kelas dasar dengan pengecualian berikut -
- Konstruktor, destruktor, dan copy konstruktor kelas dasar.
- Operator kelas dasar yang kelebihan beban.
Warisan Multi Level
Pewarisan dapat terdiri dari beberapa tingkatan dan itu ditunjukkan pada contoh berikut.
import std.stdio;
// Base class
class Shape {
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}
protected:
int width;
int height;
}
// Derived class
class Rectangle: Shape {
public:
int getArea() {
return (width * height);
}
}
class Square: Rectangle {
this(int side) {
this.setWidth(side);
this.setHeight(side);
}
}
void main() {
Square square = new Square(13);
// Print the area of the object.
writeln("Total area: ", square.getArea());
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Total area: 169
D memungkinkan Anda untuk menentukan lebih dari satu definisi untuk a function nama atau operator dalam ruang lingkup yang sama, yang disebut function overloading dan operator overloading masing-masing.
Deklarasi yang kelebihan beban adalah deklarasi yang dideklarasikan dengan nama yang sama dengan deklarasi sebelumnya dalam lingkup yang sama, kecuali kedua deklarasi tersebut memiliki argumen yang berbeda dan definisi (implementasi) yang jelas berbeda.
Ketika Anda menelepon yang kelebihan beban function atau operator, kompilator menentukan definisi yang paling tepat untuk digunakan dengan membandingkan tipe argumen yang Anda gunakan untuk memanggil fungsi atau operator dengan tipe parameter yang ditentukan dalam definisi. Proses memilih fungsi atau operator kelebihan beban yang paling tepat disebutoverload resolution..
Fungsi Overloading
Anda dapat memiliki beberapa definisi untuk nama fungsi yang sama dalam lingkup yang sama. Definisi fungsi harus berbeda satu sama lain dengan jenis dan / atau jumlah argumen dalam daftar argumen. Anda tidak dapat membebani deklarasi fungsi yang hanya berbeda menurut jenis kembaliannya.
Contoh
Contoh berikut menggunakan fungsi yang sama print() untuk mencetak tipe data yang berbeda -
import std.stdio;
import std.string;
class printData {
public:
void print(int i) {
writeln("Printing int: ",i);
}
void print(double f) {
writeln("Printing float: ",f );
}
void print(string s) {
writeln("Printing string: ",s);
}
};
void main() {
printData pd = new printData();
// Call print to print integer
pd.print(5);
// Call print to print float
pd.print(500.263);
// Call print to print character
pd.print("Hello D");
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Printing int: 5
Printing float: 500.263
Printing string: Hello D
Operator Berlebihan
Anda dapat mendefinisikan ulang atau membebani sebagian besar operator bawaan yang tersedia di D. Dengan demikian, pemrogram juga dapat menggunakan operator dengan tipe yang ditentukan pengguna.
Operator dapat kelebihan beban menggunakan string op diikuti oleh Add, Sub, dan seterusnya berdasarkan operator yang di-overload. Kami dapat membebani operator + untuk menambahkan dua kotak seperti yang ditunjukkan di bawah ini.
Box opAdd(Box b) {
Box box = new Box();
box.length = this.length + b.length;
box.breadth = this.breadth + b.breadth;
box.height = this.height + b.height;
return box;
}
Contoh berikut menunjukkan konsep operator overloading menggunakan fungsi anggota. Di sini sebuah objek dikirimkan sebagai argumen yang propertinya diakses menggunakan objek ini. Objek yang memanggil operator ini dapat diakses menggunakanthis operator seperti yang dijelaskan di bawah ini -
import std.stdio;
class Box {
public:
double getVolume() {
return length * breadth * height;
}
void setLength( double len ) {
length = len;
}
void setBreadth( double bre ) {
breadth = bre;
}
void setHeight( double hei ) {
height = hei;
}
Box opAdd(Box b) {
Box box = new Box();
box.length = this.length + b.length;
box.breadth = this.breadth + b.breadth;
box.height = this.height + b.height;
return box;
}
private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
// Main function for the program
void main( ) {
Box box1 = new Box(); // Declare box1 of type Box
Box box2 = new Box(); // Declare box2 of type Box
Box box3 = new Box(); // Declare box3 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
box1.setLength(6.0);
box1.setBreadth(7.0);
box1.setHeight(5.0);
// box 2 specification
box2.setLength(12.0);
box2.setBreadth(13.0);
box2.setHeight(10.0);
// volume of box 1
volume = box1.getVolume();
writeln("Volume of Box1 : ", volume);
// volume of box 2
volume = box2.getVolume();
writeln("Volume of Box2 : ", volume);
// Add two object as follows:
box3 = box1 + box2;
// volume of box 3
volume = box3.getVolume();
writeln("Volume of Box3 : ", volume);
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400
Jenis Kelebihan Operator
Pada dasarnya, ada tiga jenis kelebihan beban operator seperti yang tercantum di bawah ini.
Sr.No. | Jenis Overloading |
---|---|
1 | Overloading Operator Unary |
2 | Pembebanan Operator Biner |
3 | Perbandingan Operator Overloading |
Semua program D terdiri dari dua elemen dasar berikut -
Program statements (code) - Ini adalah bagian dari program yang melakukan tindakan dan mereka disebut fungsi.
Program data - Ini adalah informasi program yang dipengaruhi oleh fungsi program.
Enkapsulasi adalah konsep Pemrograman Berorientasi Objek yang mengikat data dan fungsi yang memanipulasi data bersama-sama, dan yang menjaga keamanan dari gangguan luar dan penyalahgunaan. Enkapsulasi data mengarah pada konsep OOP yang pentingdata hiding.
Data encapsulation adalah mekanisme bundling data, dan fungsi yang menggunakannya dan data abstraction adalah mekanisme yang hanya memperlihatkan antarmuka dan menyembunyikan detail implementasi dari pengguna.
D mendukung properti enkapsulasi dan menyembunyikan data melalui pembuatan tipe yang ditentukan pengguna, yang disebut classes. Kami telah mempelajari bahwa kelas dapat berisiprivate, dilindungi, dan publicanggota. Secara default, semua item yang ditentukan dalam kelas bersifat pribadi. Misalnya -
class Box {
public:
double getVolume() {
return length * breadth * height;
}
private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
Variabel panjang, lebar, dan tinggi adalah private. Ini berarti bahwa mereka hanya dapat diakses oleh anggota kelas Box lainnya, dan bukan oleh bagian lain dari program Anda. Ini adalah salah satu cara enkapsulasi dicapai.
Untuk membuat bagian dari kelas public (yaitu, dapat diakses oleh bagian lain dari program Anda), Anda harus mendeklarasikannya setelah publickata kunci. Semua variabel atau fungsi yang ditentukan setelah penentu publik dapat diakses oleh semua fungsi lain di program Anda.
Menjadikan satu kelas sebagai teman yang lain akan mengekspos detail implementasi dan mengurangi enkapsulasi. Sangat ideal untuk menyembunyikan sebanyak mungkin detail dari setiap kelas dari semua kelas lain.
Enkapsulasi Data di D
Setiap program D di mana Anda mengimplementasikan kelas dengan anggota publik dan pribadi adalah contoh enkapsulasi data dan abstraksi data. Perhatikan contoh berikut -
Contoh
import std.stdio;
class Adder {
public:
// constructor
this(int i = 0) {
total = i;
}
// interface to outside world
void addNum(int number) {
total += number;
}
// interface to outside world
int getTotal() {
return total;
};
private:
// hidden data from outside world
int total;
}
void main( ) {
Adder a = new Adder();
a.addNum(10);
a.addNum(20);
a.addNum(30);
writeln("Total ",a.getTotal());
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Total 60
Kelas di atas menambahkan angka bersama-sama, dan mengembalikan jumlahnya. Anggota publikaddNum dan getTotaladalah antarmuka ke dunia luar dan pengguna perlu mengetahuinya untuk menggunakan kelas. Total anggota pribadi adalah sesuatu yang disembunyikan dari dunia luar, tetapi dibutuhkan agar kelas dapat beroperasi dengan baik.
Strategi Perancangan Kelas di D
Sebagian besar dari kita telah belajar melalui pengalaman pahit untuk menjadikan anggota kelas pribadi secara default kecuali kita benar-benar perlu mengekspos mereka. Itu bagusencapsulation.
Kebijakan ini paling sering diterapkan ke anggota data, tetapi berlaku sama untuk semua anggota, termasuk fungsi virtual.
Antarmuka adalah cara memaksa kelas yang mewarisinya harus mengimplementasikan fungsi atau variabel tertentu. Fungsi tidak boleh diterapkan di antarmuka karena selalu diterapkan di kelas yang diwarisi dari antarmuka.
Antarmuka dibuat menggunakan kata kunci antarmuka alih-alih kata kunci kelas meskipun keduanya serupa dalam banyak hal. Jika Anda ingin mewarisi dari sebuah antarmuka dan kelas tersebut sudah mewarisi dari kelas lain, maka Anda perlu memisahkan nama kelas dan nama antarmuka dengan koma.
Mari kita lihat contoh sederhana yang menjelaskan penggunaan antarmuka.
Contoh
import std.stdio;
// Base class
interface Shape {
public:
void setWidth(int w);
void setHeight(int h);
}
// Derived class
class Rectangle: Shape {
int width;
int height;
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}
int getArea() {
return (width * height);
}
}
void main() {
Rectangle Rect = new Rectangle();
Rect.setWidth(5);
Rect.setHeight(7);
// Print the area of the object.
writeln("Total area: ", Rect.getArea());
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Total area: 35
Antarmuka dengan Fungsi Final dan Statis di D
Antarmuka dapat memiliki metode final dan statis yang definisi harus disertakan dalam antarmuka itu sendiri. Fungsi ini tidak dapat diganti dengan kelas turunan. Contoh sederhana ditunjukkan di bawah ini.
Contoh
import std.stdio;
// Base class
interface Shape {
public:
void setWidth(int w);
void setHeight(int h);
static void myfunction1() {
writeln("This is a static method");
}
final void myfunction2() {
writeln("This is a final method");
}
}
// Derived class
class Rectangle: Shape {
int width;
int height;
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}
int getArea() {
return (width * height);
}
}
void main() {
Rectangle rect = new Rectangle();
rect.setWidth(5);
rect.setHeight(7);
// Print the area of the object.
writeln("Total area: ", rect.getArea());
rect.myfunction1();
rect.myfunction2();
}
Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -
Total area: 35
This is a static method
This is a final method
Abstraksi mengacu pada kemampuan untuk membuat abstrak kelas dalam OOP. Kelas abstrak adalah salah satu yang tidak bisa dipakai. Semua fungsionalitas kelas lainnya masih ada, dan bidang, metode, dan konstruktornya semua diakses dengan cara yang sama. Anda tidak bisa membuat instance dari kelas abstrak.
Jika sebuah kelas abstrak dan tidak bisa dibuat instance-nya, kelas tersebut tidak memiliki banyak kegunaan kecuali kelas tersebut adalah subkelas. Ini biasanya bagaimana kelas abstrak muncul selama fase desain. Kelas induk berisi fungsionalitas umum dari kumpulan kelas anak, tetapi kelas induk itu sendiri terlalu abstrak untuk digunakan sendiri.
Menggunakan Kelas Abstrak di D
Menggunakan abstractkata kunci untuk mendeklarasikan abstrak kelas. Kata kunci muncul di deklarasi kelas di suatu tempat sebelum kata kunci kelas. Berikut ini adalah contoh bagaimana kelas abstrak dapat diwariskan dan digunakan.
Contoh
import std.stdio;
import std.string;
import std.datetime;
abstract class Person {
int birthYear, birthDay, birthMonth;
string name;
int getAge() {
SysTime sysTime = Clock.currTime();
return sysTime.year - birthYear;
}
}
class Employee : Person {
int empID;
}
void main() {
Employee emp = new Employee();
emp.empID = 101;
emp.birthYear = 1980;
emp.birthDay = 10;
emp.birthMonth = 10;
emp.name = "Emp1";
writeln(emp.name);
writeln(emp.getAge);
}
Ketika kita mengkompilasi dan menjalankan program di atas, kita akan mendapatkan keluaran sebagai berikut.
Emp1
37
Fungsi Abstrak
Mirip dengan fungsi, kelas juga bisa abstrak. Implementasi fungsi tersebut tidak diberikan di kelasnya tetapi harus disediakan di kelas yang mewarisi kelas dengan fungsi abstrak. Contoh di atas diperbarui dengan fungsi abstrak.
Contoh
import std.stdio;
import std.string;
import std.datetime;
abstract class Person {
int birthYear, birthDay, birthMonth;
string name;
int getAge() {
SysTime sysTime = Clock.currTime();
return sysTime.year - birthYear;
}
abstract void print();
}
class Employee : Person {
int empID;
override void print() {
writeln("The employee details are as follows:");
writeln("Emp ID: ", this.empID);
writeln("Emp Name: ", this.name);
writeln("Age: ",this.getAge);
}
}
void main() {
Employee emp = new Employee();
emp.empID = 101;
emp.birthYear = 1980;
emp.birthDay = 10;
emp.birthMonth = 10;
emp.name = "Emp1";
emp.print();
}
Ketika kita mengkompilasi dan menjalankan program di atas, kita akan mendapatkan keluaran sebagai berikut.
The employee details are as follows:
Emp ID: 101
Emp Name: Emp1
Age: 37