Skip to content

Pointer

January 16, 2011

Kita telah melihat bagaimana variabel dilihat sebagai sel memori yang dapat diakses menggunakan pengidentifikasi mereka. This way we did not have to care about the physical location of our data within memory, we simply used its identifier whenever we wanted to refer to our variable. Dengan cara ini kita tidak harus peduli tentang lokasi fisik data kami dalam memori, kita hanya menggunakan identifier setiap kali kami ingin untuk merujuk ke variabel kita.

The memory of your computer can be imagined as a succession of memory cells, each one of the minimal size that computers manage (one byte). Memori komputer Anda dapat dibayangkan sebagai suksesi sel memori, masing-masing ukuran minimal yang mengelola komputer (satu byte). These single-byte memory cells are numbered in a consecutive way, so as, within any block of memory, every cell has the same number as the previous one plus one. Sel-sel memori single-byte dinomori secara berturut-turut, sehingga, dalam setiap blok memori, setiap sel memiliki jumlah yang sama seperti sebelumnya ditambah satu.

This way, each cell can be easily located in the memory because it has a unique address and all the memory cells follow a successive pattern. Dengan cara ini, setiap sel dapat dengan mudah terletak di memori karena memiliki alamat yang unik dan semua sel memori mengikuti pola yang berurutan. For example, if we are looking for cell 1776 we know that it is going to be right between cells 1775 and 1777, exactly one thousand cells after 776 and exactly one thousand cells before cell 2776. Sebagai contoh, jika kita mencari sel 1776 kita tahu bahwa itu akan baik-baik antara sel 1775 dan 1777, tepat satu ribu sel setelah 776 dan tepat satu ribu sel sebelum sel 2776.

Referensi operator (&)

Segera setelah kita mendeklarasikan variabel, jumlah memori yang dibutuhkan adalah ditugaskan untuk itu di lokasi tertentu di memori (alamat memori). We generally do not actively decide the exact location of the variable within the panel of cells that we have imagined the memory to be – Fortunately, that is a task automatically performed by the operating system during runtime. Kita umumnya tidak aktif menentukan lokasi yang tepat dari variabel di dalam panel sel-sel yang telah kami membayangkan memori yang akan – Untungnya, itu adalah tugas dilakukan secara otomatis oleh sistem operasi saat runtime. However, in some cases we may be interested in knowing the address where our variable is being stored during runtime in order to operate with relative positions to it. Namun, dalam beberapa kasus kita mungkin tertarik untuk mengetahui alamat dimana variabel kita sedang disimpan selama runtime untuk beroperasi dengan posisi relatif untuk itu.

The address that locates a variable within memory is what we call a reference to that variable. Alamat yang menempatkan sebuah variabel dalam memori adalah apa yang kita sebut referensi ke variabel tersebut. This reference to a variable can be obtained by preceding the identifier of a variable with an ampersand sign ( & ), known as reference operator, and which can be literally translated as “address of”. Ini referensi ke variabel dapat diperoleh dengan mendahului identifier dari sebuah variabel dengan tanda ampersand (&), yang dikenal sebagai operator referensi, dan yang dapat harfiah diterjemahkan sebagai “alamat”. For example: Sebagai contoh:

 ted = &andy;

This would assign to ted the address of variable andy , since when preceding the name of the variable andy with the reference operator ( & ) we are no longer talking about the content of the variable itself, but about its reference (ie, its address in memory). Hal ini akan assign ke ted alamat dari variabel andy, sejak kapan sebelum nama variabel andy dengan operator referensi (&) kita tidak lagi berbicara tentang isi dari variabel itu sendiri, tetapi tentang referensi (misalnya, alamat di memori).

From now on we are going to assume that andy is placed during runtime in the memory address 1776 . Dari sekarang kita akan menganggap andy yang ditempatkan selama runtime di alamat memori 1776. This number ( 1776 ) is just an arbitrary assumption we are inventing right now in order to help clarify some concepts in this tutorial, but in reality, we cannot know before runtime the real value the address of a variable will have in memory. Nomor (1776) hanya sebuah asumsi sewenang-wenang kita menemukan sekarang dalam rangka untuk membantu menjelaskan beberapa konsep dalam tutorial ini, namun pada kenyataannya, kita tidak bisa tahu sebelum runtime nilai riil alamat dari suatu variabel akan ada di memori.

