Memahami Bytes, Bits, dan Tipe Data dalam C++: Panduan Lengkap

C++ adalah bahasa pemrograman yang kuat dan serbaguna yang digunakan untuk mengembangkan berbagai macam aplikasi, mulai dari sistem operasi hingga game. Memahami konsep dasar seperti bits, bytes, dan tipe data sangat penting untuk menulis kode C++ yang efisien dan efektif. Artikel ini akan memberikan panduan komprehensif untuk membantu Anda memahami konsep-konsep ini dan bagaimana menerapkannya dalam pemrograman C++.

Daftar Isi

1. Pendahuluan: Mengapa Memahami Bits, Bytes, dan Tipe Data Penting?
2. Apa itu Bit?
   • Representasi Biner
   • Operasi Bitwise
3. Apa itu Byte?
   • Hubungan antara Bit dan Byte
   • Ukuran Byte
4. Tipe Data dalam C++
   • Tipe Data Primitif
     • Integer (int, short, long, long long)
     • Floating-Point (float, double, long double)
     • Character (char)
     • Boolean (bool)
     • void
   • Tipe Data Bentukan Pengguna
     • struct
     • class
     • enum
     • union
   • Tipe Data Turunan
     • Pointer
     • Array
     • Reference
5. Ukuran Tipe Data
   • Menggunakan Operator sizeof
   • Perbedaan Ukuran Tipe Data pada Arsitektur yang Berbeda
6. Representasi Data
   • Representasi Integer: Two’s Complement
   • Representasi Floating-Point: IEEE 754
   • Representasi Character: ASCII dan Unicode
7. Endianness: Big Endian vs. Little Endian
   • Apa itu Endianness?
   • Bagaimana Memeriksa Endianness pada Sistem Anda
8. Konversi Tipe Data (Type Casting)
   • Implicit Type Conversion
   • Explicit Type Conversion (Casting)
   • static_cast, dynamic_cast, const_cast, reinterpret_cast
9. Penyimpanan Data dan Memori
   • Stack vs. Heap
   • Alokasi Memori Dinamis dengan new dan delete
10. Praktik Terbaik untuk Penggunaan Tipe Data
    • Memilih Tipe Data yang Tepat
    • Menghindari Overflow dan Underflow
    • Menggunakan const untuk Data yang Tidak Berubah
11. Contoh Kode C++
    • Menunjukkan Penggunaan Tipe Data yang Berbeda
    • Operasi Bitwise dalam Praktik
    • Konversi Tipe Data dalam Praktik
12. Tips Pemecahan Masalah Umum
    • Masalah terkait Tipe Data yang Umum
    • Cara Mendebug Masalah Tipe Data
13. Kesimpulan: Menguasai Bits, Bytes, dan Tipe Data dalam C++

1. Pendahuluan: Mengapa Memahami Bits, Bytes, dan Tipe Data Penting?

Dalam dunia pemrograman, khususnya C++, memahami konsep dasar seperti bits, bytes, dan tipe data sangat krusial. Konsep-konsep ini adalah fondasi dari bagaimana data direpresentasikan dan dimanipulasi di dalam komputer. Tanpa pemahaman yang kuat tentang konsep-konsep ini, Anda akan kesulitan untuk menulis kode yang efisien, efektif, dan bebas bug.

Berikut beberapa alasan mengapa pemahaman tentang bits, bytes, dan tipe data penting:

• Optimasi Memori: Memahami ukuran tipe data memungkinkan Anda memilih tipe data yang paling sesuai untuk kebutuhan Anda, sehingga mengoptimalkan penggunaan memori.
• Efisiensi Performa: Memilih tipe data yang tepat juga dapat meningkatkan performa program Anda. Misalnya, menggunakan tipe data integer yang lebih kecil (seperti short) daripada tipe data integer yang lebih besar (seperti long) jika memungkinkan dapat menghemat memori dan meningkatkan kecepatan eksekusi.
• Akurasi Data: Memahami rentang nilai yang dapat direpresentasikan oleh setiap tipe data membantu Anda menghindari masalah seperti overflow (ketika nilai melebihi batas atas tipe data) dan underflow (ketika nilai kurang dari batas bawah tipe data).
• Kompatibilitas Platform: Ukuran tipe data dapat bervariasi tergantung pada arsitektur komputer dan kompilator yang digunakan. Memahami perbedaan ini penting untuk menulis kode yang portabel dan dapat berjalan dengan benar di berbagai platform.
• Operasi Tingkat Rendah: Pemahaman tentang bits dan bytes sangat penting jika Anda perlu melakukan operasi tingkat rendah seperti manipulasi bit, komunikasi jaringan, atau akses memori langsung.

