1

C Pointers & Structures

Materi ke‐6
Dodi Sudiana & Alfan Presekal
Mengapa mempelajari Pointer? 2

• Pointer sangat berdaya guna (powerful)

• Efisien karena dapat menangani jumlah data 
yang tidak terbatas (dynamically allocate 
memory)
• Bandingkan dengan Array yang harus
dialokasikan jumlah memori yang akan dipakai
– Inisiasi Array dengan jumlah elemen 100 berarti
dari awal pemrograman telah dipesan sebanyak
100 lokasi memori. 
– Kenyataannya mungkin dipakai lebih sedikit, atau
butuh lebih banyak
• Dapat mengimplementasikan call by reference
2
Memory address 3

• Setiap variabel yang kita deklarasikan akan mereservasi
suatu lokasi dalam memori komputer
• Lokasi tsb memiliki address
• Untuk mengakses address memori tsb, gunakan tanda & 
(ampersand)
• Contoh:   scanf(“%d”, &var1);
 Artinya kita ingin meminta suatu input integer dan 
ingin diletakkan di address memori dimana var1 telah 
melakukan reservasi sebelumnya

3
 4

Code Result
#include <stdio.h> Address of var1 variable: 6a33e9ac
Address of var2 variable: 6a33e9a0
int main ()
{
int var1;
char var2[10];

printf("Address of var1 variable: %x\n", &var1 );

printf("Address of var2 variable: %x\n", &var2 );

return 0;
}
Apa itu Pointer? 5

• Sebuah Pointer sebenarnya juga merupakan variable 
• Bedanya dgn variable biasa:
– Pointer menyimpan address dari variable lain
• Isi pointer adalah address dari variable lain
– Variable biasa menyimpan suatu value spesifik direct reference
• Pointer digunakan untuk menunjuk lokasi memori di 
mana sebuah value ingin disimpan dengan cara 
menyebutkan address dari variable tempat seharusnya 
value tsb disimpan  indirect reference

5
 Sedang 6
Ayah kos

Citra Citra

Jalan Baru
no 10

Bayu ingin memberi kado pada Citra (tapi

tidak tahu alamatnya). Maka dapat dilakukan
dengan cara:
• langsung memberikannya pada Citra
(direct)
• menitipkannya ke Ayah Citra (indirect)
Ayah Citra berperan sebagai
Pointer atau penunjuk dimana
Bayu Citra berada
6
Fig. 7.1 | Directly and indirectly referencing a variable 7

Fig. 7.1 | Directly and indirectly referencing a variable

7
Pointer Declaration 8

• Tanda* digunakan untuk mendeklarasikan pointer 
• <variable_type> *<pointer_var_name>;

• Tipe (type) pointer sama dengan tipe variabel yang 
ditunjuknya 
• int *ip; /* pointer to an integer */
• double *dp; /* pointer to a double */
• float *fp; /* pointer to a float */
• char *ch /* pointer to a character */

• Jika ingin mendeklarasikan lebih dari 1 pointer, tanda * 
ditulis sebelum tiap nama pointer variable
• int *myPtr1, *myPtr2;

8
Pointer Initialization 9

• Untuk mendapatkan address dari variable 

yang ingin ditunjuk oleh pointer, gunakan
tanda & (address operator)
int y = 5;
int *yPtr;
yPtr = &y; /* yPtr gets address of
y */
yPtr “menunjuk ke” y
• Dengan cara ini berarti kita sudah
melakukan inisialisasi pada pointer
9
 10

Fig. 7.2 | Graphical representation of a pointer pointing to an integer variable in memory.

Sebuah pointer variable akan lebih baik jika penamaannya diakhiri Ptr. 

Hal ini akan memudahkan kita dalam memprogram

10
 11

Fig. 7.3 | Representation of y and yPtr in memory.

11
#include <stdio.h> 12

int main ()
{
int y = 20; /* actual variable declaration */
int *yPtr; /* pointer variable declaration */

yPtr = &y; /* store address of var in pointer variable*/

printf("Address of y variable: %p\n", &y );

/* address stored in pointer variable */

printf("Address stored in yPtr variable: %p\n", yPtr );

/* access the value using the pointer */

printf("Value of *yPtr variable: %d\n", *yPtr );
Address of y variable: 93f0a5a4
return 0; Address stored in yPtr variable: 93f0a5a4
} Value of *yPtr variable: 20
Indirection 13