Consider the following code fragment: Perhatikan fragmen kode berikut:

1 1
2 2
3 3
 andy = 25; fred = andy; ted = &andy;

The values contained in each variable after the execution of this, are shown in the following diagram: Nilai-nilai yang terkandung dalam setiap variabel setelah pelaksanaan ini, akan ditampilkan dalam diagram berikut:

Pertama, kami telah diberi nilai 25 untuk andy (sebuah variabel yang alamatnya di memori kita harus diasumsikan 1776).

The second statement copied to fred the content of variable andy (which is 25). Pernyataan kedua disalin ke fred isi andy variabel (yang 25). This is a standard assignment operation, as we have done so many times before. Ini adalah tugas operasi standar, seperti yang telah kita lakukan begitu banyak kali sebelumnya.

Finally, the third statement copies to ted not the value contained in andy but a reference to it (ie, its address, which we have assumed to be 1776 ). Akhirnya, salinan pernyataan ketiga untuk ted bukan nilai yang terkandung dalam andy tetapi referensi untuk itu (misalnya, alamat nya, yang telah kita diasumsikan 1776). The reason is that in this third assignment operation we have preceded the identifier andy with the reference operator ( & ), so we were no longer referring to the value of andy but to its reference (its address in memory). Alasannya adalah bahwa dalam operasi ini tugas ketiga ini kita telah mendahului pengenal andy dengan operator referensi (&), jadi kami tidak lagi merujuk pada nilai andy melainkan untuk referensi (alamat di memori).

The variable that stores the reference to another variable (like ted in the previous example) is what we call a pointer . Variabel yang menyimpan referensi ke variabel lain (seperti ted pada contoh sebelumnya) adalah apa yang kita sebut pointer. Pointers are a very powerful feature of the C++ language that has many uses in advanced programming. Penunjuk adalah fitur yang sangat kuat dari C + + bahasa yang memiliki banyak kegunaan dalam pemrograman tingkat lanjut. Farther ahead, we will see how this type of variable is used and declared. Lebih jauh ke depan, kita akan melihat bagaimana jenis variabel yang digunakan dan dideklarasikan.

Dereference operator (*) Dereference operator (*)

We have just seen that a variable which stores a reference to another variable is called a pointer. Kita baru saja melihat bahwa sebuah variabel yang menyimpan referensi ke variabel lain disebut pointer. Pointers are said to “point to” the variable whose reference they store. Pointer dikatakan “menunjuk ke” variabel yang referensi mereka toko.

Using a pointer we can directly access the value stored in the variable which it points to. Menggunakan pointer kita langsung dapat mengakses nilai yang tersimpan dalam variabel yang menunjuk ke. To do this, we simply have to precede the pointer’s identifier with an asterisk (*), which acts as dereference operator and that can be literally translated to “value pointed by”. Untuk melakukan ini, kita hanya harus mendahului pointer’s pengenal dengan tanda bintang (*), yang bertindak sebagai operator dereference dan yang dapat harfiah diterjemahkan ke “nilai ditunjukkan oleh”.

Therefore, following with the values of the previous example, if we write: Oleh karena itu, berikut dengan nilai-nilai contoh sebelumnya, jika kita menulis:

 beth = *ted;

(that we could read as: ” beth equal to value pointed by ted “) beth would take the value 25 , since ted is 1776 , and the value pointed by 1776 is 25. (Yang kita bisa dibaca sebagai: "beth sama dengan nilai yang ditunjukkan oleh ted") beth akan mengambil nilai 25, karena ted adalah 1776, dan nilai yang ditunjukkan oleh 1776 adalah 25.

Anda harus secara jelas membedakan bahwa ekspresi ted mengacu pada nilai 1776, sedangkan * ted (dengan tanda bintang * sebelum identifier) mengacu pada nilai yang disimpan di alamat 1776, yang dalam hal ini adalah 25. Notice the difference of including or not including the dereference operator (I have included an explanatory commentary of how each of these two expressions could be read): Perhatikan perbedaan termasuk atau tidak termasuk operator dereference (saya telah menyertakan sebuah komentar penjelasan tentang bagaimana masing-masing dari kedua ekspresi dapat dibaca):

1 1
2 2
 beth = ted; // beth equal to ted ( 1776 ) beth = *ted; // beth equal to value pointed by ted ( 25 )

