Cara biar banyak yang add di facebook

Question

Variabel

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

0 alamat memorinya adalah

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

3, sedangkan

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

1 alamat memorinya

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

5.

Table of Contents Show

Cara Membuat Pointer
Latihan: Mengakses data dengan Pointer
Kapan Saya Harus Pakai Pointer?
Latihan: Pointer untuk Pass by Reference pada Fungsi
Latihan: Pointer untuk Mengakses Data pada Array
Latihan: Pointer untuk Mengkases Data pada Struct
Apa Selanjutnya?

Selama sebuah alamat masih kosong.. maka alamat itu yang akan dipilih.

Oya, pemilihan alamat memori ini, dilakukan secara acak. Inilah mengapa memori ini di sebut RAM (Random Access Memory).

Intinya, setiap kita membuat variabel pasti akan punya alamat memori.

Kalau tidak percaya, kamu bisa buktikan sendiri dengan menggunakan simbol

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

6 (ampersand).

Contoh:

#include <stdio.h>

void main () {

   int  a;
   char b[10];

   printf("Alamat memori variabel a: %x\n", &a);
   printf("Alamat memori variabel b: %x\n", &b);

}

Pada program ini, kita menggunakan simbol

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

6 untuk mengambil alamat memori dari variabel

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

8 dan

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

9.

Lalu menggunakan format specifier

*ptr_hp = 95;

0 untuk menampilkannya dalam bilangan heksadesimal.

Hasilnya:

Lalu apa hubungannya alamat memori dengan pointer?

Mari kita bahas…

Pointer adalah sebuah variabel khusus yang berisi alamat memori. Pointer nantinya akan bisa mengakses data yang ada di suatu alamat memori.1

Kata kunci yang perlu kamu ingat:

“Pointer berisi alamat memori”

Cara Membuat Pointer

Pointer dibuat dengan menambahkan simbol

*ptr_hp = 95;

1 (asterik) di depan namanya, kemudian diisi dengan alamat memori yang akan digunakan sebagai referensi.

Contoh:

int *pointer1 = 00001;

Maka

*ptr_hp = 95;

2 akan bisa mengakses data yang ada pada alamat memori

*ptr_hp = 95;

3. Dengan kata lain, si

*ptr_hp = 95;

2 akan menggunakan alamat

*ptr_hp = 95;

3 sebagai referensinya.

Kita juga bisa membuat pointer tanpa harus mengisinya langsung dengan alamat memori.

Contoh:

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

Maka

*ptr_hp = 95;

6 akan menggunakan alamat memori

*ptr_hp = 95;

7, alamat memori ini khusus untuk menyimpan data

*ptr_hp = 95;

8 atau data kosong.

Sekarang masalahnya:

Karena kita tidak bisa lihat daftar alamat memori secara langsung, kita akan kesulitan memberikan referensi alamat memori untuk pointer.

Belum lagi.. beda komputer beda juga alamat memorinya. Ada yang 8 bit, ada juga yang 16, 32, dan sebagainya.

Solusinya:

Kita harus mengambil alamat memori dari variabel yang lain.

Masih ingat caranya?

Ya, dengan menggunakan simbol

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

6.

Coba perhatikan gambar ini:

Pada gambar ini, kita membuat pointer dengan nama

#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}

0 dengan isi alamat memori dari variabel

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

1.

Dengan begini..

Pointer

#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}

2 akan bisa mengakses nilai pada alamat memori

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

5 yang mana ini adalah alamat memori dari variabel

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

1.

Jika kita ingin mengubah nilai pada alamat memori tersebut, maka kita bisa gunakan pointer

#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}

2 seperti ini:

*ptr_hp = 95;

Maka, sekarang alamat memori

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

5 akan berisi

#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}

7 begitu juga dengan variabel

int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;

1.

Biar lebih jelas, mari kita coba latihan dalam program.

Latihan: Mengakses data dengan Pointer

Buatlah program baru dengan nama

#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}

9, kemudian isi dengan kode berikut:

#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}

Setelah itu, coba compile dan jalankan.

Maka hasil:

Pointer

<                      ptr

1 span>#include <stdio.h> void main(){ int score = 50; int hp = 100; // membuat pointer dengan isi alamat memori dari hp int *ptr_hp = &hp; // print isi variabel dan alama memori printf("Nama Variabel \t Alamat \t Konten\n"); printf("score \t\t %x \t %d \n", &score, score); printf("hp \t\t %x \t %d \n", &hp, hp); printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp); printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp); // mengubah data pada alamat memori dengan pointer *ptr_hp = 95; printf("hp \t\t %x \t %d \n", &hp, hp); printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp); }2 berhasil mengubah nilai pada alamat