2. Apa itu Bit?

Bit (binary digit) adalah unit terkecil informasi dalam komputasi. Bit hanya dapat memiliki dua nilai: 0 atau 1. Semua data dalam komputer direpresentasikan menggunakan kombinasi bit.

Representasi Biner

Sistem bilangan biner adalah sistem bilangan basis-2 yang hanya menggunakan dua digit: 0 dan 1. Setiap digit dalam bilangan biner disebut bit. Misalnya, angka desimal 5 direpresentasikan sebagai 101 dalam biner.

Berikut adalah tabel yang menunjukkan representasi biner dari beberapa angka desimal:

• 0 (Desimal) = 0 (Biner)
• 1 (Desimal) = 1 (Biner)
• 2 (Desimal) = 10 (Biner)
• 3 (Desimal) = 11 (Biner)
• 4 (Desimal) = 100 (Biner)
• 5 (Desimal) = 101 (Biner)
• 6 (Desimal) = 110 (Biner)
• 7 (Desimal) = 111 (Biner)
• 8 (Desimal) = 1000 (Biner)
• 9 (Desimal) = 1001 (Biner)
• 10 (Desimal) = 1010 (Biner)

Operasi Bitwise

Operasi bitwise adalah operasi yang bekerja pada bit individual dari suatu nilai. C++ menyediakan sejumlah operator bitwise yang memungkinkan Anda untuk memanipulasi bit.

Berikut adalah beberapa operator bitwise yang umum digunakan dalam C++:

• & (AND): Mengembalikan 1 jika kedua bit adalah 1, jika tidak mengembalikan 0.
• | (OR): Mengembalikan 1 jika salah satu atau kedua bit adalah 1, jika tidak mengembalikan 0.
• ^ (XOR): Mengembalikan 1 jika hanya satu dari kedua bit adalah 1, jika tidak mengembalikan 0.
• ~ (NOT): Membalikkan bit (mengubah 0 menjadi 1 dan 1 menjadi 0).
• << (Left Shift): Menggeser bit ke kiri sejumlah posisi tertentu.
• >> (Right Shift): Menggeser bit ke kanan sejumlah posisi tertentu.

Berikut adalah contoh penggunaan operator bitwise dalam C++:

  #include <iostream>

  int main() {
    int a = 5;  // 0101 dalam biner
    int b = 3;  // 0011 dalam biner

    std::cout << "a & b = " << (a & b) << std::endl;  // Output: 1 (0001)
    std::cout << "a | b = " << (a | b) << std::endl;  // Output: 7 (0111)
    std::cout << "a ^ b = " << (a ^ b) << std::endl;  // Output: 6 (0110)
    std::cout << "~a = " << (~a) << std::endl;    // Output: -6 (tergantung representasi integer)
    std::cout << "a << 1 = " << (a << 1) << std::endl;  // Output: 10 (1010)
    std::cout << "a >> 1 = " << (a >> 1) << std::endl;  // Output: 2 (0010)

    return 0;
  }
  

3. Apa itu Byte?

Byte adalah unit informasi yang lebih besar dari bit. Dalam kebanyakan sistem komputer modern, satu byte terdiri dari 8 bit.

Hubungan antara Bit dan Byte

Karena satu byte terdiri dari 8 bit, maka satu byte dapat merepresentasikan 2⁸ = 256 nilai yang berbeda. Nilai-nilai ini biasanya direpresentasikan sebagai bilangan bulat dari 0 hingga 255.

Ukuran Byte

Ukuran byte (8 bit) sudah menjadi standar de facto dalam komputasi modern. Meskipun ada sistem historis yang menggunakan ukuran byte yang berbeda, sebagian besar sistem saat ini menggunakan byte 8-bit.

4. Tipe Data dalam C++

Tipe data menentukan jenis nilai yang dapat disimpan dalam suatu variabel. C++ menyediakan berbagai macam tipe data yang dapat digunakan untuk merepresentasikan berbagai jenis informasi.

Tipe Data Primitif

Tipe data primitif adalah tipe data dasar yang sudah built-in dalam bahasa C++.

Integer (int, short, long, long long)

Tipe data integer digunakan untuk merepresentasikan bilangan bulat (bilangan tanpa koma desimal).

