Mengganti Vector 2 Dimensi dengan Menggunakan Referensi Pada Fungsi

May 23, 2013 by · Leave a Comment 

Beberapa minggu yang lalu, saya kesulitan dalam melewatkan array 2D sebagari referensi dari satu fungsi ke fungsi lain. Di tengah-tengah kesulitan tersebut, saya menemukan sebuah tulisan yang mengatakan bahwa memang cukup sulit untuk melewatkan array 2 dimensi dengan menggunakan referensi alamat. Namun, kita tetap bisa melemparkan (return) sebuah referensi dari sebuah fungsi ke dalam sebuah pointer. Jadi sifatnya hanya 1 arah (return), tidak seperti referensi yang variabelnya akan berubah nilainya di dalam fungsi yang memanipulasinya.

Karena tidak puas, saya mencoba bermain-main dengan vector. Pada awalnya saya memang agak kesulitan, namun setelah dipelajari lebih mendalam, tidak sulit untuk mengontrol vector yang kita buat. Ternyata, vector ini bisa dilewatkan sebagai referensi ke dalam sebuah fungsi :D. Wow, saya cukup senang karena memang itu yang saya inginkan. Penggunaannya juga tidak jauh berbeda dengan melewatkan variabel pada umumnya. Sebagai contoh, di bawah ini adalah sebuah program untuk membuat sebuah vector 2 dimensi, lalu memanggil sebuah fungsi untuk memanipulasi vector tersebut, kemudian menampilkan isi vector yang sudah diganti tersebut.

#include <iostream>
#include <vector>
using namespace std;
 
void manipulasiVector(vector<vector<double> > &);
 
int main()
{
	typedef vector<double> vint;
	vint tmp(4);
	vector<vint> matriks(3);
	int i=0, j=0;
	cout << endl;
	for(i=0; i<3; i++){
		for(j=0; j<4; j++){
			tmp[j]=12*i+j;
			matriks[i]=tmp;
			cout << matriks[i][j] << " ";
		}
		cout << endl;
	}
	manipulasiVector(matriks);
	for(i=0; i<3; i++){
		for(j=0; j<4; j++){
			cout << matriks[i][j] << " ";
		}
		cout << endl;
	}
	return 0;
}
 
 
void manipulasiVector(vector<vector<double> > &v){
	int i=0,j=0;
	vector<double> tmp(10);
	for(i=0; i<3; i++){
		for(j=0; j<4; j++){
			tmp[j]= 8+i+j;
			v[i] = tmp;
		}
		cout << endl;
	}
}

Mengembalikan Pointer Array 2D dari Fungsi

April 23, 2013 by · Leave a Comment 

Ketika kita membuat sebuah variabel yang diinisialisasi dengan pointer, variabel tersebut bisa dilewatkan ke dalam sebuah fungsi dan dikembalikan dalam bentuk alamat (pointer). Ketika berpindah-pindah dari satu fungsi ke fungsi lain, nilai pointer akan berubah secara dinamik (pass by address). Namun, saya mencoba membuat sebuah array 2D dan ingin melewatkan alamat pointer tersebut ke sebuah fungsi, yang nantinya fungsi tersebut akan mengganti isi array kemudian mengembalikan alamat pointer array tersebut. Sayang sekali banyak artikel yang mengatakan bahwa kita tidak bisa melewatkan pointer array 2D melalui fungsi yang telah didefinisikan.

Meskipun pointer array tidak bisa dilewatkan melalui fungsi, namun fungsi masih tetap bisa mengembalikan pointer array 2D. Jadi array 2D dibentuk di dalam fungsi, lalu alamatnya dikembalikan dan selanjutnya bisa dimasukkan ke dalam pointer lain.

Kode di bawah ini adalah cara yang saya temukan di internet. Mungkin ada cara lain, tapi saya belum mengetahuinya 🙂

#include <iostream>
using namespace std;
 