• Untuk mengakses value secara indirect, gunakan tanda * 

(indirection/dereferencing operator)
• Contoh sebelumnya:
printf("Value of *yPtr variable: %d\n", *yPtr );
Menghasilkan:
Value of *yPtr variable: 20 
• Tanda * dapat digunakan untuk mengassign value secara
indirect
*yptr = 7; /* changes y to 7 */

• * dan & merupakan inverse bagi satu sama lain

13
1 /* Fig. 7.4: fig07_04.c
2 Using the & and * operators */ Outline
3 #include <stdio.h>
4
14
5 int main( void )
6 { fig07_04.c
7 int a; /* a is an integer */
8 int *aPtr; /* aPtr is a pointer to an integer */ (1 of 2 )
9
10 a = 7;
11 aPtr = &a; /* aPtr set to address of a */
12
13 printf( "The address of a is %p"
If aPtr points to a, then &a and
14 "\nThe value of aPtr is %p", &a, aPtr ); aPtr have the same value.
15
16 printf( "\n\nThe value of a is %d" a and *aPtr have the same value
17 "\nThe value of *aPtr is %d", a, *aPtr );
18
19 printf( "\n\nShowing that * and & are complements of "
20 "each other\n&*aPtr = %p" &*aPtr and *&aPtr have the same value
21 "\n*&aPtr = %p\n", &*aPtr, *&aPtr );
22
23 return 0; /* indicates successful termination */
24
The address of a is 0012FF7C
25 } /* end main */ The value of aPtr is 0012FF7C

The value of a is 7
The value of *aPtr is 7

Showing that * and & are complements of each other.

&*aPtr = 0012FF7C
14
*&aPtr = 0012FF7C
NULL Pointers 15

• Ada kalanya kita tidak/belum ingin meng‐
assign sebuah pointer ke suatu address 
variable
• Disebut Null Pointer
– Meng‐assign NULL value ke pointer
– Dilakukan saat variable declaration. 
• Akan sangat berguna ketika menggunakan 
linked list

15
 16
#include <stdio.h>
int main ()
{ int *ptr = NULL;
printf("The value of ptr is : %x\n", ptr );
return 0;
}

The value of ptr is 0

16
Calling Functions by Reference 17

• Mengubah langsung ke lokasi memori

tempat variable disimpan
• Menggunakan pointer arguments 
– Main program, atau pemanggil function 
menggunakan operator &
double  (&num);
– Function menggunakan tanda operator *
void double( int *number )
{
*number = 2 * ( *number );
}
• *number sebagai nickname dari variable yang 
dikirimkan (num)
17
1 /* Fig. 7.6: fig07_06.c
2
3
Cube a variable using call-by-value */
#include <stdio.h>
Outline
4 18
5 int cubeByValue( int n ); /* prototype */
6
fig07_06.c
7 int main( void )
8 {
9 int number = 5; /* initialize number */
10
11 printf( "The original value of number is %d", number );
12
13 /* pass number by value to cubeByValue */
14 number = cubeByValue( number );
15
16 printf( "\nThe new value of number is %d\n", number );
17
18 return 0; /* indicates successful termination */ Call by Value
19
20 } /* end main */
21
22 /* calculate and return cube of integer argument */
23 int cubeByValue( int n )
24 {
25 return n * n * n; /* cube local variable n and return result */
26
27 } /* end function cubeByValue */

The original value of number is 5

The new value of number is 125
18
1 /* Fig. 7.7: fig07_07.c
2
3
Cube a variable using call-by-reference with a pointer argument */
Outline
4 #include <stdio.h> Function prototype takes a pointer argument 19
5
6 void cubeByReference( int *nPtr ); /* prototype */
fig07_07.c
7
8 int main( void )
9
10
{
int number = 5; /* initialize number */
Call by Reference
11
12 printf( "The original value of number is %d", number );
13
Function cubeByReference is
14 /* pass address of number to cubeByReference */
15 cubeByReference( &number );
passed an address, which can be the
16 value of a pointer variable
17 printf( "\nThe new value of number is %d\n", number );
18
19 return 0; /* indicates successful termination */
20
21 } /* end main */
22
23 /* calculate cube of *nPtr; modifies variable number in main */
24 void cubeByReference( int *nPtr ) In this program, *nPtr is number, so this
25 {
statement modifies the value of number
26 *nPtr = *nPtr * *nPtr * *nPtr; /* cube *nPtr */
27 } /* end function cubeByReference */
itself.

