Jump to content
Ancient One

C Pointer

Recommended Posts

Seingat aku laaa, masa member2 aku blaja C programming kat U dulu, biler sampai topik pointer jer, diaorang dah start pening kepala. Ader sesetengahnya langsung tak amik peduli pasal topik structure dan selanjutnya (aper2 topik selepas pointer). So, kat sini aku tulis laa sebijik tutorial khas untuk orang baru belajar C kat forum putera.com nih. Kalau korang dah tau korang nyer pointer, korang bleh bacer gak - maner tau kot2 ader yang korang tak tau (or ader yang aku salah bagitau), bleh laa kiter bincang sesama.. ye tak.

Biler nak bincang pasal pointer, nak tak nak aku kena la discuss pasal memory. Since C compilers ni bleh dikatakan wujud kat aper2 system dan architecture computers yang wujud, aku skopkan laaa citer pasal memory ni kat sistem yang kiter biasa pakai - PC. Memory yang aku refer kat sini biasa kiter sebut sebagai RAM (Random Access Memory). Nama dier random access pasal kiter bleh akses maner2 lokasi dalam memori secara direct. Setiap unit memori yang kiter bleh simpan data aku rujuk sebagai sel memori. Dalam PC, satu sel memori bleh simpan 1 byte data (8 bits data). Ni laa saiz paling kecik yang kiter bleh akses directly. Setiap sel ni ader alamatnya sendiri, sama laa cam rumah kiter. Alamat memori mula dari 0 sampailaaa n-1 (n adalah kapasiti memori tersebut). So kalau aku ader 100 byte memori, maka aku bleh simpan 100 bytes data, bermula dari alamat 0 hingga 99. Pemproses 32-bit yang kiter gunakan sekarang (80386, 80486, Pentium - Pentium 4 dan sebagainya, lepas ni aku refer sebagai x86) bleh akses sebanyak 2^32 (2 kuasa 32), iaitu bermula dari 0 hinggalah 4294967295. Dalam x86, kiter ader beberapa jenis basic data types, iaitu saiz memori yang kiter bleh akses secara direct dalam satu arahan, iaitu 1 byte, 2 bytes (1 word), 4 bytes (1 dword), 6 bytes (1 fword), 8 bytes (1 qword) dan beberapa lagi yang kiter jarang guna. So, kiter takleh laa akses memori bersaiz 3 bytes secara terus. Alternatively, kiter bleh akses memori bersaiz 3 bytes ni dengan 2 langkah, read 1 word then read 1 byte; atau dengan cara lain. Dalam C, direct mapping untuk beberapa data types yang sangat kerap digunakan :

char - byte
short - word
int/long - dword
biasanya untuk machine 16-bit, int akan jadik word dan long akan jadik dword. Dalam machine 32-bit, dua-dua menatang ni biasanya bersaiz sama, iaitu 1 dword. Dalam C, nama suatu variable yang kiter berikan adalah mewakili nilai pada suatu lokasi, bukannya mewakili lokasi tersebut. Contohnya
short Var2;
char Var3;
int Var1;
Setiap variable memerlukan storage dengan saiz yang mencukupi. Var2 perlukan at least 2 bytes. Var3 perlukan 1 byte dan Var1 perlukan 4 bytes storage. Nama variables ni tak penting pada machine sebab dia cumer kenal ngan nombor. So Var2 mungkin duduk kat lokasi 100 dalam memori, manakala Var3 plak duk kat lokasi 102, Var1 kat 105. Tu contoh jer. Since, setiap variable ni duk kat dalam memori, dalam C, kiter bleh rujuk lokasi memori setiap variables ni dengan menggunakan operator &. Contohnya :
#include <stdio.h>

/* global vars */
int foo = 1;
int bar = 2;

