IF221106 · Algoritma dan Pemrograman
Pertemuan 10–11 — Array & String
Eka Prakarsa Mandyartha, ST., M.Kom.
Prodi Informatika · UPN Veteran Jawa Timur
Materi Kuliah · Pertemuan 10 – 11
Array
& String dalam Bahasa C
Menyimpan dan mengelola banyak data bertipe sama dalam satu variabel — mulai dari array satu dimensi, dua dimensi, hingga string sebagai array karakter.
📄 7 Halaman 🗂 Array 1D & 2D 💻 Bahasa C
Progres Belajar
Halaman 1 dari 7
Pengantar
Mengapa Array Dibutuhkan?

Misalkan ingin menyimpan nilai ujian 30 mahasiswa. Tanpa array:

Tanpa array — merepotkanC
int nilai1, nilai2, nilai3, ..., nilai30; // 30 variabel terpisah!
// Tidak praktis, tidak bisa di-loop, tidak terkelola

Dengan array, cukup satu deklarasi dan seluruh data dapat diakses melalui indeks:

Dengan array — ringkas dan terstrukturC
int nilai[30]; // satu deklarasi untuk 30 data
for (int i = 0; i < 30; i++)
    scanf("%d", &nilai[i]); // input semua dengan loop
Definisi

Array adalah variabel kompleks yang dapat menyimpan banyak nilai bertipe data sama dalam satu nama variabel. Setiap nilai disebut elemen, dan diakses melalui nomor indeks yang unik. Seluruh elemen disimpan secara berurutan di dalam memori.

Array Satu Dimensi
Deklarasi dan Inisialisasi
Cara deklarasi arrayC
/* 1. Deklarasi kosong — isi nanti */
int nilai[5];

/* 2. Deklarasi sekaligus inisialisasi */
int nilai[5] = {85, 72, 90, 68, 77};

/* 3. Ukuran otomatis dari jumlah nilai */
int nilai[] = {85, 72, 90, 68, 77}; // ukuran = 5 otomatis

/* 4. Inisialisasi sebagian — sisanya 0 */
int nilai[5] = {85, 72}; // nilai[2]=0, nilai[3]=0, nilai[4]=0
Representasi dalam Memori: int nilai[5] = {85, 72, 90, 68, 77}
85
[0]
nilai[0]
72
[1]
nilai[1]
90
[2]
nilai[2]
68
[3]
nilai[3]
77
[4]
nilai[4]
⚠ Indeks dimulai dari 0, bukan 1!
Array dengan 5 elemen (int nilai[5]) memiliki indeks 0 sampai 4.
Elemen pertama adalah nilai[0], elemen terakhir adalah nilai[4].
nilai[5] tidak ada — mengaksesnya adalah illegal operation (dibahas di halaman 4).
Operasi Dasar Array 1D
Mengakses, Mengisi, dan Traversal Array

Setiap elemen array diakses dengan menuliskan nama array diikuti indeks dalam tanda kurung siku: nama_array[indeks]

Akses, ubah, dan traversal arrayC
#include <stdio.h>
int main() {
    int nilai[5] = {85, 72, 90, 68, 77};

    /* Akses elemen tunggal */
    printf("Elemen ke-0 : %d\n", nilai[0]); // 85
    printf("Elemen ke-2 : %d\n", nilai[2]); // 90

    /* Ubah nilai elemen */
    nilai[1] = 80; // ganti 72 menjadi 80

    /* Traversal: baca semua elemen dengan for */
    printf("Semua nilai: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", nilai[i]);
    }
    printf("\n");
    // Output: 85 80 90 68 77
    return 0;
}
Mencari nilai maksimum dan minimumC
#include <stdio.h>
int main() {
    int data[6] = {45, 82, 17, 93, 60, 38};
    int maks = data[0], min = data[0];
    int idx_maks = 0, idx_min = 0;

    for (int i = 1; i < 6; i++) {
        if (data[i] > maks) { maks = data[i]; idx_maks = i; }
        if (data[i] < min)  { min  = data[i]; idx_min  = i; }
    }

    printf("Maks: %d (indeks %d)\n", maks, idx_maks); // 93 (indeks 3)
    printf("Min : %d (indeks %d)\n", min, idx_min);  // 17 (indeks 2)
    return 0;
}
Pola standar traversal array: Gunakan for (int i = 0; i < N; i++) — inisialisasi dari 0 (indeks pertama), berhenti sebelum N (indeks terakhir adalah N-1). Ini adalah pola yang akan digunakan berulang kali.
Array Dua Dimensi
Array yang Menyerupai Tabel / Matriks