• int: Tipe data integer yang paling umum digunakan. Ukuran int biasanya 4 byte (32 bit), tetapi dapat bervariasi tergantung pada kompilator dan arsitektur sistem.
• short: Tipe data integer yang lebih kecil dari int. Ukuran short biasanya 2 byte (16 bit).
• long: Tipe data integer yang lebih besar atau sama dengan int. Ukuran long biasanya 4 atau 8 byte.
• long long: Tipe data integer yang paling besar. Ukuran long long biasanya 8 byte (64 bit).

Anda dapat menggunakan keyword signed dan unsigned untuk menentukan apakah tipe data integer dapat merepresentasikan nilai negatif atau tidak. Secara default, tipe data integer adalah signed (dapat merepresentasikan nilai negatif dan positif). Jika Anda menggunakan unsigned, maka tipe data integer hanya dapat merepresentasikan nilai positif dan nol.

Berikut adalah tabel yang menunjukkan rentang nilai untuk berbagai tipe data integer (dengan asumsi ukuran byte adalah 8 bit):

Floating-Point (float, double, long double)

Tipe data floating-point digunakan untuk merepresentasikan bilangan riil (bilangan dengan koma desimal).

• float: Tipe data floating-point dengan presisi tunggal. Ukuran float biasanya 4 byte.
• double: Tipe data floating-point dengan presisi ganda. Ukuran double biasanya 8 byte.
• long double: Tipe data floating-point dengan presisi diperpanjang. Ukuran long double biasanya 8 atau 16 byte.

double memberikan presisi yang lebih tinggi dibandingkan dengan float, yang berarti dapat merepresentasikan bilangan riil dengan lebih akurat. long double memberikan presisi yang paling tinggi.

Character (char)

Tipe data char digunakan untuk merepresentasikan karakter tunggal. Ukuran char biasanya 1 byte (8 bit). Karakter direpresentasikan menggunakan encoding seperti ASCII atau Unicode.

Boolean (bool)

Tipe data bool digunakan untuk merepresentasikan nilai boolean (benar atau salah). Tipe data bool hanya dapat memiliki dua nilai: true atau false. Ukuran bool biasanya 1 byte.

void

Tipe data void digunakan untuk menunjukkan bahwa suatu fungsi tidak mengembalikan nilai atau bahwa suatu pointer adalah generic pointer (pointer yang dapat menunjuk ke tipe data apa pun). Anda tidak dapat membuat variabel dengan tipe data void.

Tipe Data Bentukan Pengguna

C++ memungkinkan Anda untuk membuat tipe data Anda sendiri menggunakan keyword struct, class, enum, dan union.

struct

struct digunakan untuk mendefinisikan tipe data yang terdiri dari beberapa variabel yang disebut anggota (members). Anggota struct dapat memiliki tipe data yang berbeda.

  struct Point {
    int x;
    int y;
  };
  

class

class mirip dengan struct, tetapi dengan kemampuan tambahan seperti enkapsulasi, inheritance, dan polymorphism. class adalah dasar dari pemrograman berorientasi objek (OOP) dalam C++.

  class Rectangle {
  private:
    int width;
    int height;
  public:
    Rectangle(int w, int h) : width(w), height(h) {}
    int getArea() { return width * height; }
  };
  

enum

enum (enumeration) digunakan untuk mendefinisikan tipe data yang terdiri dari sekumpulan konstanta bernama.

  enum Color {
    RED,
    GREEN,
    BLUE
  };
  

union

union mirip dengan struct, tetapi semua anggota union berbagi ruang memori yang sama. Hanya satu anggota union yang dapat menyimpan nilai pada satu waktu.

  union Data {
    int i;
    float f;
    char str[20];
  };
  

Tipe Data Turunan

Tipe data turunan dibangun dari tipe data primitif atau tipe data bentukan pengguna lainnya.

Pointer

Pointer adalah variabel yang menyimpan alamat memori variabel lain. Pointer memungkinkan Anda untuk mengakses dan memanipulasi data secara langsung di memori.

    int num = 10;
    int *ptr = # // ptr menunjuk ke alamat memori num
    

Array

Array adalah kumpulan elemen dari tipe data yang sama yang disimpan dalam lokasi memori yang berdekatan. Array memungkinkan Anda untuk menyimpan dan mengakses banyak nilai dari tipe data yang sama menggunakan satu nama variabel.

    int numbers[5] = {1, 2, 3, 4, 5};
    