void main() {
    printf("Nilai Pembolehubah [foo] = %d dan [bar] = %d\n", foo, bar);
    printf("Alamat memori [foo] = %#x dan [bar] = %#x\n", &foo, &bar);
}
(aku assume korang reti laa guner compiler feveret korang). Biler kiter run program kat atas, then kiter akan dapat output lebih kurang camni :
Nilai Pembolehubah [foo] = 1 dan [bar] = 2
Alamat memori [foo] = 0x408040 dan [bar] = 0x408044
Pada mulanya, aku isytiharkan 2 global vars foo dan bar masing2 bernilai 1 dan 2. Dalam fungsi main, ader dua lines code. Yang pertama
    printf("Nilai Pembolehubah [foo] = %d dan [bar] = %d\n", foo, bar);
cetak nilai terkini foo dan bar. Since kiter dah initialized dua2 vars ni dengan nilai 1 dan 2 dan kiter tak ubahnya dalam fungsi main sebelum line ni dilaksanakan, maka nilai yang dicetak adalah 1 dan 2. Line kedua plak
    printf("Alamat memori [foo] = %#x dan [bar] = %#x\n", &foo, &bar);
cetak alamat foo dan bar masing2, iaitu lokasi storan yang diberikan oleh pengkompil kepada kedua-dua vars ni. Dalam arguments kepada fungsi printf, kiter berikan argument &foo dan &bar, yang bermakna alamat untuk foo dan bar. Dalam contoh kat atas, lokasi foo adalah pada 0x408040 dan lokasi bar adalah pada 0x408044, iaitu dua dwords yang berturutan. Tu contoh simple jerr.. sekarang kiter tengok plak camne nak gunakan operator * (selain daripada kegunaannya sebagai multiplication operator). Contoh di atas, foo dan bar mewakili NILAI DALAM SUATU LOKASI MEMORI. Sekarang camne plak kiter nak isytihar suatu variable yang mewakili LOKASI SUATU NILAI? Senang jer, gunakan operator * :
#include <stdio.h>

/* global vars */
int Foo = 1;
int *Address_Of_Foo;

void main() {
    printf("[Sebelum kiter modify Address_Of_Foo]\n");
    printf("Foo             = %d\n", Foo);
    printf("&Foo            = %#x\n", &Foo);
    printf("Address_Of_Foo  = %d\n\n", Address_Of_Foo);
    /* ubah Address_Of_Foo */
    Address_Of_Foo = &Foo;
    printf("[Selepas kiter modify Address_Of_Foo]\n");
    printf("Foo             = %d\n", Foo);
    printf("Address_Of_Foo  = %#x\n", Address_Of_Foo);
    printf("&Address_Of_Foo = %#x\n\n", &Address_Of_Foo);
    /* ubah Foo melalui Address_Of_Foo */
    printf("[Modify Foo melalui Address_Of_Foo]\n");
    *Address_Of_Foo=100;
    printf("Foo             = %d\n", Foo);
}
Biler kiter run program nih, outputnya adalah :
[Sebelum kiter modify Address_Of_Foo]
Foo             = 1
&Foo            = 0x408040
Address_Of_Foo  = 0

[Selepas kiter modify Address_Of_Foo]
Foo             = 1
Address_Of_Foo  = 0x408040
&Address_Of_Foo = 0x408a18

