Tutorial Melayu

ZTE MF627 USB modem driver untuk Win 7

Firmware yang dibekalkan dengan modem ZTE MF627 (anda boleh rujuk nombor ini di badan modem anda) untuk Celcom broadband hanya boleh diinstall di Windows XP atau Vista. Jika anda menggunakan Win 7, masalah yang mungkin timbul adalah firmware tersebut tidak akan mengenalpasti simcard anda.

Untuk mengatasi masalah ini, anda perlu menggunakan driver yang lebih terkini (anda masih boleh menggunakan firmware yang sama).

http://mymobile.three.co.uk:8080/downloads/MF627_Windows_7DriverSetup.exe

Jika anda mendapat error 123 ketika proses sambungan (connect), pastikan dalam Setting bahawa anda mempunyai sekurang-kurangnya satu fail konfigurasi. Hanya isi ruangan nombor panggilan. Anda boleh gunakan *99***2# .

kredit RM100 Percuma untuk akaun Adwords

Untuk mendapatkan kredit percuma bernilai RM100 untuk pemasaran produk anda menggunakan Google Adwords, sila daftar dengan menggunakan link berikut.

https://services.google.com/fb/forms/admye100/?utm_source=RMKT

Ianya hanya sah untuk akaun yang berumur kurang dari 14 hari.

P/s : Jika sesiapa yang ada link untuk $100 Adwords, sila tinggalkan link di ruangan komen. terima kasih.

Linked list dalam C

Salah satu jenis struktur data adalah linked list. Dalam bahasa melayunya, linked list adalah data yang bersambungan antara satu sama lain. Setiap elemen linked list dipanggil node. Manakala setiap node terbahagi kepada dua bahagian iaitu bahagian data yang akan menyimpan data dan bahagian sambungan (link) yang berfungsi sebagai penyambung elemen-elemen di dalam linked list ini.

Di dalam bahagian sambungan, biasanya ia terdiri dari hanya satu pembolehubah pointer yang akan merujuk kepada address (lokasi) node seterusnya. Linked list ini dipanggil single-linked linked list. Untuk double-linked linked list, terdapat dua pointer, di mana satu merujuk kepada address node seterusnya dan satu lagi merujuk kepada address node sebelumnya. Rujuk artikel ini untuk pemahaman berkenaan pointer.

Node biasanya adalah struktur C untuk menyimpan lebih daripada satu jenis pemboleh ubah (rujuk artikel ini). Salah satu contoh mudah sebuah node adalah:

struct tnode { 
  int data; 
  struct tnode *next; 
};

Di mana data merujuk kepada bahagian data dan next merujuk kepada bahagian link. Jadi dengan ini kita boleh bayangkan yang kita membuat satu linked list dengan 3 node seperti contoh di bawah.

#include <stdio.h>
#include <stdlib.h>

struct tnode { 
  int data; 
  struct tnode *next; 
};
 
int main(int argc, char *argv[])
{
  struct tnode *node = (struct tnode *)malloc(sizeof(struct tnode));
 
  // menyambung node
  node->data = 100;
  node->next = (struct tnode *)malloc(sizeof(struct tnode));
 
  printf("Data node1 %d \n", node->data);
  printf("Link node1 %p \n", node->next);
  printf("Lokasi node1 %p \n\n", node);
 
  node->next->data = 200;
  node->next->next = (struct tnode *)malloc(sizeof(struct tnode));
 
  printf("Data node2 %d \n", node->next->data);
  printf("Link node2 %p \n", node->next->next);
  printf("Lokasi node2 %p \n\n", node->next);
 
  node->next->next->data = 300;
  node->next->next->next = NULL;
 
  printf("Data node3 %d \n", node->next->next->data);
  printf("Link node3 %p \n", node->next->next->next);
  printf("Lokasi node3 %p \n\n", node->next->next);
 
  system("PAUSE");	
  return 0;
}

Seperti yang boleh digambarkan seperti di bawah.

Berikut adalah hasil output kod di atas setelah dijalankan menggunakan Dev-C++.