Notice the difference between the reference and dereference operators: Perhatikan perbedaan antara operator referensi dan dereference:

  • & is the reference operator and can be read as “address of” & Adalah operator referensi dan dapat dibaca sebagai “alamat”
  • * is the dereference operator and can be read as “value pointed by” * Adalah operator dereference dan dapat dibaca sebagai “nilai ditunjukkan oleh”

Thus, they have complementary (or opposite) meanings. Jadi, mereka telah melengkapi (atau sebaliknya) makna. A variable referenced with & can be dereferenced with * . Sebuah variabel yang direferensikan dengan & bisa dereferenced dengan *.

Earlier we performed the following two assignment operations: Sebelumnya kita melakukan dua kegiatan berikut tugas:

1 1
2 2
 andy = 25; ted = &andy;

Right after these two statements, all of the following expressions would give true as result: Tepat setelah dua pernyataan ini, semua ekspresi berikut akan memberikan benar sebagai hasilnya:

1 1
2 2
3 3
4 4
 andy == 25 &andy == 1776 ted == 1776 *ted == 25

The first expression is quite clear considering that the assignment operation performed on andy was andy=25 . Ekspresi pertama cukup jelas mengingat bahwa tugas operasi dilakukan pada andy adalah andy = 25. The second one uses the reference operator ( & ), which returns the address of variable andy , which we assumed it to have a value of 1776 . Yang kedua menggunakan operator referensi (&), yang mengembalikan alamat dari variabel andy, yang kami anggap itu memiliki nilai 1776. The third one is somewhat obvious since the second expression was true and the assignment operation performed on ted was ted=&andy . Yang ketiga adalah agak jelas sejak ekspresi kedua adalah benar dan tugas operasi dilakukan pada ted adalah ted = & andy. The fourth expression uses the dereference operator ( * ) that, as we have just seen, can be read as “value pointed by”, and the value pointed by ted is indeed 25 . Ekspresi keempat menggunakan operator dereference (*) itu, seperti telah kita lihat, dapat dibaca sebagai “nilai ditunjukkan oleh”, dan nilai yang ditunjukkan oleh ted memang 25.

So, after all that, you may also infer that for as long as the address pointed by ted remains unchanged the following expression will also be true: Jadi, setelah semua itu, Anda juga dapat menyimpulkan bahwa selama alamat yang ditunjukkan oleh ted tetap tidak berubah ekspresi berikut juga akan benar:

 *ted == andy

Declaring variables of pointer types Mendeklarasikan variabel jenis pointer

Due to the ability of a pointer to directly refer to the value that it points to, it becomes necessary to specify in its declaration which data type a pointer is going to point to. Karena kemampuan dari pointer ke langsung mengacu pada nilai yang menunjuk ke, menjadi perlu untuk menentukan dalam deklarasi yang tipe data pointer akan menunjuk ke. It is not the same thing to point to a char as to point to an int or a float . Ini bukan hal yang sama untuk menunjuk ke sebuah char sebagai untuk menunjuk ke suatu int atau pelampung.

The declaration of pointers follows this format: Deklarasi pointer berikut format ini:


type * name; ketik * nama;

where type is the data type of the value that the pointer is intended to point to. dimana tipe adalah tipe data dari nilai yang pointer dimaksudkan untuk menunjuk ke. This type is not the type of the pointer itself! Tipe ini bukan tipe dari pointer itu sendiri! but the type of the data the pointer points to. tetapi tipe data titik pointer ke. For example: Sebagai contoh:

1 1
2 2
3 3
 int * number; char * character; float * greatnumber;

These are three declarations of pointers. Ini adalah tiga deklarasi pointer. Each one is intended to point to a different data type, but in fact all of them are pointers and all of them will occupy the same amount of space in memory (the size in memory of a pointer depends on the platform where the code is going to run). Masing-masing dimaksudkan untuk menunjuk ke tipe data yang berbeda, namun sebenarnya semua dari mereka adalah pointer dan mereka semua akan menempati jumlah yang sama ruang memori (ukuran dalam memori dari sebuah penunjuk tergantung pada platform mana kode akan untuk menjalankan). Nevertheless, the data to which they point to do not occupy the same amount of space nor are of the same type: the first one points to an int , the second one to a char and the last one to a float . Namun demikian, data yang mereka menunjukkan tidak menempati jumlah yang sama ruang tidak pula dari jenis yang sama: poin pertama satu untuk int, yang kedua ke char dan orang terakhir yang mengambang. Therefore, although these three example variables are all of them pointers which occupy the same size in memory, they are said to have different types: int* , char* and float* respectively, depending on the type they point to. Oleh karena itu, walaupun ketiga variabel contoh adalah mereka semua petunjuk yang menempati ukuran yang sama di memori, mereka dikatakan memiliki jenis yang berbeda: * int, char * dan float * masing-masing, tergantung pada jenis mereka menunjukkan.