[Modify Foo melalui Address_Of_Foo]
Foo             = 100
Pertama sekali, kiter define dua variable bernama Foo berjenis integer (4 bytes of storage), dan Address_Of_Foo berjenis PENUNJUK KEPADA PEMBOLEHUBAH BERJENIS INTEGER. Since Address_Of_Foo adalah variable, dier perlukan storage gak. Saiz pointer dalam 32-bit machine adalah.. 32-bit laaa. So, Address_Of_Foo perlukan 4 bytes storage. Biler kiter deal ngan pointer, kiter kena tau jenis data (saiz) yang ditunjuk oleh pointer tersebut. Actually kiter bleh gak define pointer yang tak tau jenis data yang ditunjuknya, dalam kes ni kiter kena laa gunakan void, contohnya void *PointerToAnything;. Dalam kod kat atas, aku initialize Foo ngan nilai 1 dan Address_Of_Foo ngan nilai 0. Selalunya, dalam maner2 OS, lokasi 0 adalah tak valid, maknanya kiter takleh akses lokasi ni dalam program, yang akan menyebabkan error seperti memory access violation biler kiter akses lokasi ni. Ni membolehkan kiter check pointer yang tak sah sebelum digunakan. Ader 3 bahagian output contoh program kat atas, pertama adalah nilai awal setiap variables. Var Foo terletak pada lokasi memori 0x408040 (&Foo) dan nilainya adalah 1. Kemudian kiter berikan variable Address_Of_Foo dengan nilai alamat untuk var Foo. Maknanya sekarang Address_Of_Foo menyimpan lokasi Foo. Dalam C, kiter mesti deal ngan data type yang betul. Walaupun realitinya, pointer value hanyalah nombor (sama seperti int, char dan sebagainya). Dalam kes di atas, kiter assign LOKASI Foo kepada Address_Of_Foo. Well.. no problem kalau aku bagi nombor constant kepada Address_Of_Foo, afterall, pointer hanyalah nombor biasa kan? Contohnya, aku bleh tulis
Address_Of_Foo = 1;
tapi certain compilers tak benarkan assignment camni since 1 is just a normal integer (ni bergantung pada setting compilers laa), not a pointer. Cara nak bagi constant adalah dengan cast constant ni dengan type yang sama ngan pointer var tersebut, contohnya
Address_Of_Foo = (int *)1;
Dalam M$ Visual C/C++ compiler yang aku guner (cl.exe), dier berikan warning jer untuk kes pertama (Address_Of_Foo = 1)
warning C4047: '=' : 'int *' differs in levels of indirection from 'int'
maknanya data type tak sama ler tuh. Dalam bahagian kedua plak kiter cetak nilai Address_Of_Foo. Sekarang dier nyer nilai dah berubah sebab kiter dah assign value baru sebelum nih. Since Address_Of_Foo jugak suatu var yang tersimpan kat memori, aku cetak gak lokasinya. Ringkasnya, kiter bleh katakan lokasi 0x408a18 menyimpan nilai lokasi untuk variable Foo. Bahagian last plak, kiter ader satu lagi kegunaan operator *, iaitu indirection. Kat sini kiter refer Foo melalui Address_Of_Foo. Since Address_Of_Foo adalah address Foo, iaitu ia menunjuk kepada variable Foo.
*Address_Of_Foo=100;
maknanya assign nilai 100 kepada lokasi yang disimpan oleh Address_Of_Foo. Address_Of_Foo currently is 0x408040 (which is where Foo is located). So, secara tak langsung kiter modify Foo laaa.. Thats why biler kiter cetak nilai Foo, nilainya adalah 100, dan bukan lagi 1. Payah gak sebenarnya pointer ni. Kalau korang penah belajar pasal assembly, korang mesti faham nyer laa konsep nih. Tu baru intro jer.. Actually biler korang belajar pasal array pun sebenarnya korang dah sentuh pasal pointer. Array ngan pointer ni sama jer.
char aFoo[] = "aFoo";
char *pFoo = "pFoo";
line pertama maknanya aFoo adalah array (setiap elemen berjenis char), dengan initialized value 'a', 'F', 'o', 'o'. Basically aFoo adalah pointer yang menunjuk kepada elemen pertama array nih. Line kedua plak maknana pFoo adalah pointer yang menunjuk kepada data berjenis char, dengan initialized value yang menunjuk kepada first element of array 'p', 'F', 'o', 'o'. Aper beza dua-duanya. Yang pertamanya, aFoo adalah constant, bukan variable. Korang takleh assign constant ngan value dalam kod korang (e.g takleh buat aFoo = pFoo). Aku ulang.. ia bukan variable! pFoo plak adalah variable, so korang bleh assign pFoo ngan nilai baru dalam kod. Untuk array aFoo, kiter cuma nampak ni jer (contoh)
sel     | 1 | 2 | 3 | 4 | 5 | ..... | n-1 |
data    | a | F | o | o | 0 | ..... | ??? |
untuk pFoo, plak
sel     | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ..... | n-1 |
data    |      5        | p | F | o | o | 0 | ..... | ??? |
di mana lokasi 1-4 adalah lokasi storage untuk pFoo. Nilainya adalah 5, iaitu lokasi untuk permulaan array (chain of characters) "pFoo". Untuk refer array element, kiter just gunakan nama array ngan indexer. Index adalah zero-based. Contohnya untuk refer 'F' dalam array aFoo, kiter gunakan aFoo[1]. Untuk refer lokasinya plak, kiter gunakan &aFoo[1], maknanya amik alamat element pada index 1 of array aFoo. Pointer ngan array are interchange. Kiter takde masalah nak refer element kedua (index 1) array aFoo menggunakan pointer indirection operator (*), iaitu dengan menulis *(aFoo+1). Tapi ader satu benda yang perlu kiter ingat. Dalam *(aFoo+1), 1 bukan bermakna 1 byte, tapi satu elemen. Ni penting biler kiter gunakan pointer indirection untuk array jenis yang lebih beso dari char (1 byte). Satu lagi perbezaan dalam contoh di atas adalah "aFoo" bleh dimodify maser runtime, tapi tidak semestinya "pFoo". Dalam char *pFoo = "pFoo";, kiter define var pFoo dan kiter initializekannya dengan lokasi string "pFoo". String ni bleh duk kat maner2 jer, including read-only memory area. Setakat ni kiter cuma discuss sikit jer pasal operator * dan &. Basically operator * digunakan untuk define data type berjenis pointer seperti
void    *pAny;
short   *pWord;
int     *pInt1, *pInt2;
dan juga untuk dereference pointer (i.e akses value through pointer) seperti
int *pVal1 = 100;

