Tutorial Pemrograman C adalah pembahasan yang banyak dicari di Google, Yahoo dan Bing.
Hingga kini topik Belajar Pemrograman C, Panduan Pemrograman C Untuk Pemula, dan PDF Pemrograman C saat ini ramai dicari dalam 1 jam.

Untuk itu kami akan membahas Belajar Pemrograman C yang bisa kamu baca nantinya.
Penasaran denga Belajar Pemrograman C? Jika benar yuk simak artikel kami.
Pemrograman C
Ulasan Pemrograman C adalah pembahasan yang ramai dibahas.
Kenapa topik Panduan Pemrograman C Untuk Pemula bisa viral? dikarenakan ada media berita.
Selain itu ada juga grub yang ikut berdiskusi.
Sehingga ulasan Panduan Pemrograman C Untuk Pemula semakin viral dan kami tertarik membuat ulasannya.
Berikut ini hasil riset kami mengenai Tutorial Pemrograman C
Tutorial Pemrograman C
Bahasa C adalah bahasa pemrograman yang diciptakan oleh Kernigan dan Ritchie pada tahun 1972. Waktu membuktikan, bahwa bahasa C adalah bahasa klasik yang demikian elegan dan universal, sehingga :
- dipakai di perangkat keras kelas apa saja dari mikroprosesor hingga super komputer.
- tersedia di sistem operasi mana saja, dari UNIX, DOS, Windows hingga Linux.
- untuk aplikasi apa saja, dari membuat game, database, sistem-operasi, hingga real-time.
- menjadi inspirasi bahasa lain, mulai dari C++, C#, Java, PHP.
- selalu populer, hanya pernah dikalahkan oleh Java [1].
Belajar C sekarang, kalau anda bisa, belajar bahasa lain bakal mudah. Untuk mulai belajar, siapkan dulu:
- Kompiler C, kalau di Linux biasanya sudah pasti ada
- Integrated_Development_Environment_(IDE) C/C++.
Struktur Program
Bahasa C sangat sederhana dan konsisten (ini salah satu kelebihannya). Kalau ada yang bilang susah, itu lebih karena sintaksnya banyak yang kriptik, susah dimengerti. Tapi sekali paham, akan senang menuliskannya karena singkat, padat dan powerfull.
Untuk mulai menulis program C, anda harus mebuat sebuah file teks bernama “apa_saja.c”. Di dalam file tersebut, isi minimal adalah :
int main() { return 0; }
Sederhana kan.
Kalau mau lebih lengkap maka
/* Nama File: pertama.c */ // include pustaka dasar #include <stdio.h> // Fungsi utama int main() { // panggil fungsi print printf("Hello worldn"); return 0; }
Data
Ada rumus klasik yang mengatakan bahwa “program = struktur data + algoritma”. Mau bagaimana lagi, tugas perangkat lunak kan memang untuk mengolah data. Karena itu, jurus pertama dalam setiap bahasa adalah mendefiniskan data.
Tipe Data
Di dunia nyata, ada berbagai jenis data, misalnya nama, umur, nomor telepon, alamat. Karena itu bahasa C menyediakan berbagai tipe (jenis) data, yaitu:
Tipe | Keterangan | Contoh Penggunaan |
---|---|---|
bool | logika benar atau salah | kondisi alarm, kondisi lampu |
int | angka bulat | nomor telpon, jumlah murid |
float | angka pecahan | berat, tinggi |
char | huruf | pilihan satu huruf, satu masukan ketikan |
char[] | array of char | kalimat |
Yang agak aneh dibanding bahasa lain adalah, C tidak mengenal tipe data string ! Tapi jangan khawatir, itu bisa diatur.
Variabel
Variabel adalah sebongkah memori guna menyimpan data. Bayangkan variabel seperti “panci” penampung data, yang bisa diisi nilai data berapa saja (selama tidak penuh). Untuk menggunakan variabel, anda harus:
- Memesannya di memori
- Menentukan tipenya
- Memberinya nama
Setelah itu, anda bisa mengisinya (write) lalu membaca kembali isinya.
Konstanta
Konstanta adalah data yang nilainya tak bisa berubah selama program berjalan. Berguna untuk membuat nama bagi angka yang susah diingat. Ada tiga cara membuat konstanta, seperti contoh berikut:

