Function & Recursive

Function
Sebelum mengenal mengenai function, ada baiknya kita mengenal mengenai modular programming.
Modular programming adalah suatu teknik dalam pemograman yang membagi program ke dalam beberapa module. Module ini biasanya disebut sebagai function atau disebut juga sebagai sub-program.

Module berfungsi untuk mengerjakan suatu pekerjaan yang spesifik, biasanya digunakan ketika pengerjaan terhadap suatu pekerjaan yang spesifik dilakukan berulang kali dalam satu proses.

Mengapa harus menggunakan module?
Beberapa keunggulan menggunakan module:
1. Suatu goal diraih dengan mengerjakan beberapa sub-goal terlebih dahulum, sehingga program yang besar terbagi menjadi module yang kecil
2. Mempermudah programmer/developer memahami code
3. Memudahkan pengecekan akan kesalahan
4. Modifikasi code dapat dilakukan tanpa harus mengubah keseluruhan code
5. Dokumentasi lebih mudah

Ada dua macam function dalam C:
1. Library function, sebagai contoh:
#include<stdio.h>    //library yang sudah disediakan oleh C dengan berbagai macam function

int main()
{
       int a = 7;
       printf("%d\n,a);   // salah satu contoh function yang telah disediakan C adalah printf();
       return 0;
}

2. User Defined Function, yaitu function yang didefinisikan oleh programmer sendiri
Function construction :
return-value-type function-name (parameter-list)
{

}

- return-value-type mengembalikan value berupa data-type yang diinginkan, seperti int, float, dll.
Jika return-value-type berupa void, maka tidak perlu return apapun.
- function-name adalah nama dari function, biasanya sesuai dengan tujuan yang ingin dicapai, misalnya function untuk menghitung pertambahan 2 angka, maka nama functionnya dapat berupa: sum_two_numbers, sumValue, dll
- parameter-list adalah parameter yang dikirimkan kepada function

Contoh User-Defined Function:
#include<stdio.h>

int sum(int num1, int num2)    //parameter yang diterima berupa dua buah int
                                                 //num1 dan num2  disebut formal parameter
{
     return num1+num2;    //return value jumlah num1 dan num2;
}

int main()
{
      int a = 8. b = 2;
      int c = sum(a,b);  //mengirimkan dua buah parameter, yaitu int dan int. hasil return dari function
                                  //sum(int,int) disimpan dalam variable c
                                 // a dan b disebut actual parameter
      printf("c = %d\n",c);  // c = 10;
      return 0;
}

Function Prototype
Function Prototype memastikan bahwa function sudah didefinisikan ketika dipanggil oleh function lain.
Contoh:

int main()
{
       printf("%d",angka());
       return 0;
}

int angka()
{
      return 4;
}

Dalam kasus ini, karena program membaca dari atas sampai bawah, maka saat program membaca di main(), program tidak mengenali function angka() sehingga menyebabkan error.

Dalam kasus ini, dapat melakukan pemindahan function angka() di atas main(), atau melakukan function prototype sebagai berikut.

int angka();

int main()
{
       printf("%d",angka());
       return 0;
}

int angka()
{
      return 4;
}
Passing Parameter
Ada dua macam passing parameter:
- Passing by Value, mengirimkan ke module lain berupa angka(jika int), character(jika char) dsb.
Contoh:
int multiply(int a, int b) // menerima parameter berupa angka
{
      return a*b;
}

int main()
{
      printf("%d",multiply(6,8)); // mengirimkan parameter berupa angka
                                                  // hasil : 48
      return 0;
}


- Passing by Reference/Location, mengirimkan ke module lain berupa address
Contoh:

int multiply(int *a, int *b) // menerima parameter berupa address
{
      return a*b;
}

int main()
{
      int x = 7, y = 3;
      printf("%d",multiply(&x,&y)); // mengirimkan parameter berupa address dari variable x dan y
      return 0;
}

Jika parameter yang dikirimkan berupa array 1D, maka parameter yang diterima harus berupa address
Contoh:

int sum_array(int *a, int jumlahArray) // dapat juga int a[]
{
      int sum = 0;
      for(int i = 0 ; i < jumlahArray ; i++)
     {
            sum += a[i];
      }
      return sum;
}

int main()
{
      int array[] = {1,2,3,4,5};
      int n = 5;
      printf("%d",sum_array(array,n));
      return 0;
}

Jika array berupa 2D, maka dapat dilakukan seperti berikut:
int print(int a[10][10]) atau int print(int a[][10])
namun tidak boleh:
int print(int a[10][]) atau int print(int a[][])

RECURSION
Recursion atau juga seringkali disebut recursive adalah fungsi yang memanggil dirinya sendiri.
Biasanya dalam recursion ada base case, yaitu suatu kondisi yang memberhentikan suatu function memanggil dirinya sendiri (agar tidak terjadi looping forever)
Dalam recursion juga ada reduction step, yaitu function call pada diri sndiri, namun mengirimkan parameter yang berbeda angka dari sebelumnya, yang mengarah pada base case.
Contoh yang paling umum untuk recursion adalah factorial

int factorial(int number)
{
      //base case, berhenti saat number == 0
      if(number == 0) return 1;
      return number * factorial(number-1); //reduction step, mengarah pada base case
}

int main()
{
     printf("%d",factorial(5)); // 120
     return 0;
}

Skema terjadinya recursive:
 //factorial(5) = 5!, factorial(4) = 4!, dst

5!

(5 * 4!)

(5 * (4 *3!))

(5 * (4 * (3 * 2!)))

(5 * (4 * (3 * (2 * 1!))))

(5 * (4 * (3 * (2 * (1 * 0!))))) // base case number == 0, return 1;

(5 * (4 * (3 * (2 * (1 * 1)))))

(5 * (4 * (3 * (2 *  1))))

(5 * (4 * (3 * 2)))

(5 * (4 * 6 ))

(5 * 24)

120

Iterative(Repetition/Looping) vs Recursive
Tidak ada hal yang pasti mengatakan bahwa iterative lebih baik atau lebih buruk dari recursive, namun dapat dipastikan bahwa dalam kasus tertentu lebih muda untuk menggunakan recursive dibanding iterative, begitu juga sebaliknya

Sebagai contoh, factorial dengan iterative

int main()
{
      int x = 5;
      int hasil = x;
      for(int i = x-1 ; i >0 ; i--)
      {
           hasil *= i; // 5*4*3*2*1
      }
      return 0;
}