foo() {
    *pVal1 = 10;
    (*pVal1)++;
}
Manakala operator & digunakan untuk amik alamat suatu variable, seperti
int A = 10;         /*A : integer*/
int *pA = &A;       /*pA : pointer to integer*/
int **ppA = &pA;    /*ppA : pointer to pointer to integer*/

dan sebagainya. Banyak lagi yang aku tak citer, contohnya function pointer, pointer arithmetics dan lain2 laaa.. Lain kali aku citer plak pasal ni. Dan juga pointer dan structure, e.g penggunaan operators . dan ->. Babai!

Share this post


Link to post
Share on other sites

hihi, tu la~

kengkadang aku seke jgk wat cam

#include <stdio.h>

extern char **environ;

int main(int argc, char *argv[])

{

        char c;

        c = "ABCDEF"[2];

        printf("c besar %c\n", c);

        return 0;

}

# gcc test.c -o test

# ./test

c besar C

#

bash-2.05b# ./test2

[sebelum kiter modify Address_Of_Foo]

Foo            = 1

&Foo            = 0x8049650

Address_Of_Foo  = 0

[selepas kiter modify Address_Of_Foo]

Foo            = 1

Address_Of_Foo  = 0x8049650

&Address_Of_Foo = 0x804974c

[Modify Foo melalui Address_Of_Foo]

Foo            = 100

# ternyata variable address kiter kt memory stack berbeza #

Edited by fatah

Share this post


Link to post
Share on other sites

aku rasa buku deitel&deitel bagi explanation yg mmg best dan senang nak difaham...maaf...compare ngan korang punya tutorial di atas...weh, jangan marah..cuma opinion aku saja, peace, tak mau perang! Tahniah buat ancient one. ko mmg best dalam membantu member2 yg pening dalam pointer.

Err, ancient one. tak teringin ke nak explain polymorphism kat aku plak? bab2 OOP cam ni aku pening skit. mana tau explanation ko plak boleh membantu aku.

Share this post


Link to post
Share on other sites

aku rasa buku deitel&deitel bagi explanation yg mmg best dan senang nak difaham...maaf...compare ngan korang punya tutorial di atas

