Cara Menukar Jenis Data dalam C++
Dalam C++, terdapat dua cara untuk menukar jenis data:
Penukaran Jenis Tersirat
Mengikut peraturan yang telah ditetapkan oleh pengkompil kod C++, penukaran jenis tersirat ialah penukaran jenis yang dijalankan oleh pengkompil secara automatik tanpa memerlukan sebarang pencetus luaran daripada pengguna. Jenis penukaran ini biasanya berlaku dalam program apabila terdapat lebih daripada satu jenis data, dan jenis data ungkapan tidak sepadan dengan jenis data pembolehubah yang terlibat dalam ungkapan ini.
Untuk mengelakkan kehilangan data semasa penukaran, pengkompil secara lalai menukar jenis data tepat rendah dengan jenis data ketepatan yang lebih tinggi. Sebagai contoh, ia akan menukar integer kepada apungan dan bukannya menukar apungan kepada integer untuk mengelakkan kehilangan data. Ini dipanggil promosi. Berikut ialah rajah keutamaan untuk jenis data yang berbeza.
Pesanan untuk Penukaran Jenis
Urutan yang betul untuk penukaran jenis diberikan sebagai:
bool -- > char -- > int pendek -- > int -- > int tidak ditandatangani -- > panjang -- > panjang tidak ditandatangani -- > lama lama -- > terapung -- > berganda -- > berganda panjang
Pembolehubah jenis ketepatan rendah ditukar kepada jenis data ketepatan tinggi untuk mengelakkan kehilangan data.
Contoh 1
Dalam contoh ini, penambahan dilakukan pada pembolehubah jenis data yang berbeza menggunakan penukaran jenis tersirat.
#include
menggunakan ruang nama std ;
int utama ( ) {
int nombor = 100 ;
char watak = 'C' ;
cout << '100 + 'C' = ' << nombor + watak << endl ;
terapung val = nombor + 'c' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int adalah = 7890 ;
panjang tidak = adalah ;
cout << 'var_int = ' << tidak ;
kembali 0 ;
}
Di sini integer dan aksara daripada jadual ASCII, dan nombor apungan dan aksara 'c' ditambah. Integer disimpan dalam segmen ketiga sebagai jenis data yang panjang dan jenis data diubah oleh pengkompil itu sendiri berdasarkan peraturan yang telah ditetapkan.
Jumlah 100 dan 'C' mengembalikan 167 kerana 'C' bersamaan dengan 67 dalam nombor dan 100+'c' mengembalikan 199 kerana huruf kecil 'c' bersamaan dengan 99. Pembolehubah int disimpan dalam jenis data yang panjang.
Contoh 2
Dalam contoh ini, aksara D ditukar menjadi apungan untuk melaksanakan operasi bahagi.
#includemenggunakan ruang nama std ;
int utama ( ) {
char x = 'D' ;
terapung float_var ;
float_var = terapung ( x ) / 'c' ;
// Menukar int kepada apungan secara eksplisit.
cout << 'Nilai float_var ialah: ' << float_var << endl ;
kembali 0 ;
}
Nilai input adalah dalam bentuk aksara D yang disimpan dalam jenis data apungan dan dibahagikan lagi dengan aksara C. Aksara ini ditukar kepada nilai berangka dan operasi bahagi dilakukan pada mereka, mengembalikan nilai dalam apungan.
Penukaran Jenis Eksplisit
Pengguna mesti mengubah jenis data secara manual dengan penukaran jenis eksplisit C++, selalunya dikenali sebagai penghantaran jenis. Jenis tuangan ini dilakukan untuk mengelakkan penukaran jenis tersirat. Terdapat dua kaedah untuk menjalankan Casting Jenis Eksplisit dalam C++:
- Penukaran menggunakan Operator Tugasan
- Penukaran menggunakan Operator Cast
Taipkan Penukaran menggunakan Operator Tugasan dalam C++
Penukaran jenis menggunakan Operator Tugasan dilakukan secara paksa, iaitu satu jenis data ditukar kepada yang lain secara manual. Ini dicapai dengan menggunakan operator penugasan “=”, yang memberikan nilai operan sebelah kanan kepada pembolehubah di sebelah kirinya.
Contoh
Program ini mengira luas bulatan menggunakan tuangan jenis.
#include
menggunakan ruang nama std ;
int utama ( )
{
int jejari ;
cout <> jejari ;
terapung kawasan = M_PI * jejari * jejari ;
cout << 'Kawasan bulatan dengan jejari' << jejari << '=' << kawasan ;
}
Operator penugasan digunakan untuk menetapkan nilai apungan ke kawasan, yang terdiri daripada nilai jejari dalam jenis data integer.
Kawasan bulatan dikembalikan dalam jenis data apungan, manakala jejari dimasukkan dalam jenis data integer. Oleh itu, jenis data pembolehubah diubah melalui penghantaran jenis menggunakan pengendali tugasan.
Jenis Penukaran Menggunakan Operator Cast dalam C++
Penukaran jenis dilakukan dengan menggunakan operator cast, yang memaksa satu jenis data bertukar kepada jenis lain mengikut keperluan program.
Terdapat empat Operator Cast yang berbeza:
- static_cast
- const_cast
- dynamic_cast
- reinterpret_cast
1: static_cast
static_cast ialah pengendali pemutus yang digunakan untuk menukar apungan dan aksara secara eksplisit kepada integer dan sebagainya. Ini ialah pengendali pelakon yang paling asas. Ia boleh menghantar jenis data yang serupa sifatnya. Ia boleh menukar penunjuk dari satu bentuk ke bentuk yang lain, jadi ia juga boleh digunakan untuk pengurusan memori.
Sintaks
static_cast ( ungkapan ) Contoh
Program ini dibina untuk menukar pembolehubah berganda kepada jenis data int menggunakan static_cast. Ia akan memotong mana-mana bahagian perpuluhan dalam output.
menggunakan ruang nama std ;
int utama ( )
{
// mengisytiharkan pembolehubah
berganda hlm ;
hlm = 2,905 * 1,235 * 24,675 ;
terapung hasil ;
cout << ' Sebelum menggunakan cast statik:' << endl ;
cout << 'Nilai p = ' << hlm << endl ;
// gunakan static_cast untuk menukar jenis data
hasil = static_cast ( hlm ) ;
cout << ' Selepas menggunakan cast statik: ' << endl ;
cout << 'Nilai hasil = ' << hasil << endl ;
kembali 0 ;
}
Pada mulanya, pembolehubah berganda p dimuatkan dengan nilai yang didarab antara satu sama lain dan disimpan dalam hasilnya. Hasilnya mengandungi hasil sebelum dan selepas pengendali static_cast:
Sebelum menggunakan operator static_cast, hasilnya dipaparkan dalam titik perpuluhan, manakala selepas menggunakan operator ini ia dipaparkan dalam jenis data integer.
2: const_cast
Operator const_cast digunakan untuk menukar nilai malar objek kepada jenis bukan malar. Ia digunakan di mana objek malar diisytiharkan, dan kita perlu menukar nilainya sekali-sekala.
Sintaks
const_cast ( ungkapan ) Contoh
Dalam contoh ini, operator const_cast digunakan untuk mengalih keluar kelayakan malar buat sementara waktu dan membenarkan membuat perubahan dalam pembolehubah mengikut keperluan:
menggunakan ruang nama std ;
int utama ( ) {
const int x = 70 ;
const int * dan = & x ;
cout << 'Nilai lama ialah' << * dan << ' \n ' ;
int * Dengan = const_cast ( dan ) ;
* Dengan = 90 ;
cout << 'Nilai baharu ialah' << * dan ;
kembali 0 ;
}
Kelayakan malar diberikan kepada pembolehubah int x yang bermaksud bahawa pembolehubah ini tidak boleh diubah suai secara langsung. Selepas itu int *y yang merupakan penunjuk digunakan untuk mengakses x, tetapi ia masih tidak boleh diubah, dan nilai asalnya dipaparkan menggunakan cout. Menggunakan operator const_cast, penunjuk z dicipta yang bukan pemalar, ia digunakan untuk mengakses nilai x menjadikannya boleh diedit. Ia menukar nilai yang diberikan kepada z dengan 90 yang secara tidak langsung mengubah nilai dalam x.
Pada mulanya, nilai pembolehubah malar x ialah 70 yang diubah suai dengan menggunakan operator const_cast, menjadikannya 90.
3: dynamic_cast
dengan hierarki warisan, yang juga dirujuk sebagai downcast jenis selamat. Turun tuangan ialah proses menukar rujukan atau penuding kepada kelas terbitan daripada rujukan atau penuding kelas asas.
Sintaks
dynamic_cast ( ungkapan ) Contoh
Dalam contoh ini, pengendali dynamic_cast digunakan untuk menyemak jenis kelas polimorfik, dan ia membenarkan akses kepada kedua-dua ahli kelas asas dan terbitan.
#include
menggunakan ruang nama std ;
kelas TBase
{
awam :
terapung asas_g = 9.81 ;
maya batal dummy ( )
{
} ;
} ;
kelas Diperolehi : awam TBase
{
awam :
int local_g = 9.78 ;
} ;
int utama ( )
{
TBase * asas = baru Diperolehi ;
Diperolehi * diperolehi ;
diperolehi = dynamic_cast ( asas ) ;
cout < asas_g << endl ;
cout < local_g << endl ;
getchar ( ) ;
kembali 0 ;
}
Dua kelas ditakrifkan sebagai kelas asas dan terbitan. Pangkalan penunjuk jenis TBase* dicipta dan diperuntukkan kepada objek yang diperuntukkan secara dinamik jenis TDerived. Objek kelas terbitan boleh diberikan kepada penunjuk kelas asas dalam contoh polimorfisme ini. dynamic_cast menyemak sama ada penuding mengakses objek sah TDerived, jika pelakon mendapat hasil yang berjaya kelas terbitan akan mendapat hasil yang sah jika tidak ia akan mengembalikan nilai nol.
4: reinterpret_cast
Reinterpret_cast mengubah penunjuk satu jenis data menjadi penunjuk jenis data yang berbeza. Ia tidak menyemak sama ada jenis data penunjuk adalah sama atau tidak. Operator tuangan ini perlu digunakan dan dikendalikan dengan berhati-hati.
Contoh
Dalam ilustrasi ini, penunjuk satu jenis data ditafsirkan semula menjadi penunjuk jenis data lain menggunakan reinterpret_cast:
menggunakan ruang nama std ;
int utama ( )
{
int * q = baru int ( 70 ) ;
char * ch = reinterpret_cast ( q ) ;
cout << * q << endl ;
cout << * ch << endl ;
cout << q << endl ;
cout << ch << endl ;
kembali 0 ;
}
Pada mulanya, integer diberikan dengan nilai 70. Penunjuk q menunjuk kepada integer yang diperuntukkan secara dinamik ini. Reinterpret_cast digunakan untuk mentafsir semula penunjuk q sebagai penunjuk aksara ch, yang bermaksud bahawa memori yang asalnya diberikan kepada q kini dianggap seolah-olah ia adalah aksara. Menggunakan perintah cout, ia mencetak nilai yang diberikan kepada q dan ch. Oleh kerana ch dianggap sebagai penunjuk aksara, ia akan mengembalikan nilai aksara.
Ia mencetak nilai yang ditunjuk kepada ch menggunakan *ch. Walau bagaimanapun, oleh kerana ch dianggap sebagai penunjuk aksara, baris ini akan mentafsir memori sebagai watak. Ia mencetak alamat memori yang disimpan dalam penuding ch menggunakan ch. Ini adalah alamat memori yang sama dengan q kerana ia hanyalah tafsiran semula memori yang sama.
Pada mulanya, integer menyimpan 70. Kemudian, ini dimanipulasi antara penunjuk q dan penuding ch. Output 2 dan 4 adalah sama kerana nilai kedua ditafsir semula menggunakan reinterpret_cast.
Catatan : Adalah dicadangkan untuk tidak menggunakan operator cast ini sehingga dan melainkan sangat diperlukan kerana ia menjadikan objek sebagai produk bukan mudah alih
Kesimpulan
Proses menukar jenis data satu pembolehubah kepada yang lain dikenali sebagai penukaran jenis atau penghantaran jenis dalam C++. Ini dilakukan untuk melaksanakan operasi matematik pada pembolehubah jenis data yang berbeza, dengan menjadikan jenis data mereka serasi antara satu sama lain. Penukaran jenis mengoptimumkan kod. Terdapat penukaran jenis tersirat dan eksplisit dalam C++. Penukaran jenis tersirat dijalankan oleh pengkompil itu sendiri menggunakan set peraturan yang telah ditetapkan, manakala penukaran jenis eksplisit dijalankan oleh pengaturcara menggunakan pengendali tugasan dan pengendali hantar.