- Mengenal tipe data karakter, angka bulat, dan angka desimal
- Belajar menggunakan operator sizeof() untuk mengetahui ukuran tipe data
- Memahami penggunaan tipe data dalam konteks nyata
- Mengenal tipe data extended (lebih lanjut)
**Prerequisites:**
- Dasar-dasar pemrograman
- Pemahaman tentang program Halo Dunia
- Pemahaman tentang variabel
---END_LESSON_INFO---
# Tipe Data dalam C
**Tipe data dalam bahasa C** menentukan jenis nilai yang bisa disimpan dalam variabel, serta ukuran dan rentang nilai yang bisa ditampung. Setiap variabel dalam C harus memiliki tipe data yang dideklarasikan.
## Mengapa Tipe Data Penting?
**Tipe data** penting karena:
- Menentukan **jumlah memori** yang dialokasikan untuk variabel
- Menentukan **jenis nilai** yang bisa disimpan (angka, karakter, dll.)
- Menentukan **operasi** yang bisa dilakukan pada variabel tersebut
## Tipe Data Karakter
**Tipe data `char`** digunakan untuk menyimpan **satu karakter**. Karakter harus ditempatkan di dalam tanda petik tunggal `' '`.
```c
char myGrade = 'A';
char letter = 'x';
char symbol = '@';
```
**Format specifier** untuk `char` adalah `%c`:
```c
char myGrade = 'A';
printf("My grade is: %c\n", myGrade); // Output: My grade is: A
```
## Tipe Data Angka Bulat
**Tipe data `int`** digunakan untuk menyimpan **bilangan bulat** (angka tanpa desimal).
```c
int myNum = 5; // Bilangan positif
int myNegativeNum = -5; // Bilangan negatif
int zero = 0; // Nol
```
**Format specifier** untuk `int` adalah `%d` atau `%i`:
```c
int myNum = 5;
printf("My number is: %d\n", myNum); // Output: My number is: 5
```
### Tipe Data Integer Lainnya
C juga menyediakan tipe data integer lainnya:
-`short` - versi pendek dari int (biasanya 2 byte)
-`long` - versi panjang dari int (biasanya 8 byte)
-`unsigned int` - versi int tanpa tanda (hanya nilai positif dan nol)
## Tipe Data Desimal
**Tipe data `float`** digunakan untuk menyimpan **bilangan desimal** dengan presisi tunggal.
```c
float myFloat = 9.99;
float scientific = 3e5; // 300000
float negative = -3.99;
```
**Format specifier** untuk `float` adalah `%f`:
```c
float myFloat = 9.99;
printf("My float is: %f\n", myFloat); // Output: My float is: 9.990000
```
**Tipe data `double`** digunakan untuk menyimpan **bilangan desimal** dengan presisi ganda (lebih akurat dari float).
```c
double myDouble = 19.99;
double precise = 3.141592653589793;
```
**Format specifier** untuk `double` adalah `%lf`:
```c
double myDouble = 19.99;
printf("My double is: %lf\n", myDouble); // Output: My double is: 19.990000
```
## Mengetahui Ukuran Tipe Data
Anda bisa menggunakan **operator `sizeof()`** untuk mengetahui ukuran tipe data dalam byte:
```c
#include <stdio.h>
int main() {
printf("Size of char: %zu byte(s)\n", sizeof(char));
printf("Size of int: %zu byte(s)\n", sizeof(int));
printf("Size of float: %zu byte(s)\n", sizeof(float));
printf("Size of double: %zu byte(s)\n", sizeof(double));
return 0;
}
```
**Output (dapat bervariasi tergantung sistem):**
```
Size of char: 1 byte(s)
Size of int: 4 byte(s)
Size of float: 4 byte(s)
Size of double: 8 byte(s)
```
## Tipe Data Extended
C juga menyediakan tipe data extended untuk kebutuhan spesifik:
### Tipe Data Unsigned
-`unsigned char` - karakter tanpa tanda (0 hingga 255)
-`unsigned int` - integer tanpa tanda (0 hingga 4,294,967,295)
-`unsigned short` - short integer tanpa tanda
-`unsigned long` - long integer tanpa tanda
### Tipe Data Signed
-`signed char` - karakter dengan tanda (-128 hingga 127)
-`signed int` - integer dengan tanda (sama seperti int biasa)
## Contoh Nyata Penggunaan Tipe Data
Berikut adalah contoh penggunaan berbagai tipe data dalam situasi nyata:
```c
#include <stdio.h>
int main() {
// Tipe data karakter
char initial = 'J';
// Tipe data angka bulat
int age = 25;
unsigned int population = 1000000;
// Tipe data desimal
float temperature = 36.6;
double preciseValue = 3.141592653589793238;
// Menampilkan informasi
printf("Initial: %c\n", initial);
printf("Age: %d years old\n", age);
printf("Population: %u people\n", population);
printf("Temperature: %.1f°C\n", temperature);
printf("Pi: %.10lf\n", preciseValue);
// Menampilkan ukuran tipe data
printf("\nSize of age variable: %zu bytes\n", sizeof(age));
printf("Size of temperature variable: %zu bytes\n", sizeof(temperature));
return 0;
}
```
**Output:**
```
Initial: J
Age: 25 years old
Population: 1000000 people
Temperature: 36.6°C
Pi: 3.1415926535
Size of age variable: 4 bytes
Size of temperature variable: 4 bytes
```
## Konstanta dalam C
**Konstanta** dalam bahasa C adalah nilai tetap yang tidak dapat diubah selama eksekusi program. Konstanta juga dikenal sebagai **literal** karena nilainya langsung ditulis dalam kode program.
### Jenis-Jenis Konstanta
Ada beberapa jenis konstanta dalam bahasa C:
#### 1. Konstanta Integer
Nilai bilangan bulat yang tidak memiliki bagian desimal:
```c
const int MAX_STUDENTS = 100;
int count = 50;
```
#### 2. Konstanta Floating-Point
Nilai bilangan desimal:
```c
const double PI = 3.14159;
float tax_rate = 0.08;
```
#### 3. Konstanta Karakter
Satu karakter yang diapit oleh tanda petik tunggal:
```c
const char NEWLINE = '\n';
char grade = 'A';
```
#### 4. Konstanta String
Rangkaian karakter yang diapit oleh tanda petik ganda:
```c
const char *GREETING = "Hello, World!";
char message[] = "Welcome to C programming";
```
### Keyword `const`
Anda bisa membuat variabel menjadi konstan dengan menggunakan **keyword `const`**. Setelah dideklarasikan sebagai konstan, nilai variabel tersebut tidak bisa diubah:
```c
const int AGE = 25;
// AGE = 30; // Ini akan menyebabkan error karena AGE adalah konstan
```
### Preprocessor `#define`
Alternatif lain untuk membuat konstanta adalah dengan menggunakan **preprocessor directive `#define`**:
```c
#define PI 3.14159
#define MAX_SIZE 100
#define NAME "John Doe"
int main() {
double area = PI * 5 * 5; // Menghitung luas lingkaran dengan jari-jari 5
printf("Area of circle: %.2f\n", area);
return 0;
}
```
**Tips:**
- Gunakan tipe data yang **tepat** untuk kebutuhan Anda
- Perhatikan **rentang nilai** yang bisa ditampung oleh masing-masing tipe data
- Gunakan `unsigned` jika Anda yakin nilai tidak akan negatif
- Gunakan `double` jika Anda membutuhkan presisi tinggi