Array dua dimensi menyimpan data dalam bentuk baris dan kolom — seperti tabel atau matriks. Setiap elemen diakses menggunakan dua indeks: array[baris][kolom].

Deklarasi array 2 dimensiC
/* Sintaks: tipe nama[jumlah_baris][jumlah_kolom] */
int matriks[3][4]; // 3 baris, 4 kolom = 12 elemen total

/* Deklarasi + inisialisasi */
int matriks[3][3] = {
    {1, 2, 3},   // baris 0
    {4, 5, 6},   // baris 1
    {7, 8, 9}    // baris 2
};

/* Akses elemen: matriks[baris][kolom] */
printf("%d\n", matriks[1][2]); // baris 1, kolom 2 → 6
Visualisasi Matriks 3×3
[0] [1] [2] ← kolom
[0] 123 matriks[0][0..2]
[1] 4 5 6 ← matriks[1][2] = 6
[2] 789 matriks[2][0..2]
↑ baris
Traversal array 2D dengan nested loopC
#include <stdio.h>
int main() {
    int mat[3][3] = {{1,2,3},{4,5,6},{7,8,9}};

    printf("Isi matriks:\n");
    for (int i = 0; i < 3; i++) {      // outer: baris
        for (int j = 0; j < 3; j++) {  // inner: kolom
            printf("%3d", mat[i][j]);
        }
        printf("\n");
    }
    return 0;
}
/* Output:
   1 2 3
   4 5 6
   7 8 9  */
Contoh: nilai 3 mahasiswa × 4 mata kuliahC
int nilai[3][4] = {
    {80, 75, 90, 85},  // mahasiswa 0
    {70, 88, 65, 92},  // mahasiswa 1
    {95, 60, 78, 83}   // mahasiswa 2
};

/* Hitung rata-rata tiap mahasiswa */
for (int i = 0; i < 3; i++) {
    int total = 0;
    for (int j = 0; j < 4; j++)
        total += nilai[i][j];
    printf("Rata-rata mhs %d: %.1f\n", i, (float)total/4);
}
⚠ Bahaya Kritis
Akses Elemen di Luar Batas Array — Illegal Operation

Bahasa C tidak memeriksa batas array secara otomatis saat runtime. Ini berbeda dengan banyak bahasa modern. Ketika program mengakses indeks di luar yang didefinisikan, compiler tidak memberikan error — program tetap berjalan, tetapi membaca atau menimpa memori yang bukan miliknya.

⚠ Ini bukan sekadar bug biasa. Akses di luar batas array adalah salah satu penyebab utama:
· Hasil program yang tidak dapat diprediksi (nilai acak atau salah)
· Segmentation Fault — program crash karena mengakses memori yang dilindungi
· Buffer Overflow — celah keamanan berbahaya yang bisa dieksploitasi hacker
· Korupsi data variabel lain yang kebetulan berada di lokasi memori yang tertimpa
Contoh: akses di luar batasC
#include <stdio.h>
int main() {
    int data[3] = {10, 20, 30};
    // Elemen valid: data[0], data[1], data[2]

    printf("data[0] = %d\n", data[0]);  // ✓ 10
    printf("data[1] = %d\n", data[1]);  // ✓ 20
    printf("data[2] = %d\n", data[2]);  // ✓ 30

    /* ❌ Di luar batas — BERBAHAYA! */
    printf("data[3] = %d\n", data[3]);  // indeks 3 tidak ada!
    printf("data[5] = %d\n", data[5]);  // jauh di luar batas
    printf("data[-1]= %d\n", data[-1]); // indeks negatif!

    /* ❌ MENULIS di luar batas — jauh lebih berbahaya! */
    data[10] = 999; // menimpa memori program lain!
    return 0;
}
Contoh Hasil Eksekusi Aktual (bervariasi tiap sistem)
$ gcc -o test illegal_array.c && ./test
data[0] = 10
data[1] = 20
data[2] = 30
data[3] = 32767  ← nilai sampah dari memori (garbage value)
data[5] = 0      ← kebetulan 0, tapi tidak bisa diandalkan
data[-1]= -1836218432 ← membaca sebelum array — nilai tidak diketahui
Segmentation fault (core dumped)  ← crash! data[10]=999 menulis ke memori terlarang
Apa yang sebenarnya terjadi di memori?
Memori:
???
[-1]
10
[0] ✓
20
[1] ✓
30
[2] ✓
???
[3] ✗
???
[4] ✗
← bukan milik array
Kotak hijau = wilayah array yang sah. Kotak merah = area memori di luar array yang bisa berisi apa saja — variabel lain, kode program, atau area terlarang OS.
💡 Cara menghindari out-of-bounds:
① Selalu gunakan for (i = 0; i < N; i++) — tidak pernah i <= N
② Gunakan konstanta untuk ukuran: #define N 5 lalu pakai N di semua tempat
③ Saat menggunakan index dari input user, validasi dulu sebelum dipakai
Konsep Paling Penting tentang String
String dalam Bahasa C: Sejatinya Tidak Ada