I want to emphasize that the asterisk sign ( * ) that we use when declaring a pointer only means that it is a pointer (it is part of its type compound specifier), and should not be confused with the dereference operator that we have seen a bit earlier, but which is also written with an asterisk ( * ). Saya ingin menekankan bahwa tanda bintang (*) yang kita gunakan ketika mendeklarasikan pointer hanya berarti bahwa itu adalah sebuah pointer (ini adalah bagian dari senyawa specifier jenisnya), dan tidak harus bingung dengan operator dereference bahwa kita telah melihat sedikit sebelumnya, tetapi yang juga ditulis dengan tanda bintang (*). They are simply two different things represented with the same sign. Mereka hanya dua hal yang berbeda diwakili dengan tanda yang sama.

Now have a look at this code: Sekarang kita lihat pada kode ini:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 // my first pointer 

#include <iostream> 
using namespace std; 
int main () { int firstvalue, secondvalue; int * mypointer; mypointer = &firstvalue; *mypointer = 10;
 mypointer = &secondvalue; 
*mypointer = 20; 
cout << "firstvalue is " << firstvalue << endl; 
cout << "secondvalue is " << secondvalue << endl;
 return 0; }

Notice that even though we have never directly set a value to either firstvalue or secondvalue , both end up with a value set indirectly through the use of mypointer . Perhatikan bahwa meskipun kami tidak pernah secara langsung mengatur nilai untuk baik firstvalue atau secondvalue, mengakhiri kedua dengan nilai satu set secara tidak langsung melalui penggunaan mypointer. This is the procedure: Ini adalah prosedur:

First, we have assigned as value of mypointer a reference to firstvalue using the reference operator ( & ). Pertama, kami telah ditugaskan sebagai nilai mypointer referensi untuk firstvalue menggunakan operator referensi (&). And then we have assigned the value 10 to the memory location pointed by mypointer , that because at this moment is pointing to the memory location of firstvalue , this in fact modifies the value of firstvalue . Dan kemudian kami telah diberi nilai 10 ke lokasi memori ditunjukkan oleh mypointer, bahwa karena saat ini menunjuk ke lokasi memori firstvalue, ini sebenarnya memodifikasi nilai firstvalue.

In order to demonstrate that a pointer may take several different values during the same program I have repeated the process with secondvalue and that same pointer, mypointer . Dalam rangka untuk menunjukkan bahwa pointer dapat mengambil beberapa nilai yang berbeda dalam program yang sama aku telah mengulangi proses dengan secondvalue dan bahwa pointer yang sama, mypointer.

Here is an example a little bit more elaborated: Berikut adalah contoh sedikit lebih diuraikan:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 // more pointers 
#include <iostream> using namespace std; 
int main () { 
int firstvalue = 5, secondvalue = 15;
 int * p1, * p2; 
p1 = &firstvalue; // p1 = address of firstvalue 
p2 = &secondvalue; // p2 = address of secondvalue 
*p1 = 10; // value pointed by p1 = 10 
*p2 = *p1; // value pointed by p2 = value pointed by p1
 p1 = p2; // p1 = p2 (value of pointer is copied)
 *p1 = 20; // value pointed by p1 = 20 
cout << "firstvalue is " << firstvalue << endl;
 cout << "secondvalue is " << secondvalue << endl;
 return 0; 
}
 firstvalue is 10 firstvalue adalah 10 
 secondvalue is 20 secondvalue adalah 20

I have included as a comment on each line how the code can be read: ampersand ( & ) as “address of” and asterisk ( * ) as “value pointed by”. Saya telah menyertakan sebagai komentar pada setiap baris kode bagaimana bisa dibaca: ampersand (&) sebagai “alamat” dan tanda bintang (*) sebagai “nilai ditunjukkan oleh”.