Reference

Reference adalah alias untuk variabel lain. Ketika Anda membuat reference, Anda sebenarnya membuat nama lain untuk variabel yang sudah ada. Setiap perubahan yang dilakukan pada reference akan memengaruhi variabel asli.

    int num = 10;
    int &ref = num; // ref adalah reference ke num
    

5. Ukuran Tipe Data

Ukuran tipe data (dalam byte) menentukan berapa banyak memori yang dialokasikan untuk menyimpan nilai dari tipe data tersebut.

Menggunakan Operator sizeof

Anda dapat menggunakan operator sizeof untuk mendapatkan ukuran tipe data atau variabel dalam byte.

  #include <iostream>

  int main() {
    std::cout << "Ukuran int: " << sizeof(int) << " bytes" << std::endl;
    std::cout << "Ukuran float: " << sizeof(float) << " bytes" << std::endl;
    std::cout << "Ukuran char: " << sizeof(char) << " bytes" << std::endl;
    std::cout << "Ukuran double: " << sizeof(double) << " bytes" << std::endl;

    int num = 10;
    std::cout << "Ukuran variabel num (int): " << sizeof(num) << " bytes" << std::endl;

    return 0;
  }
  

Perbedaan Ukuran Tipe Data pada Arsitektur yang Berbeda

Ukuran tipe data dapat bervariasi tergantung pada arsitektur komputer (32-bit atau 64-bit) dan kompilator yang digunakan. Misalnya, pada sistem 32-bit, ukuran int biasanya 4 byte, sedangkan pada sistem 64-bit, ukuran int bisa 4 atau 8 byte.

Penting untuk mengetahui ukuran tipe data pada platform target Anda untuk menulis kode yang portabel dan efisien.

6. Representasi Data

Memahami bagaimana data direpresentasikan dalam memori sangat penting untuk memahami bagaimana komputer memproses informasi.

Representasi Integer: Two’s Complement

Sebagian besar sistem komputer modern menggunakan representasi two’s complement untuk merepresentasikan bilangan bulat signed. Dalam representasi two’s complement, bit paling signifikan (MSB) digunakan untuk menunjukkan tanda (0 untuk positif, 1 untuk negatif).

Untuk mendapatkan representasi two’s complement dari bilangan negatif, Anda perlu melakukan langkah-langkah berikut:

1. Dapatkan representasi biner dari nilai absolut bilangan tersebut.
2. Inverskan semua bit (ubah 0 menjadi 1 dan 1 menjadi 0).
3. Tambahkan 1 ke hasil inversi.

Contoh: Representasi two’s complement dari -5 (dengan asumsi menggunakan 8 bit):

1. Representasi biner dari 5: 00000101
2. Inverskan bit: 11111010
3. Tambahkan 1: 11111011

Jadi, representasi two’s complement dari -5 adalah 11111011.

Representasi Floating-Point: IEEE 754

Standar IEEE 754 adalah standar yang paling umum digunakan untuk merepresentasikan bilangan floating-point. Standar ini mendefinisikan format untuk merepresentasikan bilangan floating-point dengan presisi tunggal (float) dan presisi ganda (double).

Format IEEE 754 terdiri dari tiga bagian:

• Sign bit: Menunjukkan tanda bilangan (0 untuk positif, 1 untuk negatif).
• Exponent: Menunjukkan pangkat dari bilangan.
• Mantissa (atau Significand): Menunjukkan digit signifikan dari bilangan.

Representasi IEEE 754 memungkinkan untuk merepresentasikan bilangan riil dengan rentang yang luas dan presisi yang baik.

Representasi Character: ASCII dan Unicode

Karakter direpresentasikan menggunakan encoding seperti ASCII dan Unicode.

• ASCII (American Standard Code for Information Interchange): Adalah encoding karakter 7-bit yang merepresentasikan 128 karakter (huruf, angka, simbol, dan kontrol karakter).
• Unicode: Adalah encoding karakter yang lebih komprehensif yang merepresentasikan lebih dari 143,000 karakter dari berbagai bahasa di dunia. Unicode menggunakan encoding seperti UTF-8, UTF-16, dan UTF-32.

Dalam C++, tipe data char biasanya digunakan untuk merepresentasikan karakter ASCII, sementara tipe data wchar_t (wide character) digunakan untuk merepresentasikan karakter Unicode.

7. Endianness: Big Endian vs. Little Endian