The original value of number is 5

The new value of number is 125
19
 20

Fig. 7.9 | Analysis of a typical call-by-

reference with a pointer argument.

20
Fig. 7.8 | Analysis of a typical call-by-value.
Pointer to Array 21

• Sebenarnya sebuah nama array merupakan 
constant pointer pada elemen pertama dari array 
tersebut. 
– Contoh: 
double balance[50];
balance secara otomatis adalah pointer ke &balance[0]
• Kita dapat juga membuat pointer baru yang 
menunjuk ke array
double *pPtr;
double balance[10];
pPtr = balance;
Assign pPtr alamat element pertama dari array balance tanpa 
menggunakan tanda &
21
 22

• Mis. array tipe integer array b[5] dan 
pointer integer pointer variable bPtr
– bPtr = b; bPtr = &b[ 0 ];
• *( bPtr + 3 ) sama dengan elemen array ke‐
4 atau b[3] 

22
 Array values using pointer
*(p + 0) : 1000.0
*(p + 1) : 2.0 23
#include <stdio.h> *(p + 2) : 3.4
*(p + 3) : 17.0
int main () *(p + 4) : 50.0
{
Array values using balance as
/* an array with 5 elements */ address
double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};
*(balance + 0) : 1000.0
double *p;
*(balance + 1) : 2.0
int i;
*(balance + 2) : 3.4
p = balance;
/* output each array element's value */
*(balance + 3) : 17.0
printf( "Array values using pointer\n"); *(balance + 4) : 50.0
for ( i = 0; i < 5; i++ )
{
printf("*(p + %d) : %.1f\n", i, *(p + i) );
}
printf( "Array values using balance as address\n");
for ( i = 0; i < 5; i++ )
{
printf("*(balance + %d) : %.1f\n", i, *(balance + i) );
}
return 0; 23
}
Mengirim array ke function  24
(call‐by‐reference)
• Karena nama array sudah merupakan
pointer, maka ketika kita mem‐passing 
array ke function secara by reference, tidak
perlu lagi menggunakan tanda &
• Mengirimkan secara by reference pada
contoh sebelumnya:
double (&num); //num adalah variable

Contoh berikutnya:
convertToUppercase( string ); /*string adalah array.
Tanpa tanda & */
24
1 /* Fig. 7.10: fig07_10.c
2
3
Converting lowercase letters to uppercase letters
using a non-constant pointer to non-constant data */
Outline
4 25
5 #include <stdio.h>
6 #include <ctype.h>
7
fig07_10.c
8 void convertToUppercase( char *sPtr ); /* prototype */
9 (1 of 2 )
10 int main( void )
11 {
12 char string[] = "characters and $32.98"; /* initialize char array */
13
14 printf( "The string before conversion is: %s", string ); String is array, so send without &
15 convertToUppercase( string ); /* send without & */
16 printf( "\nThe string after conversion is: %s\n", string );
17
18 return 0; /* indicates successful termination */
19
20 } /* end main */
21

25
22 /* convert string to uppercase letters */
23 void convertToUppercase( char *sPtr )
24 {
Outline
25 while ( *sPtr != '\0' ) { /* current character is not '\0' */ 26
26
27 if ( islower( *sPtr ) ) { /* if character is lowercase, */
fig07_10.c
28 *sPtr = toupper( *sPtr ); /* convert to uppercase */
29 } /* end if */
30
(2 of 2 )
31 ++sPtr; /* move sPtr to the next character */ Both sPtr and *sPtr are modified by the
32 } /* end while */ convertToUppercase function
33
34 } /* end function convertToUppercase */

The string before conversion is: characters and $32.98

The string after conversion is: CHARACTERS AND $32.98

26
 27

Latihan

Silakan dikerjakan latihan 1 dan 2 di 
EMAS
Submit by 16:00 WIB hari ini