Tipe data
Karena semua data di komputer hanyalah urutan bit, kami menggunakan tipe data (sering disebut “tipe” untuk jangka pendek) untuk memberi tahu kompiler bagaimana menafsirkan isi memori dalam beberapa cara yang berarti. Anda telah melihat satu contoh tipe data: integer. Ketika kita mendeklarasikan variabel sebagai integer, kita memberi tahu compiler “bagian dari memori yang digunakan variabel ini akan ditafsirkan sebagai nilai integer”.
Ketika Anda memberikan suatu nilai pada suatu objek, kompiler dan CPU akan mengkodekan nilai Anda ke dalam urutan bit yang sesuai untuk tipe data tersebut, yang kemudian disimpan dalam memori (ingat: memori hanya dapat menyimpan bit). Misalnya, jika Anda menetapkan objek integer dengan nilai 65 , nilai tersebut dikonversi ke urutan bit 0100 0001dan disimpan dalam memori yang ditetapkan untuk objek tersebut.
Sebaliknya, ketika objek dievaluasi untuk menghasilkan nilai, urutan bit tersebut disusun kembali ke nilai aslinya. Artinya 0100 0001diubah kembali menjadi nilai 65 .
Untungnya, kompiler dan CPU melakukan semua kerja keras di sini, jadi Anda biasanya tidak perlu khawatir tentang bagaimana nilai diubah menjadi urutan bit dan kembali.
Yang perlu Anda lakukan adalah memilih tipe data untuk objek Anda yang paling cocok dengan penggunaan yang Anda inginkan.
Tipe data dasar
C++ hadir dengan dukungan bawaan untuk banyak tipe data yang berbeda. Ini disebut tipe data fundamental , tetapi sering secara informal disebut tipe dasar , tipe primitif , atau tipe bawaan .
Berikut adalah daftar tipe data fundamental, beberapa di antaranya telah Anda lihat:
Void
Void adalah tipe data yang paling mudah untuk dijelaskan. Pada dasarnya, void berarti “tidak ada tipe”!
Akibatnya, variabel tidak dapat didefinisikan dengan tipe void. Void biasanya digunakan dalam beberapa konteks yang berbeda.
Fungsi yang tidak mengembalikan nilai
Paling umum, void digunakan untuk menunjukkan bahwa suatu fungsi tidak mengembalikan nilai:
void bilangan(int x) // void here means no return value
{
std::cout << "Bilangan x adalah : " << x << '\\n';
// no return statement, because this function doesn't return a value
}
Jika Anda menggunakan pernyataan pengembalian untuk mencoba mengembalikan nilai dalam fungsi seperti itu, kesalahan kompilasi akan terjadi:
void noReturn(int x) // void here means no return value
{
return 5; // error
}
Ukuran tipe data dasar
Pertanyaan berikutnya yang jelas adalah “berapa banyak memori yang dibutuhkan variabel dari tipe data yang berbeda?”. Anda mungkin terkejut menemukan bahwa ukuran tipe data tertentu bergantung pada kompiler dan/atau arsitektur komputer!
C++ hanya menjamin bahwa setiap tipe data dasar akan memiliki ukuran minimum:
Namun, ukuran sebenarnya dari variabel mungkin berbeda pada mesin Anda (terutama int, yang lebih sering 4 byte).
Ukuran operator
Untuk menentukan ukuran tipe data pada mesin tertentu, C++ menyediakan operator bernama sizeof . Operator sizeof adalah operator unary yang mengambil baik jenis atau variabel, dan mengembalikan ukurannya dalam bytes. Anda dapat mengkompilasi dan menjalankan program berikut untuk mengetahui seberapa besar beberapa tipe data Anda:
#include <iostream>
int main()
{
std::cout << "bool:\\t\\t" << sizeof(bool) << " bytes\\n";
std::cout << "char:\\t\\t" << sizeof(char) << " bytes\\n";
std::cout << "wchar_t:\\t" << sizeof(wchar_t) << " bytes\\n";
std::cout << "char16_t:\\t" << sizeof(char16_t) << " bytes\\n";
std::cout << "char32_t:\\t" << sizeof(char32_t) << " bytes\\n";
std::cout << "short:\\t\\t" << sizeof(short) << " bytes\\n";
std::cout << "int:\\t\\t" << sizeof(int) << " bytes\\n";
std::cout << "long:\\t\\t" << sizeof(long) << " bytes\\n";
std::cout << "long long:\\t" << sizeof(long long) << " bytes\\n";
std::cout << "float:\\t\\t" << sizeof(float) << " bytes\\n";
std::cout << "double:\\t\\t" << sizeof(double) << " bytes\\n";
std::cout << "long double:\\t" << sizeof(long double) << " bytes\\n";
return 0;
}
Hasil Anda mungkin berbeda jika Anda menggunakan jenis mesin yang berbeda, atau kompiler yang berbeda. Perhatikan bahwa Anda tidak dapat menggunakan operator sizeof pada tipe void , karena tidak memiliki ukuran (melakukannya akan menyebabkan kesalahan kompilasi).
Anda juga dapat menggunakan operator sizeof pada nama variabel:
#include <iostream>
int main()
{
int x{};
std::cout << "x is " << sizeof(x) << " bytes\\n";
return 0;
}
Bilangan bulat bertanda
Bilangan bulat adalah tipe integral yang dapat mewakili bilangan bulat positif dan negatif, termasuk 0 (misalnya -2, -1, 0, 1, 2). C++ memiliki 4 tipe integer dasar yang berbeda yang tersedia untuk digunakan:
Perbedaan utama antara berbagai tipe bilangan bulat adalah bahwa mereka memiliki ukuran yang bervariasi — bilangan bulat yang lebih besar dapat menampung angka yang lebih besar.
Saat menulis angka negatif dalam kehidupan sehari-hari, kami menggunakan tanda negatif. Misalnya, -3 berarti “negatif 3”. Kami juga biasanya mengenali +3 sebagai “3 positif” (meskipun konvensi umum menyatakan bahwa kami biasanya menghilangkan awalan plus). Atribut ini menjadi positif, negatif, atau nol disebut jumlah ini tanda .
Secara default, bilangan bulat ditandatangani , yang berarti tanda nomor disimpan sebagai bagian dari nomor (menggunakan bit tunggal yang disebut bit tanda ). Oleh karena itu, bilangan bulat bertanda dapat menampung angka positif dan negatif (dan 0).
Mendefinisikan bilangan bulat bertanda
short s;
int i;
long l;
long long ll;
Semua bilangan bulat (kecuali int) dapat mengambil akhiran int opsional :
short int si;
long int li;
long long int lli;
Sufiks ini tidak boleh digunakan. Selain lebih banyak mengetik, menambahkan akhiran int membuat tipe lebih sulit dibedakan dari variabel bertipe int . Ini dapat menyebabkan kesalahan jika pengubah pendek atau panjang secara tidak sengaja terlewatkan.
Tipe integer juga dapat mengambil kata kunci bertanda opsional , yang menurut konvensi biasanya ditempatkan sebelum nama tipe:
signed short ss;
signed int si;
signed long sl;
signed long long sll;
Namun, kata kunci ini tidak boleh digunakan, karena berlebihan.
Range bilangan bulat bertanda
Seperti yang Anda pelajari di bagian terakhir, variabel dengan n bit dapat menampung 2 n nilai yang mungkin. Tapi nilai spesifik yang mana? Kami menyebut kumpulan nilai spesifik yang dapat disimpan oleh tipe data dalam jangkauannya . Rentang variabel integer ditentukan oleh dua faktor: ukurannya (dalam bit), dan apakah itu ditandatangani atau tidak.
Menurut definisi, bilangan bulat bertanda 8-bit memiliki kisaran -128 hingga 127. Ini berarti bilangan bulat bertanda dapat menyimpan nilai bilangan bulat apa pun antara -128 dan 127 (inklusif) dengan aman.
Berikut adalah tabel yang berisi kisaran bilangan bulat bertanda dengan ukuran berbeda:
Pembagian bilangan bulat
Saat membagi dua bilangan bulat, C++ berfungsi seperti yang Anda harapkan ketika hasil bagi adalah bilangan bulat:
#include <iostream>
int main()
{
std::cout << 20 / 4;
return 0;
}
Mari kita lihat apa yang terjadi ketika pembagian bilangan bulat menyebabkan hasil pecahan:
#include <iostream>
int main()
{
std::cout << 8 / 5;
return 0;
}
Saat melakukan pembagian dengan dua bilangan bulat (disebut pembagian bilangan bulat ), C++ selalu menghasilkan hasil bilangan bulat. Karena bilangan bulat tidak dapat menampung nilai pecahan, bagian pecahan mana pun dibuang begitu saja (tidak dibulatkan!).
Melihat lebih dekat pada contoh di atas, 8/5 menghasilkan nilai 1.6. Bagian pecahan (0,6) dijatuhkan, dan hasil dari 1 tetap.
Demikian pula, -8 / 5 menghasilkan nilai -1.
Bilangan bulat tak bertanda
C++ juga mendukung bilangan bulat yang tidak ditandatangani. Bilangan bulat tidak bertanda adalah bilangan bulat yang hanya dapat menampung bilangan bulat non-negatif.
Mendefinisikan bilangan bulat tak bertanda
Untuk mendefinisikan unsigned integer, kita menggunakan kata kunci unsigned . Dengan konvensi, ini ditempatkan sebelum tipe:
unsigned short us;
unsigned int ui;
unsigned long ul;
unsigned long long ull;
Range bilangan bulat tak bertanda
Bilangan bulat tidak bertanda 1 byte memiliki rentang 0 hingga 255. Bandingkan ini dengan rentang bilangan bulat bertanda 1 byte dari -128 hingga 127. Keduanya dapat menyimpan 256 nilai yang berbeda, tetapi bilangan bulat bertanda menggunakan setengah dari rentangnya untuk bilangan negatif, sedangkan bilangan bulat tidak bertanda dapat menyimpan bilangan positif yang dua kali lebih besar.
Berikut adalah tabel yang menunjukkan rentang untuk bilangan bulat yang tidak bertanda:
Bila tidak ada angka negatif yang diperlukan, bilangan bulat tidak bertanda sangat cocok untuk jaringan dan sistem dengan sedikit memori, karena bilangan bulat tidak bertanda dapat menyimpan lebih banyak bilangan positif tanpa menggunakan memori tambahan.
Notasi ilmiah
Notasi ilmiah adalah singkatan yang berguna untuk menulis angka panjang secara ringkas. Dan meskipun notasi ilmiah mungkin tampak asing pada awalnya, memahami notasi ilmiah akan membantu Anda memahami cara kerja bilangan floating point, dan yang lebih penting, apa batasannya.
Bilangan dalam notasi ilmiah berbentuk sebagai berikut: signifikan dan x 10 eksponen . Misalnya, dalam notasi ilmiah 1.2 x 10⁴, 1.2adalah signifikan dan 4eksponen. Karena 10⁴ bernilai 10.000, 1,2 x 10⁴ bernilai 12.000.
Menurut konvensi, angka dalam notasi ilmiah ditulis dengan satu digit sebelum koma, dan digit lainnya sesudahnya.
Pertimbangkan massa Bumi. Dalam notasi desimal, kami akan menulis ini sebagai 5973600000000000000000000 kg. Itu jumlah yang sangat besar (terlalu besar untuk muat bahkan dalam bilangan bulat 8 byte). Ini juga sulit dibaca (apakah itu 19 atau 20 nol?). Bahkan dengan pemisah (5.973.600.000.000.000.000.000.000) jumlahnya masih sulit dibaca.
Dalam notasi ilmiah, ini akan ditulis sebagai 5.9736 x 10²⁴ kg, yang lebih mudah dibaca. Notasi ilmiah memiliki manfaat tambahan untuk mempermudah membandingkan besaran dua bilangan yang sangat besar atau sangat kecil hanya dengan membandingkan eksponennya.
Karena mungkin sulit untuk mengetik atau menampilkan eksponen dalam C++, kami menggunakan huruf ‘e’ (atau terkadang ‘E’) untuk mewakili bagian “kali 10 pangkat” dari persamaan. Misalnya, 1.2 x 10⁴akan ditulis sebagai 1.2e4, dan 5.9736 x 10²⁴akan ditulis sebagai 5.9736e24.
Untuk angka yang lebih kecil dari 1, eksponennya bisa negatif. Angka 5e-2tersebut setara dengan 5 * 10⁻², yaitu 5 / 10², atau 0.05. Massa elektron adalah 9.1093822e-31 kg.
Cara mengubah angka menjadi notasi ilmiah
Gunakan prosedur berikut:
- Eksponen Anda dimulai dari nol.
- Geser desimal sehingga hanya ada satu angka bukan nol di sebelah kiri desimal.
- Setiap tempat Anda menggeser desimal ke kiri meningkatkan eksponen sebesar 1.
- Setiap tempat Anda menggeser desimal ke kanan mengurangi eksponen sebesar 1.
- Pangkas semua nol di depan (di ujung kiri signifikan dan)
- Pangkas semua angka nol yang tertinggal (di ujung kanan tanda dan) hanya jika angka aslinya tidak memiliki titik desimal. Kami berasumsi mereka tidak signifikan kecuali ditentukan lain.
Presisi dan angka nol setelah desimal
Pertimbangkan kasus di mana kami meminta dua asisten lab masing-masing untuk menimbang apel yang sama. Seseorang kembali dan mengatakan apel itu beratnya 87 gram. Yang lain kembali dan mengatakan apel itu berbobot 87,00 gram. Mari kita asumsikan penimbangannya benar. Dalam kasus sebelumnya, berat sebenarnya apel bisa berkisar antara 86,50 dan 87,49 gram. Mungkin skalanya hanya tepat untuk gram terdekat. Atau mungkin asisten kami sedikit membulat. Dalam kasus terakhir, kami yakin tentang berat sebenarnya apel ke tingkat yang jauh lebih tinggi (beratnya antara 86.9950 dan 87.0049 gram, yang memiliki variabilitas jauh lebih sedikit).
Jadi, dalam notasi ilmiah standar, kami lebih memilih untuk tetap mengikuti angka nol setelah titik desimal, karena angka tersebut memberikan informasi yang berguna tentang ketepatan angka.
Namun, dalam C++, 87 dan 87.000 diperlakukan sama persis, dan kompiler akan menyimpan nilai yang sama untuk masing-masing. Tidak ada alasan teknis mengapa kita harus lebih memilih satu daripada yang lain (meskipun mungkin ada alasan ilmiah, jika Anda menggunakan kode sumber sebagai dokumentasi).
Sekarang kita telah membahas notasi ilmiah, kita siap untuk membahas bilangan floating point.
Floating Point
Bilangan bulat sangat bagus untuk menghitung bilangan bulat, tetapi terkadang kita perlu menyimpan bilangan yang sangat besar, atau bilangan dengan komponen pecahan. Sebuah floating point variabel jenis adalah variabel yang dapat menyimpan sejumlah nyata, seperti 4320,0, -3,33, atau 0,01226. Bagian floating dari nama floating point mengacu pada fakta bahwa titik desimal dapat “mengambang”; yaitu, dapat mendukung sejumlah variabel digit sebelum dan sesudah titik desimal.
Ada tiga tipe data floating point yang berbeda: float , double , dan long double . Seperti halnya bilangan bulat, C++ tidak menentukan ukuran sebenarnya dari jenis ini (tetapi menjamin ukuran minimum). Pada arsitektur modern, representasi floating point hampir selalu mengikuti format biner IEEE 754. Dalam format ini, float adalah 4 byte, double adalah 8, dan double panjang dapat setara dengan double (8 byte), 80-bit (sering diisi hingga 12 byte), atau 16 byte.
Tipe data floating point selalu bertanda (dapat menyimpan nilai positif dan negatif).
float fValue;
double dValue;
long double ldValue;
Saat menggunakan literal floating point, selalu sertakan setidaknya satu tempat desimal (bahkan jika desimalnya adalah 0). Ini membantu kompiler memahami bahwa angka tersebut adalah angka floating point dan bukan bilangan bulat.
Mencetak angka floating point
#include <iostream>
int main()
{
std::cout << 5.0 << '\\n';
std::cout << 6.7f << '\\n';
std::cout << 9876543.21 << '\\n';
return 0;
}
Floating point range
Presisi floating point
Perhatikan pecahan 1/3. Representasi desimal dari angka ini adalah 0,33333333333333… dengan 3 keluar hingga tak terhingga. Jika Anda menulis nomor ini di selembar kertas, lengan Anda akan lelah di beberapa titik, dan Anda akhirnya akan berhenti menulis. Dan angka yang tersisa akan mendekati 0,3333333333…. (dengan 3 keluar hingga tak terbatas) tetapi tidak persis.
Di komputer, jumlah panjang tak terbatas akan membutuhkan memori tak terbatas untuk disimpan, dan biasanya kita hanya memiliki 4 atau 8 byte. Memori yang terbatas ini berarti bilangan floating point hanya dapat menyimpan sejumlah digit signifikan tertentu — dan bahwa setiap digit signifikan tambahan akan hilang. Angka yang sebenarnya disimpan akan mendekati angka yang diinginkan, tetapi tidak tepat.
presisi dari sejumlah floating point mendefinisikan berapa banyak angka yang signifikan dapat mewakili tanpa kehilangan informasi.
Saat mengeluarkan angka floating point, std::cout memiliki presisi default 6 — yaitu, mengasumsikan semua variabel floating point hanya signifikan hingga 6 digit (presisi minimum float), dan karenanya akan memotong apa pun setelah itu .
Program berikut menunjukkan std::cout terpotong menjadi 6 digit:
#include <iostream>
int main()
{
std::cout << 9.87654321f << '\\n';
std::cout << 987.654321f << '\\n';
std::cout << 987654.321f << '\\n';
std::cout << 9876543.21f << '\\n';
std::cout << 0.0000987654321f << '\\n';
return 0;
}
Boolean
Dalam kehidupan nyata, pertanyaan atau pertanyaan yang bisa dijawab dengan “ya” atau “tidak” adalah hal yang biasa. “Apakah apel itu buah?” Ya. “Apakah kamu suka asparagus?” Tidak.
Sekarang perhatikan pernyataan serupa yang dapat dijawab dengan “benar” atau “salah”: “Apel adalah buah”. Ini jelas benar. Atau bagaimana dengan, “Saya suka asparagus”. Benar-benar salah.
Kalimat seperti ini yang hanya memiliki dua kemungkinan hasil: ya/benar, atau tidak/salah adalah sangat umum, sehingga banyak bahasa pemrograman menyertakan tipe khusus untuk menanganinya. Tipe itu disebut tipe Boolean (catatan: Boolean dikapitalisasi dengan benar dalam bahasa Inggris karena dinamai menurut penemunya, George Boole).
Variabel boolean
Variabel Boolean adalah variabel yang hanya memiliki dua kemungkinan nilai: true , dan false .
Untuk mendeklarasikan variabel Boolean, kita menggunakan kata kunci bool .
bool b;
Untuk menginisialisasi atau menetapkan nilai true atau false ke variabel Boolean, kami menggunakan kata kunci true dan false .
bool b1 { true };
bool b2 { false };
b1 = false;
bool b3 {}; // default initialize to false
Sama seperti operator unary (-) dapat digunakan untuk membuat bilangan bulat negatif, operator NOT (!) dapat digunakan untuk membalik nilai Boolean dari true ke false , atau false ke true :
bool b1 { !true }; // b1 will be initialized with the value false
bool b2 { !false }; // b2 will be initialized with the value true
Nilai Boolean sebenarnya tidak disimpan dalam variabel Boolean sebagai kata “benar” atau “salah”. Sebaliknya, mereka disimpan sebagai bilangan bulat: true menjadi bilangan bulat 1 , dan false menjadi bilangan bulat 0 . Demikian pula, ketika nilai Boolean dievaluasi, mereka tidak benar-benar mengevaluasi ke “benar” atau “salah”. Mereka mengevaluasi ke bilangan bulat 0 (salah) atau 1 (benar). Karena Boolean sebenarnya menyimpan bilangan bulat, mereka dianggap sebagai tipe integer.
Mencetak variabel boolean
Saat kita mencetak nilai Boolean dengan std::cout, std::cout mencetak 0 untuk false , dan 1 untuk true :
#include <iostream>
int main()
{
std::cout << true << '\\n'; // true evaluates to 1
std::cout << !true << '\\n'; // !true evaluates to 0
bool b{false};
std::cout << b << '\\n'; // b is false, which evaluates to 0
std::cout << !b << '\\n'; // !b is true, which evaluates to 1
return 0;
}
Char
Char tipe data dirancang untuk membuatcharacter. Sebuah karakter dapat menjadi satu huruf, angka, simbol, atau spasi.
Tipe data char adalah tipe integral, artinya nilai yang mendasari disimpan sebagai integer. Mirip dengan bagaimana nilai Boolean 0ditafsirkan sebagai falsedan bukan nol ditafsirkan sebagai true, bilangan bulat yang disimpan oleh charvariabel ditafsirkan sebagai ASCII character.
ASCII singkatan dari American Standard Code for Information Interchange, dan mendefinisikan cara tertentu untuk mewakili karakter bahasa Inggris (ditambah beberapa simbol lainnya) sebagai angka antara 0 dan 127 (disebut kode ASCII atau titik kode ). Misalnya, kode ASCII 97 ditafsirkan sebagai karakter ‘a’.
Literal karakter selalu ditempatkan di antara tanda kutip tunggal (misalnya ‘g’, ‘1’, ‘ ‘).
Inisialisasi karakter
Anda dapat menginisialisasi variabel char menggunakan literal karakter:
char ch2{ 'a' };
Mencetak karakter
Saat menggunakan std::cout untuk mencetak char, std::cout menampilkan variabel char sebagai karakter ASCII:
#include <iostream>
int main()
{
char ch1{ 'a' }; // (preferred)
std::cout << ch1; // cout prints a character
char ch2{ 98 }; // code point for 'b' (not preferred)
std::cout << ch2; // cout prints a character ('b')
return 0;
}
Mencetak karakter sebagai bilangan bulat melalui type casting
Jika kita ingin menampilkan char sebagai angka, bukan karakter, kita harus memberi tahu std::cout untuk mencetak char seolah-olah itu bilangan bulat. Salah satu cara (buruk) untuk melakukan ini adalah dengan menetapkan karakter ke bilangan bulat, dan mencetak bilangan bulat:
#include <iostream>
int main()
{
char ch { 97 } ;
int i { ch }; // initialize an integer with the value of ch
std::cout << i << '\\n'; // print the integer value
return 0;
}
Namun, ini aneh. Cara yang lebih baik adalah dengan menggunakan tipe cast . Sebuah tipe cast menciptakan nilai dari satu jenis dari nilai tipe lain. Untuk mengonversi antara tipe data dasar (misalnya, dari char ke int, atau sebaliknya), kami menggunakan tipe cast yang disebut static cast .
Sintaks untuk pemain statis terlihat sedikit lucu:
static_cast<new_type>(ekspresi)
static_cast mengambil nilai dari ekspresi sebagai input, dan mengubahnya menjadi tipe dasar apa pun yang direpresentasikan new_type (misalnya int, bool, char, double).
#include <iostream>
int main()
{
char ch{ 'a' };
std::cout << ch << '\\n';
std::cout << static_cast<int>(ch) << '\\n';
std::cout << ch << '\\n';
return 0;
}
Penting untuk dicatat bahwa parameter ke static_cast dievaluasi sebagai ekspresi. Ketika kita memasukkan sebuah variabel, variabel tersebut dievaluasi untuk menghasilkan nilainya, yang kemudian diubah menjadi tipe baru. Variabel tidak terpengaruh oleh casting nilainya ke tipe baru. Dalam kasus di atas, variabel ch masih berupa char, dan masih memiliki nilai yang sama.
Perhatikan juga bahwa casting statis tidak melakukan pemeriksaan rentang apa pun, jadi jika Anda memasukkan bilangan bulat besar ke dalam char, Anda akan membanjiri char Anda.
Memasukkan karakter
Program berikut meminta pengguna untuk memasukkan karakter, lalu mencetak karakter dan kode ASCII-nya:
#include <iostream>
int main()
{
std::cout << "Input a keyboard character: ";
char ch{};
std::cin >> ch;
std::cout << ch << " has ASCII code " << static_cast<int>(ch) << '\\n';
return 0;
}
Perhatikan bahwa std::cin akan memungkinkan Anda memasukkan banyak karakter. Namun, variabel ch hanya dapat menampung 1 karakter. Akibatnya, hanya karakter input pertama yang diekstraksi ke dalam variabel ch . Sisa input pengguna dibiarkan di buffer input yang digunakan std::cin, dan dapat diekstraksi dengan panggilan berikutnya ke std::cin.
Anda dapat melihat perilaku ini dalam contoh berikut:
#include <iostream>
int main()
{
std::cout << "Input a keyboard character: "; // assume the user enters "abcd" (without quotes)
char ch{};
std::cin >> ch; // ch = 'a', "bcd" is left queued.
std::cout << ch << " has ASCII code " << static_cast<int>(ch) << '\\n';
// Note: The following cin doesn't ask the user for input, it grabs queued input!
std::cin >> ch; // ch = 'b', "cd" is left queued.
std::cout << ch << " has ASCII code " << static_cast<int>(ch) << '\\n';
return 0;
}
Escape
Ada beberapa karakter dalam C++ yang memiliki arti khusus. Karakter ini disebut escape sequence . Urutan escape dimulai dengan karakter ‘\’ (garis miring terbalik), dan kemudian huruf atau angka berikutnya.
Anda telah melihat urutan escape yang paling umum: ‘\n’, yang dapat digunakan untuk menyematkan baris baru dalam string teks:
Berikut adalah tabel dari semua urutan escape:
std::string
Untuk menggunakan string dalam C++, pertama-tama kita perlu #include <string> header untuk membawa deklarasi untuk std::string. Setelah selesai, kita dapat mendefinisikan variabel bertipe std::string.
#include <string> // allows use of std::string
std::string myName {}; // empty string
Sama seperti variabel normal, Anda dapat menginisialisasi atau menetapkan nilai ke string seperti yang Anda harapkan:
std::string name{ "Jony" }; // initialize myName with string literal "Alex"
name = "Erik"; // assign variable myName the string literal "John"
Perhatikan bahwa string juga dapat menampung angka:
std::string myID{ "45" }; // "45" is not the same as integer 45!
Dalam bentuk string, angka diperlakukan sebagai teks, bukan angka, dan dengan demikian angka tidak dapat dimanipulasi sebagai angka (misalnya Anda tidak dapat mengalikannya). C++ tidak akan secara otomatis mengonversi nomor string menjadi nilai integer atau floating point.
Output string
String dapat menjadi output seperti yang diharapkan menggunakan std::cout:
#include <iostream>
#include <string>
int main()
{
std::string name{ "Sahru" };
std::cout << "Nama saya adalah " << name << '\\n';
return 0;
}
String kosong tidak akan mencetak apa pun:
#include <iostream>
#include <string>
int main()
{
std::string empty{ };
std::cout << '[' << empty << ']';
return 0;
}
Masukan string dengan std::cin
Menggunakan string dengan std::cin dapat menghasilkan beberapa kejutan! Perhatikan contoh berikut:
#include <iostream>
#include <string>
int main()
{
std::cout << "Enter your full name: ";
std::string name{};
std::cin >> name; // this won't work as expected since std::cin breaks on whitespace
std::cout << "Enter your age: ";
std::string age{};
std::cin >> age;
std::cout << "Your name is " << name << " and your age is " << age << '\\n';
return 0;
}
Berikut hasil dari contoh run program ini:
Hmm, itu tidak benar! Apa yang terjadi? Ternyata ketika menggunakan operator>> untuk mengekstrak string dari cin, operator>> hanya mengembalikan karakter hingga spasi putih pertama yang ditemuinya. Karakter lain dibiarkan di dalam std::cin, menunggu ekstraksi berikutnya.
Jadi ketika kami menggunakan operator>> untuk mengekstrak string ke dalam variabel name, hanya "John"diekstraksi, meninggalkan " Doe"di dalam std::cin. Ketika kami kemudian menggunakan operator>> untuk mendapatkan variabel age, itu diekstraksi "Doe"alih-alih menunggu kami memasukkan usia. Kemudian program berakhir.
Gunakan std::getline() untuk memasukkan teks
Untuk membaca baris input lengkap ke dalam string, Anda sebaiknya menggunakan std::getline()fungsi sebagai gantinya. std::getline() mengambil dua parameter: yang pertama adalah std::cin, dan yang kedua adalah variabel string Anda.
Berikut program yang sama seperti di atas menggunakan std::getline():
#include <string> // For std::string and std::getline
#include <iostream>
int main()
{
std::cout << "Enter your full name: ";
std::string name{};
std::getline(std::cin >> std::ws, name); // read a full line of text into name
std::cout << "Enter your age: ";
std::string age{};
std::getline(std::cin >> std::ws, age); // read a full line of text into age
std::cout << "Your name is " << name << " and your age is " << age << '\\n';
return 0;
}
Terimakasih, semoga tutorial ini bermanfaat apabila ada pertanyaan silahkan untuk bertanya di kolom komentar.
Leave a Reply