*ptr // ini akan berisi 95 (nilai dari alamat) // ini akan berisi d57ba6c (alamat memori dari variabel hp) menjadi #include <stdio.h> void main(){ int score = 50; int hp = 100; // membuat pointer dengan isi alamat memori dari hp int *ptr_hp = &hp; // print isi variabel dan alama memori printf("Nama Variabel \t Alamat \t Konten\n"); printf("score \t\t %x \t %d \n", &score, score); printf("hp \t\t %x \t %d \n", &hp, hp); printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp); printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp); // mengubah data pada alamat memori dengan pointer *ptr_hp = 95; printf("hp \t\t %x \t %d \n", &hp, hp); printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp); }
7.
Saat menggunakan pointer, kita menggunakan tanda 
*ptr_hp = 95;
1 di depan nama pointer untuk mengakses nilai pada alamat memori. Jika tidak menggunakan tanda ini, maka kita akan mendapatkan alamat memori yang di-pointing.
*ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
Oh iya, pointer juga punya alamat memorinya sendiri.
Pada contoh di atas, alamat memori dari pointer 
#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}
2 adalah *ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
5. Mungkin di komputermu akan berbeda, silahkan di cek sendiri.
Jika kamu perhatikan gambar ini:
Alamat memori yang dipakai 
#include <stdio.h>

void main(){
    int score = 50;
    int hp = 100;

    // membuat pointer dengan isi alamat memori dari hp
    int *ptr_hp = &hp;

    // print isi variabel dan alama memori
    printf("Nama Variabel \t Alamat \t Konten\n");
    printf("score \t\t %x \t %d \n", &score, score);
    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("ptr_hp \t %x \t %x \n", &ptr_hp, ptr_hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);

    // mengubah data pada alamat memori dengan pointer
    *ptr_hp = 95;

    printf("hp \t\t %x \t %d \n", &hp, hp);
    printf("*ptr_hp \t %x \t %d \n", &ptr_hp, *ptr_hp);
}
2 adalah *ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
7 dengan isi alamat memori int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;
5.
Sapai di sini sudah paham?
Sekarang pertanyaanya:
Kalau kita menggunakan pointer, bukankah ini akan boros memori? Krena kita harus mengalokasikan alamat memori untuk si pointernya juga.
Jika kita bisa menggunakan variabel biasa, ngapain pakai pointer?
Penggunaan pointer sebenarnya opsional, kamu boleh pakai.. boleh juga tidak.
Namun..
Pada kondisi tertentu, penggunaan pointer lebih optimal.
Nanti kita akan bahas ini lagi.



Kapan Saya Harus Pakai Pointer?
Seperti yang saya katakan tadi, kita tidak harus selalu menggunakan pointer dalam program.
Namun, ada beberapa kasus tertentu yang menyarankan menggunakan pointer daripada cara biasa.
Biar jelas..
Kita bahas dulu, mengapa pointer diciptakan?
Jadi zaman dulu, memori komputer itu sangat terbatas. Tidak seperti sekarang yang kapasitasnya sampai giga-gigaan.
Saat kita melakukan operasi iterasi pada tipe data seperti array, string, tree, linked list, graph, dan sebagainya.. sering kali memakan banyak memori dan membuat programnya lambat.
Penggunaan Pointer pada operasi semacam akan meningkatkan performa secara signifikan dibandingkan tanpa menggunakan pointer. 1
Latihan: Pointer untuk Pass by Reference pada Fungsi
Petama kita akan coba menggunakan pointer untuk melakukan passing argumen berdasaran referensinya (pass by reference).
Contoh:
#include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
Pada program ini, kita membuat fungsi dengan nama 
*ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
9 untuk menambahkan nilai score sebanyak #include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
0.
Tapi ketika dijalankan:
Nilai variabel score tidak berubah, ia tetap bernilai 
#include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
1.
Mengapa?
Ini karena kita melakukan pass by value, bukan pass by reference.
Variabel 
int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;
0 kan dibuat di dalam fungsi #include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
3, lalu ketika fungsi *ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
9 mencoba mengubah nilainya..
…maka perubahan hanya terjadi secara lokal di dalam fungsi 
*ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
9 saja.
Nggak percaya?
Coba buktikan dengan mengubah fungsi 
*ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
9 menjadi seperti ini:
#include <stdio.h>