/* Program Data */ // konstanta, cara 1 // pakai pragma #define #define MAX 10 // konstanta, cara 2 # pakai kata kunci const, diikuti dengan pendefinisian tipe, nama dan nilai const int MIN=0; // enumeration // khusus untuk bilangan integer, bisa mendefinisikan banyak konstanta sekaligus enum {SATU=1, DUA, TIGA}; int main() { // pesan variabel int a, b, c; a = MIN; b = MAX; c = TIGA; printf("A = %dn", a); printf("B = %dn", b); printf("C = %dn", c); printf("Ukuran integer = %dn", sizeof(a)); return 0; }
Output
Jurus kedua, output, berguna untuk menampilkan data kepada manusia. Ini penting, karena apa gunanya data di dalam memori komputer kalau tak bisa dilihat orang. Untuk output ini, tekniknya sangat tergantung pada antarmuka pemakai, apakah TUI atau GUI. Kali ini kita pakai TUI dulu.
/* * File: main.c * Author: kocil * * Created on June 19, 2010, 10:02 AM */ #include <stdio.h> #include <stdlib.h> int main() { int angka = 123; float pecahan = 456.789; char huruf = 'a'; char kata[] = "abc"; printf("Angka : %dn", angka); printf("Pecahan : %fn", pecahan); printf("Huruf : %cn", huruf); printf("Kata : %sn", kata); // pakai posisi dan lebar printf("Angka : %5dn", angka); printf("Pecahan : %5.2fn", pecahan); printf("Huruf : %10cn", huruf); printf("Kata : %-10sn", kata); }
Input
Kebalikan dari Output, Input adalah jurus untuk menerima masukan dari pemakai, dan memasukkannya ke variabel.
/* * File: main.c * Author: kocil * * Created on June 19, 2010, 10:15 AM */ #include <stdio.h> #include <stdlib.h> int main() { int angka = 123; float pecahan = 456.789; char huruf = 'a'; char kata[] = "abc"; printf("Silahkan Masukkan datan"); printf("Sebuah angka: "); scanf("%d", &angka); printf("Sebuah pecahan desimal: "); scanf("%f", &pecahan); printf("Sebuah huruf: "); huruf = getchar(); printf("Sebuah kata: "); gets(kata); printf("Ini masukan dari andan"); printf("Angka : %dn", angka); printf("Pecahan : %fn", pecahan); printf("Huruf : %cn", huruf); printf("Kata : %sn", kata); return (EXIT_SUCCESS); }
Operator
Terakhir soal data, tentunya data harus diolah. Pengolah data paling sederhana disebut operator (yang lebih rumit akan memakai fungsi). Ada banyak operator, tergantung jenis datanya. Demikian pula untuk tipe data berbeda, operator yang sama artinya bisa beda.
Sebagai contoh, kita buat program penembak meriam berikut:
#include <stdio.h> #include <stdlib.h> #include <math.h> #include <tgmath.h> /* Penembak meriam * */ int main() { const float g = 9.8; float v, alpha; float rad, vx, vy, t; float xm,ym; // baca input printf("Penembak meriamn"); printf("Kecepatan awal peluru:"); scanf("%f", &v); printf("Sudut tembak:"); scanf("%f", &alpha); // hitung memakai operator rad = alpha / 180 * M_PI; vx = v * cos(rad); vy = v * sin(rad); // mencapai maks ketika ... vy - 2 g t = 0 t = vy / (2 * g); // maksimum adalah ym = vy * t; xm = vx * 2 * t; // tulis output printf("Tinggi maksimum: %6.2fn", ym); printf("Jarak maksimum: %6.2fn", xm); return (EXIT_SUCCESS); }
Pencabangan
Kalau diperhatikan lagi contoh-contoh sebelum ini, komputer selalu menjalankan perintah-perintah secara berurut, mulai dari yang ditulis pertama hingga terakhir.
Ibarat jalan, ini artinya jalan lurus tanpa simpangan sama sekali. Nah, pencabangan adalah fitur dimana jalannya program bisa membelok ke salah satu alur, dan tak perlu melakukan alur yang lain. Sebelum membelok, komputer akan menghitung suatu kondisi untuk memilih alur. Kelihatan sederhana, banyak yang bilang kalau pencabangan adalah kunci kecerdasan komputer. Kalau tak percaya, silahkan memrogram kasus yang rumit. Pasti akan banyak pencabangannya 😉
Dalam bahasa C, ada dua konstruksi dasar pencabangan yaitu:
- If – else
- switch – case
Langsung contoh saja ya:
#include <stdio.h> #include <stdlib.h> #include <math.h> /* * Menembak sasaran */ int main() { const float g = 9.8; const float akurasi = 2; const float xtarget = 100; float v, alpha; float rad, vx, vy, t; float xm; // baca input printf("Menembak sejauh 100 m n"); printf("Kecepatan awal peluru:"); scanf("%f", &v); printf("Sudut tembak:"); scanf("%f", &alpha); // hitung memakai operator rad = alpha / 180 * M_PI; vx = v * cos(rad); vy = v * sin(rad); // mencapai maks ketika ... vy - 2 g t = 0 t = vy / (2 * g); // jarak tembak maksimum adalah xm = vx * 2 * t; printf("Jarak tembakan: %6.2fn", xm); // periksa apakah memang mengenai sasaran if ((xm > (xtarget - akurasi)) && (xm < (xtarget + akurasi))) { printf("KENA !!!n"); } else { printf("LUPUT !!!n"); } return (EXIT_SUCCESS); }
Pengulangan
Kalau pencabangan adalah kunci kecerdasan komputer, pengulangan adalah kunci kerajinan komputer. Fitur inilah yang membuat komputer mau saja mengolah berjuta-juta data tanpa mengeluh, dan selalu konsisten (benar atau salahnya).
Dalam bahasa C, ada tiga konstruksi dasar pengulangan yaitu:
- while
- do – while
- for
Mari kita lihat bagaimana aksinya:
#include <stdio.h> #include <stdlib.h> #include <math.h> #include <time.h> /* Menembak sasaran, tiga kali kesempatan * */ int main() { const float g = 9.8; const float akurasi = 2; float xtarget; float v, alpha; float rad, vx, vy, t; float xm; int ulang; // random, posisi sasaran xtarget = (time(NULL) % 100) + 10; printf("Menembak sasaran pada posisi %6.2f mn", xtarget); printf("Anda punya 3 pelurun"); // tiga kali kesempatan for (ulang=1; ulang <= 3; ulang++) { // baca input printf("Tembakan %dn", ulang); printf("Kecepatan awal:"); scanf("%f", &v); printf("Sudut tembak:"); scanf("%f", &alpha); // hitung memakai operator rad = alpha / 180 * M_PI; vx = v * cos(rad); vy = v * sin(rad); // mencapai maks ketika ... vy - g t = 0 t = vy / (g); // jarak tembak maksimum adalah xm = vx * 2 * t; printf("Jarak tembakan: %6.2fn", xm); // periksa apakah memang mengenai sasaran if ((xm > (xtarget - akurasi)) && (xm < (xtarget + akurasi))) { printf("KENA !!!n"); break; } else { printf("LUPUT !!!nn"); } } return (EXIT_SUCCESS); }
Ini aksi yang lebih banyak:
#include <stdio.h> #include <stdlib.h> #include <math.h> /* Pengulangan menghitung trayektori peluru * */ int main() { const float g = 9.8; float v, alpha; float rad, vx, vy, t, dt; float x, y; // baca input printf("Trayektori Tembakann"); printf("Kecepatan awal peluru:"); scanf("%f", &v); printf("Sudut tembak:"); scanf("%f", &alpha); // hitung memakai operator rad = alpha / 180 * M_PI; vx = v * cos(rad); vy = v * sin(rad); dt = ceil(vy / (g)) / 10; x = y = 0; t = 0; printf("Waktu X Yn"); printf("%6.3f %6.2f %6.2fn", t, x, y); do { t = t + dt; x = vx * t; y = (vy * t) - (g * t * t / 2); printf("%6.3f %6.2f %6.2fn", t, x, y); } while (y > 0.0); return (EXIT_SUCCESS); }
Subrutin
Jurus ketujuh, adalah jurus yang memungkinkan kita menulis program secara modular. Intinya, bagian program yang kita anggap ‘satu kesatuan’ kita kumpulkan menjadi satu fungsi. Fungsi tersebut dapat menerima masukan (disebut parameter) dan memberikan luaran (disebut return value). Dengan demikian program kita:
- Lebih mudah dibaca
- Lebih singkat ditulis
Contohnya nih:
#include <stdio.h> #include <stdlib.h> #include <math.h> // konstanta gravitasi global const float g = 9.8; /* fungsi menghitung jarak X */ float jarakX(float v, float a, float t) { float vx; vx = v * cos(a / 180 * M_PI); return vx * t; } /* fungsi menghitung jarak Y */ float jarakY(float v, float a, float t) { float vy; vy = v * sin(a / 180 * M_PI); return (vy * t) + (g / 2 * t * t ); } /* menghitung trayektori peluru * */ int main() { float v, alpha; float t, dt; float x, y; // baca input printf("Trayektori Tembakann"); printf("Kecepatan awal peluru:"); scanf("%f", &v); printf("Sudut tembak:"); scanf("%f", &alpha); t = 0; dt = 0.1; printf("Waktu X Yn"); do { x = jarakX(v, alpha, t); y = jarakY(v, alpha, t); printf("%6.3f %6.2f %6.2fn", t, x, y); t = t + dt; } while (y > 0.0); return (EXIT_SUCCESS); }
Penggunaan lebih maju dari subrutin, kita dapat membedakan variabel sebagai variabel global atau lokal. Ini bisa membuat program lebih mudah diikuti, atau lebih cepat.
#include <stdio.h> #include <stdlib.h> #include <math.h> // konstanta gravitasi global const float g = 9.8; // variabel global float vx, vy; /* mulai tembak */ void mulaiTembak(float v, float a) { vx = v * cos(a / 180 * M_PI); vy = v * sin(a / 180 * M_PI); } /* fungsi menghitung jarak X */ float jarakX(float t) { return vx * t; } /* fungsi menghitung jarak Y */ float jarakY(float t) { return (vy * t) - (g / 2 * t * t ); } /* menghitung trayektori peluru * */ int main() { float v, alpha; float t, dt; float x, y; // baca input printf("Trayektori Tembakann"); printf("Kecepatan awal peluru:"); scanf("%f", &v); printf("Sudut tembak:"); scanf("%f", &alpha); t = 0; dt = 0.1; mulaiTembak(v, alpha); printf("Waktu X Yn"); do { x = jarakX(t); y = jarakY(t); printf("%6.3f %6.2f %6.2fn", t, x, y); t = t + dt; } while (y >= 0.0); return (EXIT_SUCCESS); }
Structure
Kini kita masuk ke jurus tingkat lanjut. Struktur (atau record) adalah fitur untuk membuat struktur data, dimana beberapa data disatukan. Ini akan sangat menolong dalam memahami persoalan, maupun pemrograman.
#include <stdio.h> #include <stdlib.h> #include <math.h> // konstanta gravitasi global const float g = 9.8; typedef struct { float x, y; } data_xy; // variabel global data_xy velocity; /* mulai tembak */ void mulaiTembak(float v, float a) { velocity.x = v * cos(a / 180 * M_PI); velocity.y = v * sin(a / 180 * M_PI); } /* fungsi menghitung jarak */ data_xy jarak(float t) { data_xy s; s.x = velocity.x * t; s.y = (velocity.y * t) - (g / 2 * t * t ); return s; } /* menghitung trayektori peluru * pakai struktur data */ int main() { float v, alpha; float t, dt; data_xy j; // baca input printf("Trayektori Tembakann"); printf("Kecepatan awal peluru:"); scanf("%f", &v); printf("Sudut tembak:"); scanf("%f", &alpha); t = 0; dt = 0.1; mulaiTembak(v, alpha); printf("Waktu X Yn"); do { j = jarak(t); printf("%6.3f %6.2f %6.2fn", t, j.x, j.y); t = t + dt; } while (j.y >= 0.0); return (EXIT_SUCCESS); }
Pemrograman
Sekian artikel Tutorial Pemrograman C yang sudah anda baca sampai habis, di situs KepoWin.
Semoga ulasan Belajar Pemrograman C, Panduan Pemrograman C Untuk Pemula, dan PDF Pemrograman C bisa bermanfaat dan terimakasih sudah berkunjung
jika ada waktu silahkan share di media sosial Whatsapp, Twtitter, Instagram, Telegram, TikTok, Facebook dan lainnya.
tutorial bahasa pemrograman c untuk pemula,tutorial pemrograman bahasa c,tutorial pemrograman c++,tutorial membuat program c++,tutorial bahasa pemrograman c++ pdf,tutorial belajar bahasa pemrograman c++,cara membuat program c++ di visual studio,cara membuat program c++ di android,belajar bahasa pemrograman c untuk pemula,tutorial program c++,cara membuat program c++ menghitung luas persegi panjang