Jadi setelah melihat bagaimana linked list berfungsi, mari kita lihat bagaimana membina satu program linked list yang lengkap. Dalam program linked list, saya membayangkan beberapa fungsi yang boleh membantu kita memanipulasi linked list yang dihasilkan.

Membina node baru
Fungsi ini bertujuan untuk memperuntukkan (allocate) ruang memori untuk node baru dan memasukkan data ke dalamnya.

struct tnode * createnode(int data){
    struct tnode * node;
    node = (struct tnode *)malloc(sizeof(struct tnode));
    node->next = NULL;
    node->data = data;
    return node;       
}

Menambah node
Fungsi ini akan menggunakan fungsi createnode di atas dan kemudiannya memasukkan node tersebut ke dalam linked list yang sedia ada di posisi yang diberi.

void tambahnode(int data, int pos)
{
    int i;
    struct tnode *temp, *prev, *current;
 
    current = head;
 
    if(pos > (length()+1) || pos <= 0){
           printf("Posisi tidak sah.\n ");
    }
    else {
         if (pos == 1){
            temp = createnode(data);
            temp->next = head;
            head = temp;
         }
         else{
            for(i=1;i<pos;i++){
                prev = current;
                current = current->next;
            }
 
            temp = createnode(data);
            prev->next = temp;
            temp->next = current;
        }
    }
}

Memaparkan data node
Fungsi ini digunakan untuk memaparkan kesemua data yang terkandung di dalam node-node yang ada.

void paparnode(void){
     struct tnode * current = head;
 
     while(current != NULL) {
          printf("Data node %d \n", current->data);
          printf("Link node %p \n", current->next);
          printf("Lokasi node %p \n\n", current);
          current = current->next;
     }     
}

Mengira jumlah node
Fungsi ini bertujuan untuk memberikan jumlah node yang berada di dalam linked list.

int length(void) {
    struct tnode* current = head;
    int count = 0;
 
    while (current != NULL) {
          count++;
          current = current->next;
    }
    return count;
}

Membuang node
Fungsi ini bertujuan untuk membuang node di posisi yang ditetapkan.

void deletenode(int pos){
     struct tnode * current = head;
     struct tnode * prev;
     int i;
 
     if(pos > (length()) || pos <= 0){
            printf("Posisi tidak sah.\n");
     } 
     else {
          if(pos == 1){
              head = current->next;
              free(current);     
          } 
          else{
               for(i=1; i<pos; i++) {
                   prev = current;
                   current = current->next;
               }      
               prev->next = current->next;
               free(current);
          }
     }    
}

Jika kita gabungkan kesemua fungsi-fungsi di atas, kita sudahpun mempunyai satu program linked list yang lengkap.

#include <stdio.h>
#include <stdlib.h>

struct tnode { 
    int data; 
    struct tnode *next; 
} *head;
 
struct tnode * createnode(int data){
    struct tnode * node;
    node = (struct tnode *)malloc(sizeof(struct tnode));
    node->next = NULL;
    node->data = data;
    return node;       
}
 
void tambahnode(int data, int pos)
{
    int i;
    struct tnode *temp, *prev, *current;
 
    current = head;
 
    if(pos > (length()+1) || pos <= 0){
           printf("Posisi tidak sah.\n ");
    }
    else {
         if (pos == 1){
            temp = createnode(data);
            temp->next = head;
            head = temp;
         }
         else{
            for(i=1;i<pos;i++){
                prev = current;
                current = current->next;
            }
 
            temp = createnode(data);
            prev->next = temp;
            temp->next = current;
        }
    }
 }
 
void paparnode(void){
     struct tnode * current = head;
     printf("*****************************\n");
     while(current != NULL) {
          printf("Data node %d \n", current->data);
          printf("Link node %p \n", current->next);
          printf("Lokasi node %p \n\n", current);
          current = current->next;
     }     
}
 
int length(void) {
    struct tnode* current = head;
    int count = 0;
    while (current != NULL) {
          count++;
          current = current->next;
    }
    return count;
}
 