tu laa hasilnya bila aku tulis aper yang aku biasa cakap ngan kawan2 aku. nak tulis secara formal aku tak reti sebab aku tak penah cakap secara formal smile.gif.

Err, ancient one. tak teringin ke nak explain polymorphism kat aku plak? bab2 OOP cam ni aku pening skit. mana tau explanation ko plak boleh membantu aku.

betul ker ko nak aku tulis????? bleh bacer buku deitel&deitel aper smile.gif.

ni sambungannya..

When dealing with dynamic data storage, kiter selalu kena guna pointer (or array). Kiter biasa mintak memory ngan C standard library, malloc, atau calloc, atau dengan new operator in C++. Here's a prototype for malloc :

void *malloc(size_t size);
maknanya malloc adalah fungsi yang memulangkan void pointer. void supaya kiter bleh gunakan return value ni untuk assignment kepada aper jenis pointer pun, without casting, e.g
char *UserName=malloc(_MAX_USERNAME);
tu dalam C; dalam C++ kiter kena cast malloc nyer return value kepada jenis yang betul :
char *UserName=(char *)malloc(_MAX_USERNAME);
Kalau UserName bukan sifar, maknanya kiter dapat laa pointer kepada satu kawasan memori yang diallocatekan oleh memory manager. Kiter bleh treat UserName jugak sebagai array, contohnya
UserName[_MAX_USERNAME-1]='\0';
atau kiter bleh lakukannya dengan pointer indirection
*(UserName+_MAX_USERNAME-1)='\0';
which is basically just the same thing, seperti yang aku dah katakan sebelum ni, pointer ngan array sama jer. Tapi kiter perlu ingat yang
char *UserName=malloc(_MAX_USERNAME);
tak sama ngan
int *UserName=malloc(_MAX_USERNAME);
biler kiter akses elemen dalam dynamic memory tuh. Dalam pointer arithmetic, kiter kena fikir dalam konteks array, bukannya dalam konteks memori, iaitu 1 maknanya 1 elemen, bukannya 1 byte. Unless kiter cast int *UserName jadik char *, sebab char bersaiz 1 byte. Dalam pengaturcaraan Windows, kiter jarang nampak asterisk nih walaupun pointer banyak digunakan (contohnya VirtualAlloc). Sebabnya, include files dalam PSDK dah typedefkan jenis pointer ni ngan nama yang biasanya dimulai dengan P atau LP. Contohnya, prototype untuk VirtualAlloc :
LPVOID VirtualAlloc(
  LPVOID lpAddress,        // region to reserve or commit
  SIZE_T dwSize,           // size of region
  DWORD flAllocationType,  // type of allocation
  DWORD flProtect          // type of access protection
);
di mana LPVOID sebenarnya adalah void *. Korang bleh verify menatang ni dengan melihat header file windef.h :
...
typedef FLOAT               *PFLOAT;
typedef BOOL near           *PBOOL;
typedef BOOL far            *LPBOOL;
typedef BYTE near           *PBYTE;
typedef BYTE far            *LPBYTE;
typedef int near            *PINT;
typedef int far             *LPINT;
typedef WORD near           *PWORD;
typedef WORD far            *LPWORD;
typedef long far            *LPLONG;
typedef DWORD near          *PDWORD;
typedef DWORD far           *LPDWORD;
typedef void far            *LPVOID;
typedef CONST void far      *LPCVOID;
typedef unsigned int        *PUINT;
...
*note* near ngan far tu citer lama nyer.. bleh diabaikan dalam Win32. Walaupun takla nampak cam problem besar, tapi ia bleh memudahkan kiter membaca declaration yang kompleks. Kat atas hanyalah contoh ringkas. Kalau kiter buat program yang lebih kompleks, kiter akan tulis declaration yang lebih kompleks plak. Contohnya
#include <stdio.h>

void F1(char *);
void F2(char *);
void F3(char *);

void (*FCetak[3])(char *) = {F1, F2, F3};