Notice that there are expressions with pointers p1 and p2 , both with and without dereference operator ( * ). Perhatikan bahwa ada ekspresi dengan pointer p1 dan p2, baik dengan dan tanpa operator dereference (*). The meaning of an expression using the dereference operator ( * ) is very different from one that does not: When this operator precedes the pointer name, the expression refers to the value being pointed, while when a pointer name appears without this operator, it refers to the value of the pointer itself (ie the address of what the pointer is pointing to). Arti dari sebuah ekspresi dengan menggunakan operator dereference (*) ini sangat berbeda dari satu yang tidak: Ketika operator ini mendahului nama pointer, ekspresi mengacu nilai yang menunjuk, sedangkan bila nama pointer muncul tanpa operator ini, itu merujuk dengan nilai pointer itu sendiri (yaitu alamat apa pointer menunjuk ke).

Another thing that may call your attention is the line: Hal lain yang mungkin menarik perhatian Anda adalah baris:

 int * p1, * p2;

This declares the two pointers used in the previous example. Ini mendeklarasikan dua pointer yang digunakan dalam contoh sebelumnya. But notice that there is an asterisk (*) for each pointer, in order for both to have type int* (pointer to int ). Tapi perhatikan bahwa ada tanda bintang (*) untuk setiap pointer, agar kedua untuk memiliki tipe int * (penunjuk ke int).

Otherwise, the type for the second variable declared in that line would have been int (and not int* ) because of precedence relationships. Jika tidak, jenis untuk variabel kedua dinyatakan dalam baris yang akan int (dan tidak * int) karena hubungan didahulukan. If we had written: Jika kita telah menulis:

 int * p1, p2;

p1 would indeed have int* type, but p2 would have type int (spaces do not matter at all for this purpose). p1 memang akan memiliki tipe int *, tapi p2 akan bertipe int (spasi tidak masalah sama sekali untuk tujuan ini). This is due to operator precedence rules. Hal ini disebabkan aturan prioritas operator. But anyway, simply remembering that you have to put one asterisk per pointer is enough for most pointer users. Tapi bagaimanapun, hanya mengingat bahwa Anda harus meletakkan satu bintang per pointer cukup untuk sebagian besar pengguna penunjuk.

Pointers and arrays Pointer dan array

The concept of array is very much bound to the one of pointer. Konsep array sangat terikat pada salah satu pointer. In fact, the identifier of an array is equivalent to the address of its first element, as a pointer is equivalent to the address of the first element that it points to, so in fact they are the same concept. Bahkan, array identifier adalah setara dengan alamat dari elemen pertama, sebagai pointer setara dengan alamat dari elemen pertama yang poin, jadi pada kenyataannya mereka adalah konsep yang sama. For example, supposing these two declarations: Sebagai contoh, seandainya kedua deklarasi:

1 1
2 2
 int numbers [20]; int * p;

The following assignment operation would be valid: Operasi tugas berikut akan berlaku:

 p = numbers;

After that, p and numbers would be equivalent and would have the same properties. Setelah itu, p dan nomor akan sama dan akan memiliki sifat yang sama. The only difference is that we could change the value of pointer p by another one, whereas numbers will always point to the first of the 20 elements of type int with which it was defined. Satu-satunya perbedaan adalah bahwa kita bisa mengubah nilai p pointer dengan yang lain, sedangkan angka akan selalu menunjuk kepada yang pertama dari 20 elemen bertipe int dengan yang didefinisikan. Therefore, unlike p , which is an ordinary pointer, numbers is an array, and an array can be considered a constant pointer . Oleh karena itu, tidak seperti p, yang merupakan pointer biasa, jumlah adalah array, dan array dapat dianggap sebuah penunjuk konstan. Therefore, the following allocation would not be valid: Oleh karena itu, alokasi berikut ini tidak akan berlaku:

 numbers = p;

Because numbers is an array, so it operates as a constant pointer, and we cannot assign values to constants. Karena angka adalah array, sehingga beroperasi sebagai pointer konstan, dan kita tidak bisa memberikan nilai pada konstanta.