Endianness mengacu pada urutan byte dalam memori untuk merepresentasikan data yang lebih besar dari satu byte (misalnya, integer atau floating-point). Ada dua jenis endianness: big endian dan little endian.

Apa itu Endianness?

• Big Endian: Byte paling signifikan (MSB) disimpan di alamat memori terendah, dan byte paling tidak signifikan (LSB) disimpan di alamat memori tertinggi.
• Little Endian: Byte paling tidak signifikan (LSB) disimpan di alamat memori terendah, dan byte paling signifikan (MSB) disimpan di alamat memori tertinggi.

Contoh: Misalkan kita ingin merepresentasikan integer 0x12345678 (dalam heksadesimal) dalam memori.

• Big Endian: Alamat memori akan berisi byte-byte berikut: 12 34 56 78
• Little Endian: Alamat memori akan berisi byte-byte berikut: 78 56 34 12

Arsitektur Intel x86 (yang digunakan pada sebagian besar komputer desktop dan laptop) menggunakan little endian, sedangkan beberapa arsitektur lain (seperti beberapa sistem embedded dan jaringan) menggunakan big endian.

Bagaimana Memeriksa Endianness pada Sistem Anda

Anda dapat menggunakan kode C++ berikut untuk memeriksa endianness pada sistem Anda:

  #include <iostream>

  int main() {
    int num = 1;
    char *ptr = (char *)#

    if (*ptr == 1) {
      std::cout << "Little Endian" << std::endl;
    } else {
      std::cout << "Big Endian" << std::endl;
    }

    return 0;
  }
  

Kode ini memeriksa byte pertama dari integer 1. Jika byte pertama adalah 1, maka sistem menggunakan little endian; jika tidak, sistem menggunakan big endian.

8. Konversi Tipe Data (Type Casting)

Konversi tipe data (atau type casting) adalah proses mengubah nilai dari satu tipe data ke tipe data lainnya.

Implicit Type Conversion

Implicit type conversion (konversi tipe data implisit) terjadi secara otomatis oleh kompilator ketika tipe data dicampur dalam suatu ekspresi.

Contoh:

  int a = 10;
  double b = a; // Implicit conversion dari int ke double
  

Dalam contoh ini, nilai a (yang bertipe int) secara otomatis dikonversi ke tipe double sebelum disimpan dalam variabel b.

Explicit Type Conversion (Casting)

Explicit type conversion (konversi tipe data eksplisit) dilakukan secara manual oleh programmer menggunakan operator casting.

Contoh:

  double a = 10.5;
  int b = (int)a; // Explicit conversion dari double ke int (C-style cast)
  

Dalam contoh ini, nilai a (yang bertipe double) secara eksplisit dikonversi ke tipe int menggunakan C-style cast. Nilai desimal akan dipotong (truncated), sehingga b akan bernilai 10.

static_cast, dynamic_cast, const_cast, reinterpret_cast

C++ menyediakan beberapa operator casting yang lebih aman dan terkontrol:

• static_cast: Digunakan untuk konversi tipe data yang dapat dilakukan pada waktu kompilasi (misalnya, konversi antara tipe data numerik atau konversi dari pointer ke tipe dasar).
• dynamic_cast: Digunakan untuk konversi tipe data yang melibatkan hierarki class (misalnya, konversi dari pointer ke tipe dasar ke pointer ke tipe turunan). dynamic_cast melakukan pemeriksaan tipe pada waktu runtime dan mengembalikan nullptr jika konversi tidak valid.
• const_cast: Digunakan untuk menghilangkan atau menambahkan qualifier const pada suatu variabel.
• reinterpret_cast: Digunakan untuk melakukan konversi tipe data yang berbahaya dan tidak portable. Operator ini harus digunakan dengan hati-hati karena dapat menyebabkan undefined behavior.

Contoh:

  double a = 10.5;
  int b = static_cast<int>(a); // Konversi dari double ke int menggunakan static_cast

  class Base {
  public:
    virtual void print() { std::cout << "Base" << std::endl; }
  };

  class Derived : public Base {
  public:
    void print() { std::cout << "Derived" << std::endl; }
  };

  Base *basePtr = new Derived();
  Derived *derivedPtr = dynamic_cast<Derived*>(basePtr); // Konversi dari Base* ke Derived* menggunakan dynamic_cast

  const int num = 10;
  int *nonConstPtr = const_cast<int*>(&num); // Menghilangkan qualifier const

  int *intPtr = new int(10);
  char *charPtr = reinterpret_cast<char*>(intPtr); // Konversi dari int* ke char* menggunakan reinterpret_cast
  