void add_score(int score){
    score = score + 5;
    printf("Score dibuah ke %d\n", score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
Hasilnya:
Benar kan yang saya katakan..
Nilai 
int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;
0 pada fungsi *ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
9 sudah berubah menjadi #include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
0, namun variabel int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;
0 pada fungsi #include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
3 akan tetap bernilai #include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
1.
Nah..
Di sinilah kita harus menggunakan pointer untuk melakukan pass-by-reference.
Sekarang, coba ubah kode programnya menjadi seperti ini:
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
Karena argumen fugsi 
*ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
9 kita ubah menjadi pointer, maka kita harus memberikan alamat memori saat memanggilnya.
Maka hasilnya:



Setiap fungsi 
*ptr // ini akan berisi 95 (nilai dari alamat)
ptr // ini akan berisi d57ba6c (alamat memori dari variabel hp)
9 dipanggil atau dieksekusi, maka nilai variabel int *pointer_ku;

// atau bisa juga

int *pointer_ku = NULL;
0 akan bertambah #include <stdio.h>

void add_score(int score){
    score = score + 5;
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
0.
Coba kita ubah menjadi seperti ini:
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
Hasilnya:
Latihan: Pointer untuk Mengakses Data pada Array
Pointer juga sering digunakan untuk mengakses data pada array.
Contoh: 
#include <stdio.h>

void add_score(int score){
    score = score + 5;
    printf("Score dibuah ke %d\n", score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
7
int *pointer1 = 00001;
0
Pada program ini, kita menggunakan 
#include <stdio.h>

void add_score(int score){
    score = score + 5;
    printf("Score dibuah ke %d\n", score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
8 untuk mengakses elemen array. Saat pertama kali dibuat, pointer #include <stdio.h>

void add_score(int score){
    score = score + 5;
    printf("Score dibuah ke %d\n", score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(score);
    printf("score setelah diubah: %d\n", score);
}
8 akan mereferensi pada elemen pertama array.
Lalu pada perulangan dilakukan increment 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
0, maka pointer ini akan mereferensi ke elemen array sealnjutnya.
Hasilnya:
Latihan: Pointer untuk Mengkases Data pada Struct
Menggunakan pointer pada struct akan membantu kita membuat kode menjadi lebih mudah dan gampang dibaca dibandingkan tanpa pointer.
Sebagai contoh..
Misalnya kita punya struct seperti ini:
int *pointer1 = 00001;
1
Struct 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
1 di dalamnya ada struct lagi, yakni struct #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
2. Nah di sini kita menggunakan pointer untuk struct #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
2.
int *pointer1 = 00001;
2
Pertanyaanya:
Gimana cara mengakses data di struct weapon?
Ada dua cara, kita bisa pakai operator 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
4 (dot/titik) dan #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
5 (operator pointer).
Pertama kita coba dulu pakai titik.
Silahkan buat program baru dengan nama 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
6, kemudian isi dengan kode berikut:
int *pointer1 = 00001;
3
Setelah itu, compile dan jalankan.
Maka hasilnya:



Perhatikan kodenya!
Saat kita mengakses data member pada struct yang bentuknya pointer dengan operator dot atau titik, maka kita harus menggunakan tanda kurung dan 
*ptr_hp = 95;
1 untuk menyatakan itu adalah pointer.
int *pointer1 = 00001;
4
Jika hanya satu member yang berbentuk pointer struct, ini oke-oke aja.
Tapi..
Kalau misalnya ada member struct pointer dan di dalamnya lagi ada struct pointer dan di dalamnya ada struct pointer, pasti kita akan bingung.
Bisa saja kodenya seperti ini:
int *pointer1 = 00001;
5
Duh! saya aja bingung bacanya.
Nah, biar gak seperti ini.. maka sebaiknya pakai Pointer. Sehingga akan bisa seperti ini:
int *pointer1 = 00001;
6
Ini lebih mudah dibaca dibandingkan yang tadi.
Jadi, jika ada member pointer di dalam Struct, maka sebaiknya pakai operator 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
5 untuk mengakses membernya.
Mari kita ubah kode yang tadi (
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
6) menjadi seperti ini:
int *pointer1 = 00001;
7
Hasilnya:
Pada program ini kita membuat dua variabel untuk struct Player, yakni 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
0 dan #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
1. Variabel #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
1 akan menjadi pointer untuk mengakses data pada #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
0.
int *pointer1 = 00001;
8
Selain cara ini, kita juga bisa pakai fungsi 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
4 seperti ini:
int *pointer1 = 00001;
9
Apa Selanjutnya?
Kita sudah membahas konsep dasar pointer pada C. Konsep ini harus kamu pahami, agar nanti saat ketemu pointer tidak bingung.
Kita tidak harus selalu menggunakan Pointer, tapi ada kasus tertentu seperti akses data pada Struct.. menggunakan pointer sangat disarankan agar kodenya lebih mudah dibaca.
Jika kamu masih bingun, silahkan tanyakan di komentar.
Selanjutnya silahkan pelajari tentang alokasi memori dengan fungsi 
#include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
4, #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
6, #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
7, dan #include <stdio.h>

void add_score(int *score){
    *score = *score + 5;
    printf("score dibuah ke: %d\n", *score);
}

void main(){
    int score = 0;

    printf("score sebelum diubah: %d\n", score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    add_score(&score);
    printf("score setelah diubah: %d\n", score);
}
8.