Array dan Pointer
Dalam programming, salah satu masalah yang paling sering ada adalah masalah mengatur/menyimpan variable bertipe sama. Untuk mengatasi, kita dapat menggunakan Array. Tapi, apa itu array? Jadi...
Apa itu Array?
Array merupakan suatu tipe data terstruktur yang dapat menyimpan banyak variable bertipe sama. Nilai dari array tersimpan dalam memori secara berurutan dan dapat diakses berdasarkan indexnya.
Misalkan, terdapat 500 mahasiswa dan kita ingin membuat variablenya, maka merupakan hal yang sangat tidak efektif jika kita membuat sebanyak 500 variable mahasiswa. Untuk mengatasinya, kita dapat membuat sebuah array yang dapat menyimpan 500 data mahasiswa tersebut.
Karakteristik array
Homogenous
Semua elemen memiliki nilai yang sama
Random Access
Setiap elemen dapat diakses secara acak
Array memiliki 2 jenis tipe:
Array memiliki 2 jenis tipe:
- One Dimensional Array
- Multidimensional Array
One Dimensional Array
Syntax:
type array_value [value_dim];
type merupakan tipe data C yang valid
array_value merupakan nama dari array
value_dim merupakan size dari array
array_value merupakan nama dari array
value_dim merupakan size dari array
Contoh:
int A[10];
Dibawah ini merupakan visualisasi array satu dimensi
Index array selalu dimluai dari 0
Inisialisasi Array
Array diinisialisasi menggunakan kurung keriting ({ })
Array diinisialisasi menggunakan kurung keriting ({ })
Contoh:
int B[4]={1, 2, -4, 8};
Berdasarkan contoh diatas, maka size dari array diatas adalah 4.
Tidak penting untuk menentukan size array pada inisialisasi.
Contoh:
int B[]={1, 2, -4, 8};
Dalam kasus ini, compiler menentukan size dari array berdasarkan jumlah value dari array, yaitu 4.
Tidak penting untuk menentukan size array pada inisialisasi.
Contoh:
int B[]={1, 2, -4, 8};
Dalam kasus ini, compiler menentukan size dari array berdasarkan jumlah value dari array, yaitu 4.
Ingat bahwa index dari array selalu dimulai dari 0, jadi index terakhir dari array adalah size array-1.
Jumlah nilai dari array pada inisialisasi tidak harus sama dengan size dari array.
Contoh:
int B[8]={1, 2, -4, 8};
Berdasarkan contoh diatas, jumlah variable dari array hanyalah 4, sedangkan size dari array diatas adalah 8, maka nilaai sisanya akan bernilai 0.
Namun, jumlah nilai dari array pada inisialisasi tidak boleh lebih dari size yang ditentukan.
Contoh:
int B[4] = { 1, 2, -4, 8, 9 }; //error
int B[4] = { 1, 2, -4, 8, 9 }; //error
Disebabkan karena tidak adanya alokasi memori yang lebih buat nilai array ke 5.
Example array initialization after definition:
int A[5];
(for i=0; i<5;i++) A[i]=0;
int B[5];
B[5]={0,0,0,0,0};
Error, why ?
Accessing Arrays
Two analogous ways of accessing an element i=2;
*(A+2) or A[2]
A is equivalent with &A[0] or a constant pointer to the first element of particular array
To show A[2] on the monitor screen:
printf(“%d”,A[2]) or
printf(“%d\n”,*(A+2));
Assigning Values
Assigning value to an element
Example : A[6] = 15; A[3] = 27;
Statement A[2] = A[3] - A[6], resulting:
Pointer Constant & Pointer Variable
Pointer variable is a pointer that can be assigned with new value at run-time.
Pointer constant is a pointer that can not be assigned with new value at run-time
Array is Pointer Constant to its first element of the array. Array can be filled with pointer variable.
Example:
int x=10, y=20;
int *ptr; //ptr is pointer variable
ptr = &x;
ptr = &y;
Example:
int x=10, y=20;
int B[4]; // B is an Array pointer constant
int *ptr; // ptr is a pointer variable
ptr = &x; // ok
ptr = B; // ok
ptr++; // ok
B = ptr; // error
B++; // error
B = &y; // error
ptr = B; analogous with ptr = &B[0]; B is a pointer constant pointing to the first element of an array.
Pointer constant can only be initialized at definition time
Example:
int Arr1[10];
Arr1[10] = {1, 2, 3, 4, 5}; // error
Arr1 = {1, 2, 3, 4, 5}; // error
Arr1[10] = 12; // error max 9
Arr1[0] = 23; // ok
int Arr2[10] = {1, 2, 3, 4, 5}; //ok
Accessing Arrays
Accessing array using a pointer
int arr[10];
int *ptr_arr;
ptr_arr = arr; //or ptr_arr = &arr[0];
To access certain element can be done using:
ptr_arr[i];
arr[i];
*(ptr_arr + i);
*(arr + i);
ptr_arr = ptr_arr + i; *ptr_arr;
Array: Program Examples
Example:
#include <stdio.h>
void main()
{
int i;
int list_int[10];
for (i=0; i<10; i++){
list_int[i] = i + 1;
printf( "list_int[%d] init with %d.\n", i, list_int[i]);
}
}
One Dimensional Array
C compiler does not limit number of dimensional which can be created. Our PC memory does.
Example Array 1D:
#include<stdio.h>
int SIZE = 5;
void main() {
int i, j;
int n[SIZE] = {15, 9, 1, 7, 5};
for( i=0 ; i<= SIZE ; i++) {
printf("%5d ", n[i]);
for ( j=1; j<=n[i] ; j++) printf("%c","*");
printf("\n");
}
Two Dimensional Array
Syntax 2D Array:
type name_array[row][col];
Example:
int a[3][4];
Initialization:
using rmo (row major order)
Example:
int b[2][2] = {1, 2, 3, 4 };
int b[2][2] = { { 1, 2 }, { 3, 4 } };
int b[2][2] = { { 1 }, { 3, 4 } };
int x[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
int x[3][4] = { {1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
Example Array 2D:
/* Printing out array 2-D */
#include <stdio.h>
void main() {
int two_dim[3][5] = {1, 2, 3, 4, 5,
10, 20, 30, 40, 50,
100, 200, 300, 400, 500};
int i, j;
for (i=0; i<3; i++){
for (j=0; j<5; j++) printf("%6d", two_dim[i][j]);
printf("\n");
}
}
Output:
1 2 3 4 5
10 20 30 40 50
100 200 300 400 500
Three Dimensional Array
Syntax 3D Array :
type name_array[row][col][depth];
Example:
int x[3][2][4] = {{{1,2,3,4}, {5,6,7,8}},
{{11,12,13,14}, {15,16,17,18}},
{{21,22,23,24}, {25,26,27,28}}
};
void main() {
int x[4][3][5] = {{{1, 2, 3}, {0, 4, 3, 4}, {1, 2}},
{{9, 7, 5}, {5, 7, 2}, {9}},
{{3, 3, 5}, {2, 8, 9, 9}, {1, 2, 1}},
{{0}, {1}, {0, 1, 9}}
};
printf(“%5d”, x[2][1][3]);
}
Array of Pointer
An array filled with pointer/s
Syntax :
type *array_name [value_dim];
Example:
int i;
int *ptr[4];
int x=1, y=2, z=3, w=5;
ptr[0]=&x, ptr[1]=&y; ptr[2]=&z; ptr[3]=&w;
for(i=0;i<4;i++) printf("%d ",*ptr[i]);
Output : 1 2 3 5
Array of Character
Array filled with character/s
Syntax:
char array_name[value_dim];
Example:
char name[40];
char ss[20]={‘B’,’I’,’N’,’U’,’S’}; //20 elements
char ss[ ]= {‘B’,’I’,’N’,’U’,’S’}; // 5 elements
StringString is an array of character that ended with null character ( ‘\0’ or in ASCII = 0)
String constant or string literal is some characters written between double quote
Example: ”Welcome to Binus”
String constant type is pointer constant, thus can be assigned to an array of character :
Example :
char name[40] = ”Amir”; //ok
name = ”Amir”; // error name is a constant pointer
Name[40]= “Amir”; //error
A Constant String can be linked at compile-time:
”Hello,” ” world”
Similar to:
”Hello, world”
Example string initialization:
char s[ ] = ”BiNus”;
Similar to :
char s[ ] = {’B’,’i’,’N’,’u’,’s’,’\0’};
String as a data type does not known in C
Char vs String
Character in c written between single quote. Each uses one byte of computer memory
Example:
char ch=’A’;
char ch=65; //Ascii
char ch=0x41; //Ascii
String written in between double quote.
String Manipulation
In Standard Library Function (header file string.h) provides functions to manipulate string:
strlen()
Return a value of string length; excluded null char
strcpy(s1,s2)
Copy s2 to s1
strncpy(s1,s2,n)
Copy first n characters of s2 to s1
strcat(s1,s2)
Adding string s2 to the end of string s1
strncat(s1,s2,n)
Adding n characters of string s2 to the end of string s1
strcmp(s1,s2)
Comparing the value of string s1 and s2, if similar returning 0
etc.
////
////
Apa itu Pointer?
Pointer adalah sebuah variable yang menyimpan alamat dari variable lain, seperti, alamat langsung dari lokasi memori. Seperti variable lainnya, Pointer juga harus di deklarasi terlebih dahulu sebelum bisa digunakan.
Syntax :
<type> *ptr_name;
type merupakan tipe dasar dari pointer, harus merupakan tipe data C yang valid
ptr_name merupakan nama variable dari pointer
*(asterisk) untuk menunjukkan sebuah variable sebagai pointer
ptr_name merupakan nama variable dari pointer
*(asterisk) untuk menunjukkan sebuah variable sebagai pointer
Contoh :
int *ip; /* pointer ke integer */
double *dp; /* pointer ke double */
float *fp; /* pointer ke float */
char *ch /* pointer ke character */
int *ip; /* pointer ke integer */
double *dp; /* pointer ke double */
float *fp; /* pointer ke float */
char *ch /* pointer ke character */
Bagaimana Cara Menggunakan Pointer?
Ada 3 langkah penting dalam menggunakan pointer:
1. Tetapkan variable pointer
2. Berikan alamat dari sebuah variable ke variable pointer
3. Akses nilai pada alamat sebuah variable menggunakan unary operator *
Contoh :
#include <stdio.h>
int main () {
int var = 20;
int *ip;
ip = &var; /* simpan alamat variable var ke pointer ip */
printf("Alamat variable var: %x\n", &var );
/* alamat yang tersimpan pada variable pointer ip */
printf("Alamat yang tersimpan dalam variable ip: %x\n", ip );
/* akses nilai menggunakan pointer */
printf("Nilai variable *ip: %d\n", *ip );
return 0;
}
Output:
Alamat variable var: bffd8b3c
Alamat yang tersimpan dalam variable ip: bffd8b3c
Nilai variable *ip: 20
Berdasarkan contoh diatas, alamat dari variable var di simpan pada variable pointer ip. Karena alamat dari variable var adalah bffd8b3c, maka alamat dari variable ip adalah sama. Selanjutnya, untuk mendapatkan nilai dari alamat variable var, kita dapat menggunakan tanda * berarti isi/nilai, yang dalam contoh ini, nilai dari alamat var.
Konsep Pointer
Untuk mengubah nilai dari sebuah pointer, dapat dilakukan dengan
*<nama variable> = x;
maka nilai dari variable pointer dan variable yang alamatnya ditetapkan pada pointer berubah.
*<nama variable> = x;
maka nilai dari variable pointer dan variable yang alamatnya ditetapkan pada pointer berubah.
Pointer to Pointer
Pointer to pointer merupakan sebuah rantai pointer atau pointer yang menyimpan alamat dari pointer lain. Silahkan lihat gambar dibawah untuk lebih jelasnya.
Syntax:
<type> **ptr_ptr ;
** menunjukkan pointer yang mengarah ke pointer lain. Biasanya pointer yang mengarah ke pointer lain disebut sebagai double pointer.
Contoh:
#include <stdio.h>
int main () {
int var;
int *ptr;
int **pptr;
var = 3000;
/* mengambil alamat variable var */
ptr = &var;
/* mengambil alamat variable pointer ptr */
pptr = &ptr;
/* mengambil nilai variable pptr */
printf("Nilai dari var = %d\n", var );
printf("Nilai dari *ptr = %d\n", *ptr );
printf("Nilai dari **pptr = %d\n", **pptr);
return 0;
}
Output:
Value of var = 3000
Value available at *ptr = 3000
Value available at **pptr = 3000
Berdasarkan contoh diatas, variable pptr mengarah ke alamat variable ptr yang mengarah ke alamat variable var. Karena nilai dari var = 3000, maka nilai dari ptr dapat diambil dengan menggunakan * dan nilai dari pptr dapat diambil dengan menggunakan **(double pointer) adalah sama dengan nilai dari var, yaitu 3000.
Konsep Pointer to Pointer
Untuk mengubah nilai dari sebuah pointer to pointer(double pointer), dapat dilakukan dengan
**<nama variable> = x;
maka nilai dari variable pointer to pointer(double pointer) dan semua variable yang alamatnya terkait pada pointer to pointer(double pointer) berubah. Jadi, jika nilai dari double pointer diubah, maka nilai dari single pointer dan variable yang terikat pada single pointer akan berubah.
**<nama variable> = x;
maka nilai dari variable pointer to pointer(double pointer) dan semua variable yang alamatnya terkait pada pointer to pointer(double pointer) berubah. Jadi, jika nilai dari double pointer diubah, maka nilai dari single pointer dan variable yang terikat pada single pointer akan berubah.
Comments
Post a Comment