Ini adalah konsep yang paling sering disalahpahami pemula. Dalam bahasa C, tidak ada tipe data string. Yang ada hanyalah array bertipe char yang diakhiri oleh karakter khusus bernilai nol ('\0'), yang disebut null terminator.

Null Terminator '\0'

'\0' adalah karakter dengan nilai ASCII 0 (nol). Ia menandai akhir dari sebuah string. Semua fungsi string standar C (printf, strlen, strcpy, dll.) bergantung pada karakter ini untuk mengetahui di mana string berakhir. Tanpa '\0', fungsi-fungsi tersebut akan terus membaca memori melampaui batas string.

Penulisan "Halo" dalam program C sebenarnya adalah array 5 karakter: 'H', 'a', 'l', 'o', dan '\0' di akhir.

Bagaimana "Halo" tersimpan di memori
'H'
[0]
'a'
[1]
'l'
[2]
'o'
[3]
'\0'
[4]
← null terminator
wajib ada di akhir
Panjang string "Halo" = 4 karakter, tapi ukuran array yang dibutuhkan = 5 (4 + 1 untuk '\0')
Pengaruh '\0' pada Deklarasi
Ukuran Array char Harus Selalu +1

Karena '\0' menyita satu slot, array char untuk menyimpan string harus dideklarasikan dengan ukuran panjang karakter + 1.

❌ Ukuran kurang — berbahaya!
/* "Halo" = 4 karakter */
char nama[4] = "Halo";
// H a l o  ← hanya 4 slot
// Tidak ada tempat untuk '\0'!
// printf akan terus baca
// memori melampaui batas
'H'
[0]
'a'
[1]
'l'
[2]
'o'
[3]
???
[4]✗
← '\0' tidak ada tempat
✅ Ukuran benar
/* "Halo" = 4 karakter + 1 */
char nama[5] = "Halo";
// H a l o '\0' ← 5 slot
// Compiler otomatis
// menambahkan '\0'
// di posisi [4]
'H'
[0]
'a'
[1]
'l'
[2]
'o'
[3]
'\0'
[4]✓
← null terminator aman
⚠ Aturan mutlak: Untuk menyimpan string dengan panjang N karakter, deklarasikan array char berukuran minimal N+1.
Contoh: menyimpan NIM "052112007" (9 karakter) → char nim[10];
Visualisasi '\0' dengan loopC
#include <stdio.h>
int main() {
    char nama[5] = "Halo";

    /* Cetak tiap karakter dan nilainya */
    for (int i = 0; i < 5; i++) {
        printf("nama[%d] = '%c' (ASCII: %d)\n",
               i, nama[i], nama[i]);
    }
    return 0;
}
/* Output:
   nama[0] = 'H' (ASCII: 72)
   nama[1] = 'a' (ASCII: 97)
   nama[2] = 'l' (ASCII: 108)
   nama[3] = 'o' (ASCII: 111)
   nama[4] = ''  (ASCII: 0)   ← null terminator '\0' */