void F1(char *str) {printf("F1 : %s\n", str);}
void F2(char *str) {printf("F2 : %s\n", str);}
void F3(char *str) {printf("F3 : %s\n", str);}

void TestFunctionPointer() {
    FCetak[0]("Test1");
    (*FCetak)("Test2");
    FCetak[1]("Test3");
    FCetak[2]("Test4");
}

void main() {
    TestFunctionPointer();
}
Tengok line
void (*FCetak[3])(char *) ...
Line ni bleh laa dikatakan complex declaration. Basically aper yang diwakilinya adalah FCetak adalah array of pointers to function returning void. Since ia adalah array, kiter initialize dengan {...} dan setiap elemen mestilah berjenis void ... (char *), cam F1, F2 ngan F3 kat atas. Tengok plak kat fungsi TestFunctionPointer. Korang akan dapati string "Test1" dan "Test2" dicetak melalui fungsi yang sama, iaitu F1. Untuk memudahkan kompleks declaration camni, kiter bleh gunakan typedef:
typedef INT (* PMessageBox)(HWND, LPCSTR, LPCSTR, UINT);
so kiter bleh declare var camni
PMessageBox MessageBox = NULL;
yang bermaksud MessageBox adalah function pointer yang menerima 4 params (seperti kat atas) dan memulangkan integer, dengan nilai awalnya adalah NULL (0). Biler dah dapat address MessageBox at runtime, kiter bleh panggil dier cam biasa
MessageBox(hWnd, TEXT("Hello putera.com"), TEXT("Test"), MB_ICONINFORMATION);
Kalau kiter nampak complex declaration camni, yang terdiri daripada beberapa bijik asterisk, brackets dan parentheses, cara nak interpret dia senang jer. kiter bleh start dari nama identifier tuh. Then tengok kat sebelah kanan, kalau ader [] atau (), interpret tu dulu, pastu baru tengok kiri kalau ader *. Last sekali baru kiter apply type specifier. Contohnya, dalam function definition
double (*SomeFunc(double *Val[5]))[5] {
    ...
}
1. SomeFunc adalah fungsi
    SomeFunc()
2. yang menerima 1 parameter berjenis array of 5 elements, iaitu pointers to double values,
    SomeFunc(double *Val[5])
3. memulangkan nilai berjenis pointer
    (*SomeFunc(double *Val[5]))
4. to arrays of 5 elements, berjenis double. Ye ke tuh?? camtu laa lebih kurang dia nyer makna. Aku harap korang dapat ideanya. $-=-=-=-=-=-=-=-=$ Structure, kalau nak diringkaskan, hanyalah kumpulan variables yang berturutan dalam memori, di mana setiap variable di dalam structure bleh mempunyai jenis berlainan. Ni membolehkan kiter mengkelaskan data kepada kumpulan. Kiter define structure ngan struct keyword, contohnya
struct EMPATSEGI {
    int Atas;
    int Kiri;
    int Bawah;
    int Kanan;
};
tu cuma declare template jer, bukannya variable. Template ni namanya EMPATSEGI. Kiter bleh declare variable berjenis EMPATSEGI seperti berikut :
struct EMPATSEGI RangkaLuar, RangkaDalam;
struct EMPATSEGI HadLuar;
Kalau kiter taknak ulang struct SEGIEMPAT tu dalam variables declaration, kiter bleh guna typedef :
struct _EMPATSEGI {
    int Atas;
    int Kiri;
    int Bawah;
    int Kanan;
} EMPATSEGI, *LPEMPATSEGI;
then kiter bleh declare vars
EMPATSEGI RangkaLuar, RangkaDalam;
EMPATSEGI HadLuar;
sebab sekarang EMPATSEGI adalah type. Kat atas tu kiter declare 3 variables yang merupakan structure EMPATSEGI. Setiapnya bersaiz 16 bytes (iaitu sizeof(EMPATSEGI)). Camne plak kiter nak akses value setiap field (member) dalam structure nih? Senang jer.. ngan . (dot) operator.
EMPATSEGI HadLuar;