void deletenode(int pos){
     struct tnode * current = head;
     struct tnode * prev;
     int i;
 
     if(pos > (length()) || pos <= 0){
            printf("Posisi tidak sah.\n");
     } 
     else {
          if(pos == 1){
              head = current->next;
              free(current);     
          } 
          else{
               for(i=1; i<pos; i++) {
                   prev = current;
                   current = current->next;
               }      
               prev->next = current->next;
               free(current);
          }
     }    
}
 
int main(int argc, char *argv[])
{
    head = NULL;   
 
    tambahnode(100, 1);
    tambahnode(200, 1);
    tambahnode(300, 1);
    tambahnode(400, length() + 1);
 
    paparnode();
    deletenode(3);
    paparnode();
 
    system("PAUSE");	
    return 0;
}

Struktur Data (data structure)

Dalam dunia sains komputer, struktur data adalah satu cara untuk menyimpan dan mengurus data supaya ianya boleh digunakan dengan efisien. Terdapat pelbagai struktur data yang biasa digunakan seperti linked-list, hash tables, tree dan queue.

Untuk sesebuah struktur data, kita memerlukan beberapa fungsi seperti fungsi masuk, fungsi padam yang akan membenarkan kita untuk membina dan memanipulasi struktur data tersebut.

Pointer dalam C

Terdapat satu pembolehubah khas yang dinamakan pointer yang digunakan secara meluas dalam C. Pelajar yang mempelajari C biasanya mempunyai masalah dengan pointer kerana dikatakan susah difahami. Saya akan cuba mengatasi masalah ini dengan menggunakan pendekatan yang berlainan dengan menggunakan gambarajah.

Jika kita lihat analogi pembolehubah di artikel ini, ia juga boleh diaplikasikan di sini tapi bezanya, pointer hanya boleh menyimpan lokasi pembolehubah lain.

Untuk lebih memahami pointer, kita boleh lihat contoh di bawah di mana kita mempunyai satu pembolehubah dan satu pointer. Kita akan menganggap lokasi memori untuk pembolehubah harga adalah 0×3333 manakala lokasi pointer ptr adalah 0×1234.

int harga = 500;
int * ptr = &harga;

int harga = 500 akan menghasilkan kotak bernama harga yang mengandungi angka 500. Manakala int * ptr akan menghasilkan pointer yang mengandungi lokasi pembolehubah harga (&harga merujuk kepada lokasi harga). Jika lokasi harga adalah 0×3333, jadi 0×3333 lah yang akan terkandung di dalam kotak ptr seperti gambarajah di atas.

Memandangkan kotak ptr mengandungi lokasi kotak harga, bagaimana jika kita mahu menukar nilai harga dengan menggunakan pembolehubah pointer ptr? Jawapannya adalah dengan menggunakan *ptr. *ptr merujuk kepada nilai di dalam kotak yang dirujuk oleh kotak ptr. Jadi dalam kes di atas, *ptr merujuk kepada nilai 500 di dalam kotak harga.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  int harga = 500;
  int * ptr = &harga;
 
  printf("Harga %d \n", harga);
  printf("Harga %d \n", *ptr);
 
  harga = 600;
 
  printf("Harga %d \n", harga);
  printf("Harga %d \n", *ptr);
 
  *ptr = 700;
 
  printf("Harga %d \n", harga);
  printf("Harga %d \n", *ptr);
 
  system("PAUSE");	
  return 0;
}

Harga 500
Harga 500
Harga 600
Harga 600
Harga 700
Harga 700

Kita boleh membayangkan situasi yang sedikit kompleks seperti di bawah:

int a = 100;
int b = 200;
int *c = &a;
int **d = &c;

Yang boleh digambarkan seperti berikut:

di mana nilai a adalah 100, nilai b adalah 200, nilai c adalah lokasi a iaitu 0×0000 dan nilai d adalah lokasi c iaitu 0×0008. Seperti yang diterangkan di atas, *c bermaksud nilai di dalam kotak a iaitu 100 dan *d bermaksud nilai di dalam kotak c iaitu 0×0000. Jadi bolehkah kita akses nilai di dalam kotak a dengan menggunakan pointer d? Jawapannya boleh dengan bantuan **d.

Struktur (structure) dalam C

Struktur digunakan untuk menyimpan pelbagai pembolehubah dalam satu pembolehubah. Sebagai contoh jika kita mahu menyimpan nama dan umur pekerja dalam hanya satu pembolehubah seperti contoh di bawah. Kita boleh mengakes pembolehubah-pembolehubah di dalam pembolehubah struktur ini dengan menggunakan “.”.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct pekerja {
  char nama[20];
  int umur;     
  int gaji;  
};
 
int main(int argc, char *argv[])
{
  struct pekerja pekerja1;
 
  strcpy(pekerja1.nama, "Karim");
  pekerja1.umur = 23;
  pekerja1.gaji = 5000;
 
  printf("Pekerja bernama %s berumur %d tahun mempunyai gaji sebanyak RM%d\n", 
    pekerja1.nama, pekerja1.umur, pekerja1.gaji);
 
  system("PAUSE");	
  return 0;
}

Dalam tutorial pembolehubah (rujuk di sini), saya ada menceritakan tentang analogi kotak. Ia masih boleh diaplikasi dalam kes ini di mana anda boleh menganggap pembolehubah struktur ini adalah sebuah kotak yang besar yang mengandungi beberapa kotak yang lain.

Kod di atas boleh digantikan dengan kod di bawah yang bagi saya lebih senang digunakan.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct pekerja {
  char nama[20];
  int umur;     
  int gaji;  
} pekerja_t;
 
int main(int argc, char *argv[])
{
  pekerja_t pekerja1;
 
  strcpy(pekerja1.nama, "Karim");
  pekerja1.umur = 23;
  pekerja1.gaji = 5000;
 
  printf("Pekerja bernama %s berumur %d tahun mempunyai gaji sebanyak RM%d\n", 
    pekerja1.nama, pekerja1.umur, pekerja1.gaji);
 
  system("PAUSE");	
  return 0;
}

Pointer kepada struktur

Sepertimana pembolehubah lain, kita juga mempunyai pointer struktur.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct pekerja {
  char nama[20];
  int umur;     
  int gaji;  
} pekerja_t;
 
int main(int argc, char *argv[])
{
  pekerja_t pekerja1;
  pekerja_t * ptr = &pekerja1;
 
  strcpy(pekerja1.nama, "Karim");
  pekerja1.umur = 23;
  pekerja1.gaji = 5000;
 
  printf("Pekerja bernama %s berumur %d tahun mempunyai gaji sebanyak RM%d\n", 
    pekerja1.nama, pekerja1.umur, pekerja1.gaji);
 
  printf("Pekerja bernama %s berumur %d tahun mempunyai gaji sebanyak RM%d\n", 
   (*ptr).nama, (*ptr).umur, (*ptr).gaji);
 
  printf("Pekerja bernama %s berumur %d tahun mempunyai gaji sebanyak RM%d\n", 
    ptr->nama, ptr->umur, ptr->gaji);
 
  system("PAUSE");	
  return 0;
}

Kita mempunyai dua cara untuk mengakses data dari pointer struktur iaitu samada menggunakan (*ptr).nama ataupun dengan cara yang lebih mudah ptr->nama.

Pembolehubah (variable) dalam C

Dalam C, pembolehubah adalah sebuah lokasi blok memori yang boleh diberikan nama (atau identifier) dan juga boleh diberikan nilai. Jika kita mahu menerangkannya secara ringkas, kita boleh umpamakan ia sebagai sebuah kotak.

Jadi jika kita menambah satu pembolehubah seperti berikut:

int jumlah_harga = 100

Dalam analogi kotak saya tadi, kita akan mendapat kotak berikut:

Satu lagi contoh, kali ini dengan 3 pembolehubah.