Operasi String
Input, Output, dan Fungsi String Standar
Input dan output stringC
#include <stdio.h>
int main() {
    char nama[50]; // cadangan 50 karakter + '\0'

    /* Input: scanf berhenti di spasi */
    printf("Nama depan: ");
    scanf("%s", nama); // tidak perlu & karena array sudah pointer
    printf("Halo, %s!\n", nama);

    /* Input dengan spasi: gunakan fgets */
    char nama_lengkap[100];
    printf("Nama lengkap: ");
    fgets(nama_lengkap, 100, stdin); // membaca satu baris penuh
    printf("Halo, %s", nama_lengkap);
    return 0;
}
scanf("%s") vs fgets(): scanf("%s") berhenti membaca saat bertemu spasi — hanya cocok untuk satu kata. fgets() membaca satu baris penuh termasuk spasi — gunakan untuk nama lengkap atau kalimat.
Fungsi String Standar — dari <string.h>
Fungsi Kegunaan Contoh
strlen(s) Panjang string (tidak termasuk '\0') strlen("Halo") → 4
strcpy(dst,src) Salin string src ke dst strcpy(b, "Halo")
strcat(dst,src) Sambung src ke akhir dst strcat(a,"!") → "Halo!"
strcmp(a,b) Bandingkan dua string. Return 0 jika sama strcmp("A","A") → 0
strupr(s) Ubah semua huruf menjadi kapital strupr("halo") → "HALO"
Penggunaan fungsi stringC
#include <stdio.h>
#include <string.h>

int main() {
    char a[20] = "Halo";
    char b[20] = "Dunia";

    printf("Panjang a: %d\n", (int)strlen(a));   // 4
    strcat(a, " ");
    strcat(a, b);
    printf("Gabungan : %s\n", a);           // Halo Dunia

    /* Perbandingan string — tidak bisa pakai == */
    if (strcmp(a, b) == 0)
        printf("Sama\n");
    else
        printf("Berbeda\n");                 // Berbeda
    return 0;
}
⚠ Jangan bandingkan string dengan ==
if (nama == "Eka") membandingkan alamat memori, bukan isi string. Selalu gunakan strcmp(nama, "Eka") == 0 untuk membandingkan isi string.
Latihan Terpadu
Program: Data Nilai Mahasiswa (Array 1D + String)
data_mahasiswa.cC
#include <stdio.h>
#include <string.h>
#define N 5   // gunakan konstanta, lebih aman

int main() {
    char nama[N][30]; // array 2D: N mahasiswa, max 30 char
    float nilai[N];
    float total = 0, rata;
    int idx_terbaik = 0;

    /* Input data */
    for (int i = 0; i < N; i++) {
        printf("Nama mahasiswa %d : ", i+1);
        scanf("%29s", nama[i]); // max 29 char + '\0'
        printf("Nilai           : ");
        scanf("%f", &nilai[i]);
        total += nilai[i];
        if (nilai[i] > nilai[idx_terbaik]) idx_terbaik = i;
    }

    rata = total / N;

    /* Output laporan */
    printf("\n====== LAPORAN NILAI ======\n");
    for (int i = 0; i < N; i++) {
        printf("%-20s : %.1f %s\n",
               nama[i], nilai[i],
               (nilai[i] >= 60) ? "Lulus" : "Tidak");
    }
    printf("===========================\n");
    printf("Rata-rata  : %.1f\n", rata);
    printf("Nilai Maks : %s (%.1f)\n", nama[idx_terbaik], nilai[idx_terbaik]);
    return 0;
}
💡 Perhatikan kombinasinya:
char nama[N][30] adalah array 2D — N nama, masing-masing max 30 karakter (29 + '\0')
scanf("%29s") — angka 29 membatasi input agar tidak melampaui batas array
Operator ternary digunakan langsung di dalam printf untuk efisiensi
Ringkasan Pertemuan 10 – 11
Yang Telah Kita Pelajari
2
Dimensi Array (1D & 2D)
0
Indeks mulai dari nol
+1
Ukuran char untuk '\0'
  • Array menyimpan banyak data bertipe sama dalam satu variabel — diakses via indeks mulai dari 0
  • Array 2D menggunakan dua indeks array[baris][kolom] — cocok untuk tabel dan matriks
  • Akses di luar batas → undefined behavior: nilai sampah, crash (segfault), atau buffer overflow
  • String dalam C bukan tipe data — melainkan array char yang diakhiri '\0'
  • Array char untuk N karakter harus berukuran N+1 untuk muat null terminator
  • Fungsi string standar dari <string.h>: strlen, strcpy, strcat, strcmp
  • Perbandingan string harus pakai strcmp() — bukan ==
🔜 Topik Berikutnya
Fungsi — Membuat Kode yang Modular dan Dapat Digunakan Ulang
Array sering diteruskan sebagai argumen ke fungsi — memahami cara kerja pengiriman array ke fungsi akan menjadi bagian penting di topik berikutnya.