int** editArray();
int main(){
	int i=0, j=0;
	int **arr;
	arr=editArray();
	for(i=0; i<2; i++){
		for(j=0; j<4; j++){
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}
	//system("pause");
}
 
int** editArray(){
	int** tmp;
	tmp = 0;
	tmp = new int*[100]; // 100 baris -> tmp [100][x];
	int i=0;
 
	/* Untuk kemudahan, 2 buah contoh cara memasukkan nilai pada variable
		pada array 'tmp' diberikan dalam 1 fungsi. 
		Silahkan berikan komentar pada baris-baris pada salah satu contoh
		agar 1 cara saja yang dipakai.
	*/
 
	/* Contoh 1: memasukkan nilai awal */
	for(i=0; i<2; i++){
		tmp[i] = new int[4];	// 4 kolom -> tmp[100][4]
		tmp[i][0] = (i+2)*1;
		tmp[i][1] = (i+2)*2;
		tmp[i][2] = (i+2)*3;
		tmp[i][3] = (i+2)*4;
	}
 
	/* Contoh 2: mengedit array */
	tmp[0] = new int[4];
	tmp[0][0]=2;
	tmp[0][1]=3;
	tmp[0][2]=4;
	tmp[0][3]=5;
 
	tmp[1] = new int[4];
	tmp[1][0]=20;
	tmp[1][1]=30;
	tmp[1][2]=40;
	tmp[1][3]=50;
 
    return tmp;
}

Melewatkan Fungsi sebagai Parameter Fungsi dalam C++

February 23, 2013 by · Leave a Comment 

Bukan hanya variabel yang bisa dilewatkan pada sebuah fungsi dalam pemrograman C/C++. Fungsi juga bisa dilewatkan sebagai parameter. Konsepnya hampir sama saja, namun dengan sedikit tambahan syntax agar fungsi bisa dilewatkan dan berhasil dijalankan. Umumnya, pemanggilan fungsi dilakukan untuk menjalankan fungsi di dalam fungsi. Lebih jelasnya, ketika program memanggil sebuah fungsi, maka kita melewatkan sebuah fungsi sebagai parameter untuk kemudian dijalankan oleh fungsi pertama tadi.

Untuk bisa mendemonstrasikan contoh bagaimana melewatkan fungsi sebagai parameter, dibutuhkan paling tidak 2 fungsi selain fungsi utama (main). Dalam contoh di bawah ini, kita menggunakan 2 fungsi: trigger() dan sum(). Fungsi trigger() akan dipanggil di program utama. Fungsi sum() akan dilewatkan sebagai parameter fungsi trigger() untuk kemudian dijalankan di dalam fungsi trigger() itu sendiri.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;
 
int trigger(int (*)(int));
int sum(int end);
 
int main(){
	cout << trigger(&sum) << endl;
	return 0;
}
 
int trigger(int (*f)(int)){
	int end=50;
	return (*f)(end);
 
}
int sum(int end){
	int i, sum=0;
	for(i=0; i<end; i++){
		sum += i;
	}
	return sum;
}

Untuk melewatkan fungsi sebagai parameter, kita harus menuliskan tipe kembalian fungsi, lalu pointer yang menunjuk ke nama fungsi, dan tipe parameter fungsi.

4
int trigger(int (*)(int));

Bentuk int (*)(int) merupakan bentuk yang sama dengan nama fungsi yang akan dipanggil:

int sum(int end);

Untuk deklarasi fungsi tersebut, kita menggunakan pointer agar bisa memanggil fungsi yang dimaksud.

int trigger(int (*f)(int)){
	int end=50;
	return (*f)(end); // dalam kasus ini, artinya sama dengan -> return sum(end);
 
}

Untuk menggunakan fungsi trigger() dalam program utama, kita melewatkan referensi fungsi sum() di dalam parameter fungsi trigger.

trigger(&sum)

Bagaimana jika ingin melewatkan fungsi beserta dengan parameternya? Kita tinggal menambah parameter lain di dalam fungsi yang memanggil tadi. Pada kasus di atas, variabel end dideklarasikan di dalam fungsi trigger. Dalam contoh di bawah ini, variabel end akan dideklarasikan di dalam fungsi main dan akan dilewatkan dalam fungsi trigger.

#include <iostream>
using namespace std;
 
int trigger(int (*)(int), int);
int sum(int end);
 
int main(){
	int end = 50;
	cout << trigger(&sum, end) << endl;
	return 0;
}
 
int trigger(int (*f)(int), int end){
	return (*f)(end);	
}
int sum(int end){
	int i, sum=0;
	for(i=0; i<end; i++){
		sum += i;
	}
	return sum;
}

Secara teknis, kita tidak bisa melewatkan parameter bersamaan dengan nama fungsi yang dipanggil, contohnya:

trigger(&sum(4)); // tidak akan berhasil dicompile

Oleh karena itulah, parameter fungsi yang akan dilewatkan diberikan sebagai parameter tambahan seperti potongan kode di bawah ini.

int trigger(int (*f)(int), int end){
	return (*f)(end);	
}
trigger(&sum, 5);

Pointer dan Reference

February 20, 2013 by · Leave a Comment 

Beberapa hari ini saya kembali belajar tentang bahasa pemrograman C++ namun dengan cakupan yang lebih luas dan mendalam. Dari dulu saya berusaha mencoba membaca source code C++ dalam proyek mini seseorang, namun tetap saja dengan pemahaman C++ yang pas-pasan malah membuat saya tidak betah berlama-lama dengan bahasa yang satu ini. Syukurlah dengan pembelajaran yang intensif saya sedikit bisa mengerti konsep dalam bahasa C++ yang sebelumnya tidak saya pahami.

Agar lebih konkrit, saya ingin membawakan sedikit pengetahuan yang saya peroleh mengenai pointer ke dalam sebuah artikel.

Dilihat dari datanya, sebuah variabel sebenarnya menyimpan 2 buah nilai: alamat variabel itu dan nilai variabel itu. Untuk bisa mengakses alamat ini, ada 2 cara yang bisa dipakai: menggunakan referensi atau menggunakan pointer.

Contoh di bawah ini adalah menggunakan referensi. Alamat variabel bisa diakses dengan menggunakan tanda & di depaan variabel yang ingin dilihat. Nilai x bisa berubah setiap saat namun alamatnya tidak akan berubah. Ibaratnya penghuni rumah mungkin akan berganti orang, namun sebuah rumah di sebuah perkampungan akan memiliki alamat yang tetap.

1
2
3
4
5
6
int x = 12;
cout << "Nilai:" << x << endl; //mengakses nilai x=12
cout << "Alamat:" << &x << endl; //mengakses alamat -> A
x = 14;
cout << "Nilai:" << x << endl; //mengakses nilai, x=14
cout << "Alamat:" << &x << endl; //mengakses alamat -> A (alamat tetap)

Potongan kode di bawah ini adalah cara untuk mendeklarasikan sebuah pointer p yang menunjuk ke variabel x. Ada 2 cara untuk mendeklarasikan pointer: pertama adalah dengan mendeklarasikan langsung pada saat inisialisasi (contoh pada baris 2) dan cara lain adalah mendeklarasikan kemudian (contoh baris 3).

1
2
3
4
5
6
7
int x = 12;  // inisialisasi variabel x=12
int *p = &x; // alamat dari x disimpan ke dalam pointer p
p = &x;  // alamat dari x disimpan ke dalam pointer p, fungsinya sama dengan baris 2
*p=13; // nilai berubah menjadi *p=13 dan x=13, namun alamat nya tetap, yaitu yang berasal dari x
 
int y = 15;  // deklarasi variabel y
p = &y;  // alamat pointer p berubah ke alamat y, nilai *p=15

Dalam potongan kode di atas, p adalah sebuah variabel yang menyimpan alamat saja. Memang itulah kegunaan pointer, yaitu menyimpan sebuah alamat, sedangkan nilainya bergantung dari nilai dari alamat yang disimpannya. Ibaratnya, sebuah buku kontak hanya bisa menyimpan alamat rumah saja, namun jika kita pergi ke alamat rumah tersebut, bisa saja penghuninya berbeda tergantung siapa yang memiliki rumah tersebut.

Next Page »