int proses;
int bilangan = 0;
int jumlah_harga = 100;

Lokasi kotak-kotak ini di dalam memori bukanlah ditentukan oleh kita tetapi oleh unit memori sistem tersebut. Dan lokasi ini tidak dijanjikan sama setiap kali anda menjalankan program anda.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  int proses;
  int bilangan = 0;
  int jumlah_harga = 100;
 
  printf("lokasi variable proses -> %p \n", &proses);
 
  printf("nilai variable bilangan -> %d \n", bilangan);
  printf("lokasi variable bilangan -> %p \n", &bilangan);
 
  printf("nilai variable jumlah_harga -> %d \n", jumlah_harga);
  printf("lokasi variable jumlah_harga -> %p \n", &jumlah_harga);
 
  system("PAUSE");	
  return 0;
}

———————————————————————-

Jenis-jenis pembolehubah
Terdapat beberapa jenis pembolehubah yang perlu kita ketahui.

• char
• int
• float
• double

Mereka berbeza dari segi nilai yang boleh dimasukkan ke dalam ruang memori pembolehubah tersebut. Sebagai contoh jenis char hanya bersaiz satu byte di mana ia hanya boleh menyimpan angka -128 hingga 127 sahaja. Dalam analogi kotak yang saya perkenalkan di atas, kita boleh menganggap terdapat pelbagai kotak dengan saiz yang berlainan.

Jadi jika kita menyimpan angka 129 di dalam pembolehubah berjenis char, ia akan menyimpan -127 dan bukan 129.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  char c = 129;
 
  printf("nilai pembolehubah c %d \n", c);
 
  system("PAUSE");	
  return 0;
}

nilai pembolehubah c -127

Bermula dengan C : Hello World

Untuk bermula dengan C, saya mencadangkan Dev-C++ (Muat turun di sini). Ianya sebuah editor yang sudah dilengkapi dengan compiler minGW. Jadi anda hanya perlu muat turun dan install untuk membolehkan anda bermula dengan C.

Kita mulakan dengan membina projek C baru dengan Dev-C++ seperti ditunjukkan di bawah:

Masukkan kod hello world di bawah dan simpan sebagai main.c :

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  printf("Hello World \n");
  system("PAUSE");	
  return 0;
}

Untuk compile & run, tekan F9 atau pada menu, Execute -> Compile & Run. Sebuah tetingkap akan muncul seperti di bawah yang memaparkan mesej Hello World anda.

Penting diingatkan bahawa semua program C hendaklah mempunyai fungsi main. Paling minimum adalah seperti berikut:

int main(void){
 
  return 0;
}

Untuk memaparkan output di dalam tetingkap DOS, kita menggunakan fungsi printf.

printf("Hello World \n");

Apa itu CRUD?

Di dalam dunia pangkalan data, CRUD atau Create Read Update Delete adalah 4 fungsi utama yang diimplementasi dan dianggap mencukupi untuk sesebuah aplikasi.

Create Memasukkan (row) data baru ke dalam pangkalan data
Read mendapatkan maklumat daripada pangkalan data
Update Mengubah nilai di dalam pangkalan data
Delete Memadam data dari pangkalan data

Tanpa salah satu dari 4 fungsi ini, satu-satu aplikasi itu tidak akan dianggap sempurna kerana mereka adalah asas kepada interaksi dengan pangkalan data.

Memadam data dari pangkalan data

Proses untuk memadam data dari pangkalan data hampir sama dengan proses pengubahsuaian nilai dalam tutorial yang lepas di mana kita memerlukan kata kunci WHERE untuk memberitahu MySQL data mana yang perlu dibuang.

<?php
mysql_connect("localhost", "mdpai", "mdpai123") or die(mysql_error());
mysql_select_db("tutorial") or die(mysql_error());
 
mysql_query("DELETE FROM pekerja WHERE nama='Karim'") or die(mysql_error());  
?>

Dalam contoh di atas, kita membuang pekerja bernama Karim dari pangkalan data.