9. Penyimpanan Data dan Memori

Memahami bagaimana data disimpan dalam memori sangat penting untuk menulis kode C++ yang efisien dan bebas dari kebocoran memori.

Stack vs. Heap

Ada dua area memori utama yang digunakan oleh program C++: stack dan heap.

• Stack: Digunakan untuk menyimpan variabel lokal, parameter fungsi, dan alamat pengembalian fungsi. Memori pada stack dialokasikan dan dibebaskan secara otomatis oleh sistem. Stack bersifat LIFO (Last-In, First-Out).
• Heap: Digunakan untuk menyimpan data yang dialokasikan secara dinamis menggunakan operator new. Memori pada heap harus dibebaskan secara manual menggunakan operator delete. Heap lebih fleksibel daripada stack, tetapi pengelolaan memori pada heap lebih kompleks dan rentan terhadap kebocoran memori jika tidak dilakukan dengan benar.

Alokasi Memori Dinamis dengan new dan delete

Anda dapat menggunakan operator new untuk mengalokasikan memori secara dinamis pada heap dan operator delete untuk membebaskan memori yang telah dialokasikan.

  int *numPtr = new int; // Mengalokasikan memori untuk sebuah integer pada heap
  *numPtr = 10;

  delete numPtr; // Membebaskan memori yang telah dialokasikan
  numPtr = nullptr; // Mengatur pointer ke nullptr untuk menghindari dangling pointer
  

Penting untuk selalu membebaskan memori yang telah dialokasikan menggunakan new dengan menggunakan delete untuk menghindari kebocoran memori. Selain itu, setelah membebaskan memori, sebaiknya atur pointer ke nullptr untuk menghindari dangling pointer (pointer yang menunjuk ke lokasi memori yang sudah dibebaskan).

10. Praktik Terbaik untuk Penggunaan Tipe Data

Berikut adalah beberapa praktik terbaik untuk penggunaan tipe data dalam C++:

Memilih Tipe Data yang Tepat

Pilih tipe data yang paling sesuai untuk jenis data yang akan Anda simpan. Misalnya, jika Anda hanya perlu menyimpan bilangan bulat kecil, gunakan tipe data short daripada int atau long untuk menghemat memori.

Menghindari Overflow dan Underflow

Pastikan bahwa rentang nilai yang mungkin untuk suatu variabel sesuai dengan rentang nilai yang dapat direpresentasikan oleh tipe datanya. Jika tidak, Anda dapat mengalami overflow (ketika nilai melebihi batas atas tipe data) atau underflow (ketika nilai kurang dari batas bawah tipe data).

Menggunakan const untuk Data yang Tidak Berubah

Gunakan keyword const untuk mendeklarasikan variabel yang nilainya tidak boleh diubah setelah inisialisasi. Ini membantu untuk meningkatkan keamanan kode dan mencegah perubahan yang tidak disengaja.

  const int MAX_VALUE = 100;
  

11. Contoh Kode C++

Berikut adalah beberapa contoh kode C++ yang menunjukkan penggunaan tipe data yang berbeda, operasi bitwise, dan konversi tipe data:

Menunjukkan Penggunaan Tipe Data yang Berbeda

  #include <iostream>

  int main() {
    int age = 30;
    float height = 1.75f;
    double weight = 70.5;
    char initial = 'J';
    bool isStudent = true;

    std::cout << "Umur: " << age << std::endl;
    std::cout << "Tinggi: " << height << std::endl;
    std::cout << "Berat: " << weight << std::endl;
    std::cout << "Inisial: " << initial << std::endl;
    std::cout << "Status Mahasiswa: " << isStudent << std::endl;

    return 0;
  }
  

Operasi Bitwise dalam Praktik

  #include <iostream>

  int main() {

    int a = 5;  // 0101 dalam biner

    int b = 3;  // 0011 dalam biner
    std::cout << "a & b = " << (a & b) << std::endl;  // Output: 1

    std::cout << "a | b = " << (a | b) << std::endl;  // Output: 7

    std::cout << "a ^ b = " << (a ^ b) << std::endl;  // Output: 6

    std::cout << "~a = " << (~a) << std::endl;    // Output: -6

    std::cout << "a << 1 = " << (a << 1) << std::endl;  // Output: 10

    std::cout << "a >>