void SetHadLuarAuto() {
    HadLuar.Atas = 0;
    HadLuar.Kiri = 0;
    HadLuar.Bawah = SkrinY;
    HadLuar.Kanan = SkrinX;
}
Camne plak nak akses structure's members ngan pointer? Kiter ganti jer la . ngan ->. Tapi kiter perlu ingat, biler kiter define pointer ke structure, camni
EMPATSEGI *pHadLuar; /*atau LPEMPATSEGI HadLuar; */
Kiter hanya define pointer ke structure, bukan structure tersebut. So, sizeof(HadLuar) sama ngan 16 bytes, tapi sizeof(pHadLuar) hanya 4 bytes, since it's just a pointer. Pointer ni perlu menunjuk kepada structure yang valid dalam memory atau kiter allocate secara dynamic. Contohnya
EMPATSEGI   HadLuar,
            *pHadLuar = &HadLuar;

void SetHadLuarAuto() {
    /*
    HadLuar.Atas = 0;
    HadLuar.Kiri = 0;
    HadLuar.Bawah = SkrinY;
    HadLuar.Kanan = SkrinX;
    */
    pHadLuar->Atas = 0;
    pHadLuar->Kiri = 0;
    pHadLuar->Bawah = SkrinY;
    pHadLuar->Kanan = SkrinX;
}
Please note that -> hanyalah pointer indirection untuk akses member structure; so,
    pHadLuar->Atas = 0;
takde bezanyanya dengan
    (*pHadLuar).Atas = 0;
$-=-=-=-=-=-=-=-=$ Kalau korang tau pasal assembly, citer pasal pointer dalam C ni mengarut jer. Dalam assembly mudah jer: SETIAP LABEL ADALAH LOKASI MEMORI (this is true for FASM). Kiter lakukan pointer indirection ngan [] pair. Contohnya
Lebar dd ?

    mov     eax, Lebar

menyalin lokasi memori (pemalar) ke register eax, dan
Lebar dd ?

    mov     eax, [Lebar]

menyalin nilai yang ada pada lokasi memori ke register eax. Kalau label Lebar adalah lokasi 0x402000 katakan, maka kedua-dua kod di atas nampak camni laa..
    mov     eax, 0x402000
eax akan jadik 0x402000 lepas perlaksanaan, manakala yang kedua jadik
    mov     eax, [0x402000]
eax akan jadik aper jer nilai yang currently ader pada lokasi 0x402000. Sesetengah assembler ader support untuk structure, cam kat C laaa, cuma ringkas sikit. Tapi basically konsep kat atas sama jer diaplikasikan untuk structure. Dalam FASM (assume jer la label SkrinX ngan SkrinY wujud kat maner2),
struc EMPATSEGI {
    .Atas   dd ?
    .Kiri   dd ?
    .Bawah  dd ?
    .Kanan  dd ?
}

HadLuar EMPATSEGI

SetHadLuarAuto:
    xor     eax, eax
    mov     [HadLuar.Atas], eax
    mov     [HadLuar.Kiri], eax
    push    SkrinY
    pop     [HadLuar.Bawah]
    push    SkrinX
    pop     [HadLuar.Kanan]
    ret

$-=-=-=-=-=-=-=-=$

Share this post


Link to post
Share on other sites

salam.....

ak org br kt cni....

harap2 dialu2kn... B)

so nk tnya la,kalo korg tau kt mane(website)ekh ak bleh blajo c programming yg bleh sng difahami...

sbb skrg ak blajo mggunakn c programming,tp xbrapa nk phm sgt....

so,harap sapa bleh tolng......

Edited by third87

Share this post


Link to post
Share on other sites

Askum,

kalu korang nak powerpoint slide C (Intro to Programming), bleh aku kasi...ada kat dalam email aku...kalu nak bagi tau je...

ok thx

Share this post


Link to post
Share on other sites

saudara yg bukak topic ni dah meninggal dunia..sekadar utk pengetahuan iamnewbie

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...

×
×
  • Create New...