Due to the characteristics of variables, all expressions that include pointers in the following example are perfectly valid: Karena karakteristik variabel, semua ekspresi yang mencakup pointer dalam contoh berikut ini sempurna sah:

1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
11 11
12 12
13 13
14 14
15 15
16 16
17 17
 // more pointers #include <iostream> using namespace std; int main () { int numbers[5]; int * p; p = numbers; *p = 10; p++; *p = 20; p = &numbers[2]; *p = 30; p = numbers + 3; *p = 40; p = numbers; *(p+4) = 50; for ( int n=0; n<5; n++) cout << numbers[n] << ", " ; return 0; }
 10, 20, 30, 40, 50, 10, 20, 30, 40, 50,

In the chapter about arrays we used brackets ( [] ) several times in order to specify the index of an element of the array to which we wanted to refer. Dalam bab tentang array kami menggunakan kurung ([]) beberapa kali dalam rangka untuk menentukan indeks dari sebuah elemen dari array yang kita ingin lihat. Well, these bracket sign operators [] are also a dereference operator known as offset operator . Nah, ini operator tanda kurung [] adalah juga operator dereference dikenal sebagai operator offset. They dereference the variable they follow just as * does, but they also add the number between brackets to the address being dereferenced. Mereka dereference variabel yang mereka ikuti hanya sebagai * tidak, tetapi mereka juga menambahkan angka antara kurung ke alamat yang sedang dereferenced. For example: Sebagai contoh:

1 1
2 2
 a[5] = 0; // a [offset of 5] = 0 *(a+5) = 0; // pointed by (a+5) = 0

These two expressions are equivalent and valid both if a is a pointer or if a is an array. Kedua ekspresi tersebut setara dan berlaku baik jika sebuah pointer atau jika sebuah array.

Pointer initialization Pointer inisialisasi

When declaring pointers we may want to explicitly specify which variable we want them to point to: Ketika mendeklarasikan pointer kita mungkin ingin secara eksplisit menentukan variabel yang kita ingin mereka menunjuk ke:

1 1
2 2
 int number; int *tommy = &number;

The behavior of this code is equivalent to: Perilaku kode ini setara dengan:

1 1
2 2
3 3
 int number; int *tommy; tommy = &number;

When a pointer initialization takes place we are always assigning the reference value to where the pointer points ( tommy ), never the value being pointed ( *tommy ). Ketika inisialisasi pointer terjadi kita selalu menempatkan nilai referensi ke mana titik pointer (tommy), tidak pernah nilai yang menunjuk (* tommy). You must consider that at the moment of declaring a pointer, the asterisk ( * ) indicates only that it is a pointer, it is not the dereference operator (although both use the same sign: *). Anda harus mempertimbangkan bahwa pada saat menyatakan pointer, tanda bintang (*) hanya menunjukkan bahwa itu adalah sebuah pointer, itu bukan operator dereference (walaupun keduanya menggunakan tanda yang sama: *). Remember, they are two different functions of one sign. Ingat, mereka adalah dua fungsi yang berbeda satu tanda. Thus, we must take care not to confuse the previous code with: Jadi, kita harus berhati-hati agar tidak membingungkan kode sebelumnya dengan:

1 1
2 2
3 3
 int number; int *tommy; *tommy = &number;

that is incorrect, and anyway would not have much sense in this case if you think about it. yang tidak benar, lagi pula tidak akan masuk akal dalam hal ini jika Anda berpikir tentang hal ini.

As in the case of arrays, the compiler allows the special case that we want to initialize the content at which the pointer points with constants at the same moment the pointer is declared: Seperti dalam kasus array, kompilator memungkinkan kasus khusus yang kita ingin menginisialisasi konten di mana titik pointer dengan konstanta pada saat yang sama pointer dideklarasikan:

 char * terry = "hello" ;

In this case, memory space is reserved to contain "hello" and then a pointer to the first character of this memory block is assigned to terry . Dalam hal ini, disediakan ruang memori berisi "halo" dan kemudian pointer ke karakter pertama dari blok memori diberikan ke terry. If we imagine that "hello" is stored at the memory locations that start at addresses 1702, we can represent the previous declaration as: Jika kita membayangkan bahwa "hello" disimpan pada lokasi memori yang dimulai pada alamat 1702, kita dapat mewakili deklarasi sebelumnya sebagai:

From → MATERI, Struktur Data

Leave a Comment

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: