Tutorial Pemrograman C

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 world\n");
   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:

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 = %d\n", a);
  printf("B = %d\n", b);
  printf("C = %d\n", c);
 
  printf("Ukuran integer = %d\n", 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 : %d\n", angka);
    printf("Pecahan : %f\n", pecahan);
    printf("Huruf : %c\n", huruf);
    printf("Kata : %s\n", kata);
 
    // pakai posisi dan lebar
    printf("Angka : %5d\n", angka);
    printf("Pecahan : %5.2f\n", pecahan);
    printf("Huruf : %10c\n", huruf);
    printf("Kata : %-10s\n", 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 data\n");
    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 anda\n");
    printf("Angka : %d\n", angka);
    printf("Pecahan : %f\n", pecahan);
    printf("Huruf : %c\n", huruf);
    printf("Kata : %s\n", 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 meriam\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);
 
    // maksimum adalah
    ym = vy * t;
    xm = vx * 2 * t;
 
    // tulis output
    printf("Tinggi maksimum: %6.2f\n", ym);
    printf("Jarak maksimum: %6.2f\n", 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.2f\n", 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 m\n", xtarget);
    printf("Anda punya 3 peluru\n");
 
    // tiga kali kesempatan
    for (ulang=1; ulang <= 3; ulang++) {
        // baca input
        printf("Tembakan %d\n", 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.2f\n", xm);
 
        // periksa apakah memang mengenai sasaran
        if ((xm > (xtarget - akurasi)) && (xm < (xtarget + akurasi))) {
            printf("KENA !!!\n");
            break;
        }
        else {
            printf("LUPUT !!!\n\n");
        }
    }
    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 Tembakan\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);
    dt = ceil(vy / (g)) / 10;
 
    x = y = 0;
    t = 0;
    printf("Waktu     X      Y\n");
    printf("%6.3f %6.2f %6.2f\n", t, x, y);
    do {
        t = t + dt;
        x = vx * t;
        y = (vy * t) - (g * t * t / 2);
        printf("%6.3f %6.2f %6.2f\n", 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 Tembakan\n");
    printf("Kecepatan awal peluru:");
    scanf("%f", &v);
    printf("Sudut tembak:");
    scanf("%f", &alpha);
 
    t = 0;
    dt = 0.1;
    printf("Waktu     X      Y\n");
    do {
        x = jarakX(v, alpha, t);
        y = jarakY(v, alpha, t);
        printf("%6.3f %6.2f %6.2f\n", 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 Tembakan\n");
    printf("Kecepatan awal peluru:");
    scanf("%f", &v);
    printf("Sudut tembak:");
    scanf("%f", &alpha);
 
    t = 0;
    dt = 0.1;
    mulaiTembak(v, alpha);
    printf("Waktu     X      Y\n");
    do {
        x = jarakX(t);
        y = jarakY(t);
        printf("%6.3f %6.2f %6.2f\n", 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 Tembakan\n");
    printf("Kecepatan awal peluru:");
    scanf("%f", &v);
    printf("Sudut tembak:");
    scanf("%f", &alpha);
 
    t = 0;
    dt = 0.1;
    mulaiTembak(v, alpha);
    printf("Waktu     X      Y\n");
    do {
        j = jarak(t);
        printf("%6.3f %6.2f %6.2f\n", 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