control statement

Loop Control Statements

With loop control statements, you can repeatedly execute a block of code. There are two types of loops:

• for statements loop a specific number of times, and keep track of each iteration with an incrementing index variable.
  For example, preallocate a 10-element vector, and calculate five values:

  x = ones(1,10);
  for n = 2:6
      x(n) = 2 * x(n - 1);
  end

• while statements loop as long as a condition remains true.
  For example, find the first integer n for which factorial(n) is a 100-digit number:

  n = 1;
  nFactorial = 1;
  while nFactorial < 1e100
      n = n + 1;
      nFactorial = nFactorial * n;
  end

Each loop requires the end keyword.

It is a good idea to indent the loops for readability, especially when they are nested (that is, when one loop contains another loop):

A = zeros(5,100);
for m = 1:5
    for n = 1:100
        A(m, n) = 1/(m + n - 1);
    end
end

You can programmatically exit a loop using a break statement, or skip to the next iteration of a loop using a continue statement. For example, count the number of lines in the help for the magic function (that is, all comment lines until a blank line):

fid = fopen('magic.m','r');
count = 0;
while ~feof(fid)
    line = fgetl(fid);
    if isempty(line)
       break
    elseif ~strncmp(line,'%',1)
       continue
    end
    count = count + 1;
end
fprintf('%d lines in MAGIC help\n',count);
fclose(fid);

2. if else 

If else statements in C is also used to control the program flow based on some condition, only the difference is: it's used to execute some statement code block if the expression is evaluated to true, otherwise executes else statement code block. 

The basic format of if else statement is:

Syntax:

if(test_expression)
{
   //execute your code
}
else
{
   //execute your code
}


Figure - Flowchart of if-else Statement:



example for a C program to demonstrate if-else statemants

for the example:

#include<stdio.h>

main()
{
  int a, b;

  printf("Please enter the value for a:");
  scanf("%d", & amp; a);

  printf("\nPlease the value for b:");
  scanf("%d", & amp; b);

  if (a & gt; b) {  
    printf("\n a is greater");
  } else {  
    printf("\n b is greater");
  }
}

3. While loop/Do while loop

Do while loop


From Wikipedia, the free encyclopedia




Jump to navigationJump to search










Do While loop flow diagram



Loop constructs
Do while loop
While loop
For loop
Foreach loop
Infinite loop
Control flow


In most computer programming languages, a do while loop is a control flow statement that executes a block of code at least once, and then repeatedly executes the block, or not, depending on a given boolean condition at the end of the block.

The do while construct consists of a process symbol and a condition. First, the code within the block is executed, and then the condition is evaluated. If the condition is true the code within the block is executed again. This repeats until the condition becomes false. Because do while loops check the condition after the block is executed, the control structure is often also known as a post-test loop. Contrast with the while loop, which tests the condition before the code within the block is executed, the do-while loop is an exit-condition loop. This means that the code must always be executed first and then the expression or test condition is evaluated. If it is true, the code executes the body of the loop again. This process is repeated as long as the expression evaluates to true. If the expression is false, the loop terminates and control transfers to the statement following the do-while loop. In other words, whereas a while loop sets the truth of a statement as a condition precedent for the code's execution, a do-while loop provides for the action's ongoing execution subject to defeasance by the condition's falsity, which falsity (i.e., the truth of the condition's negation) is set as a condition subsequent.

It is possible, and in some cases desirable, for the condition to always evaluate to true, creating an infinite loop. When such a loop is created intentionally, there is usually another control structure (such as a break statement) that allows termination of the loop.

Some languages may use a different naming convention for this type of loop. For example, the Pascal language has a "repeat until" loop, which continues to run until the control expression is true (and then terminates) — whereas a "while" loop runs while the control expression is true (and terminates once the expression becomes false).




Equivalent constructs[edit]

do {
    do_work();  
} while (condition);



is equivalent to

do_work();

while (condition) {
    do_work();
}



In this manner, the do ... while loop saves the initial "loop priming" with do_work(); on the line before the while loop.

As long as the continue statement is not used, the above is technically equivalent to the following (though these examples are not typical or modern style used in everyday computers):

while (true) {
   do_work();
   if (!condition) break;
}



or

LOOPSTART:
    do_work();
    if (condition) goto LOOPSTART;

Demonstrating do while loops





These example programs calculate the factorial of 5 using their respective languages' syntax for a do-while loop.






ActionScript 3[edit]





var counter: int = 5;
var factorial: int = 1;

do {
    factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);

trace(factorial);








Ada[edit]



The Wikibook Ada_Programming has a page on the topic of: Control





with Ada.Integer_Text_IO;

procedure Factorial is
    Counter   : Integer := 5;
    Factorial : Integer := 1;
begin
    loop
        Factorial := Factorial * Counter;
        Counter   := Counter - 1;
        exit when Counter = 0;
    end loop;

    Ada.Integer_Text_IO.Put (Factorial);
end Factorial;





BASIC[edit]


Early BASICs (such as GW-BASIC) used the syntax WHILE/WEND. Modern BASICs such as PowerBASIC provide both WHILE/WEND and DO/LOOP structures, with syntax such as DO WHILE/LOOP, DO UNTIL/LOOP, DO/LOOP WHILE, DO/LOOP UNTIL, and DO/LOOP (without outer testing, but with a conditional EXIT LOOP somewhere inside the loop). Typical BASIC source code:


Dim factorial As Integer
Dim counter As Integer

factorial = 1
counter = 5

Do 
    factorial = factorial * counter
    counter = counter - 1
Loop While counter > 0

Print factorial




C#[edit]


int counter = 5;
int factorial = 1;

do {
    factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);

System.Console.WriteLine(factorial);




C[edit]


int counter = 5;
int factorial = 1;

do {
    factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);

printf("factorial of 5 is %d\n", factorial);




Do-while(0) statements are also commonly used in C macros as a way to wrap multiple statements into a regular (as opposed to compound) statement. It makes a semicolon needed after the macro, providing a more function-like appearance for simple parsers and programmers as well as avoiding the scoping problem with if. It is recommended in CERT C Coding Standard rule PRE10-C.[1]


C++[edit]


int counter = 5;
int factorial = 1;

do {
    factorial *= counter--;
} while (counter > 0);

std::cout << "factorial of 5 is "<< factorial << std::endl;

4. Switch Statement in C/C++




Switch case statements are a substitute for long if statements that compare a variable to several integral values

The switch statement is a multiway branch statement. It provides an easy way to dispatch execution to different parts of code based on the value of the expression.
Switch is a control statement that allows a value to change control of execution.


Syntax:


switch (n)
{
    case 1: // code to be executed if n = 1;
        break;
    case 2: // code to be executed if n = 2;
        break;
    default: // code to be executed if n doesn't match any cases
}
Important Points about Switch Case Statements:

1. The expression provided in the switch should result in a constant value otherwise it would not be valid.

Valid expressions for switch:

// Constant expressions allowed
switch(1+2+23)
switch(1*2+3%4)

// Variable expression are allowed provided
// they are assigned with fixed values
switch(a*b+c*d)
switch(a+b+c)







2.  Duplicate case values are not allowed.



3.  The default statement is optional.Even if the
switch case statement do not have a    default
statement,

it would run without any problem.



4.  The break statement is used inside the switch
to terminate a statement sequence. When a break statement is reached, the
switch terminates, and the flow of control jumps to the next line following the
switch statement.



5.  The break statement is optional. If omitted,
execution will continue on into the next case. The flow of control will fall
through to subsequent cases until a break is reached.



6.  Nesting of switch statements are allowed,
which means you can have switch statements inside another switch. However
nested switch statements should be avoided as it makes program more complex and
less readable.

Example:

·        C 

 


  

// Following is a simple C program  

// to demonstrate syntax of switch. 

#include <stdio.h> 

int main()
  

{ 

   int
  x = 2; 

   switch
  (x) 

   { 

       case 1: printf("Choice is
  1"); 

               break;
  

       case 2: printf("Choice is
  2"); 

                break;
  

       case 3: printf("Choice is
  3"); 

               break;
  

       default:
  printf("Choice other than 1, 2 and 3"); 

                break;  
  

   } 

   return
  0; 

}  

 


Output:

Choice is 2
5.break and continue






C break


The break statement ends the loop immediately when it is encountered. Its syntax is:
break;

The break statement is almost always used with if...else statement inside the loop.

How break statement works?

Example 1: break statement
// Program to calculate the sum of a maximum of 10 numbers
// If a negative number is entered, the loop terminates

# include <stdio.h>
int main()
{
    int i;
    double number, sum = 0.0;

    for(i=1; i <= 10; ++i)
    {
        printf("Enter a n%d: ",i);
        scanf("%lf",&number);

        // If the user enters a negative number, the loop ends
        if(number < 0.0)
        {
            break;
        }

        sum += number; // sum = sum + number;
    }

    printf("Sum = %.2lf",sum);
    
    return 0;
}

Output
Enter a n1: 2.4
Enter a n2: 4.5
Enter a n3: 3.4
Enter a n4: -3
Sum = 10.30

This program calculates the sum of a maximum of 10 numbers. Why a maximum of 10 numbers? It's because if the user enters a negative number, the break statement is executed. This will end the for loop, and the sum is displayed.

In C, break is also used with the switch statement. This will be discussed in the next tutorial.

C continue

The continue statement skips the current iteration of the loop and continues with the next iteration. Its syntax is:
continue;

The continue statement is almost always used with the if...else statement.

How continue statement works?

Example 2: continue statement
// Program to calculate the sum of a maximum of 10 numbers
// Negative numbers are skipped from the calculation

# include <stdio.h>
int main()
{
    int i;
    double number, sum = 0.0;

    for(i=1; i <= 10; ++i)
    {
        printf("Enter a n%d: ",i);
        scanf("%lf",&number);

        if(number < 0.0)
        {
            continue;
        }

        sum += number; // sum = sum + number;
    }

    printf("Sum = %.2lf",sum);
    
    return 0;
}

Output
Enter a n1: 1.1
Enter a n2: 2.2
Enter a n3: 5.5
Enter a n4: 4.4
Enter a n5: -3.4
Enter a n6: -45.5
Enter a n7: 34.5
Enter a n8: -4.2
Enter a n9: -1000
Enter a n10: 12
Sum = 59.70


In this program, when the user enters a positive number, the sum is calculated using sum += number; statement.

When the user enters a negative number, the continue statement is executed and it skips the negative number from the calculation.
definisi fungsi

Fungsi adalah sekumpulan perintah operasi program yang dapat menerima argumen input dan dapat memberikan hasil output yang dapat berupa nilai ataupun sebuah hasil operasi. Nama fungi yang didefinisikan sendiri oleh pemrogram tidak boleh sama dengan nama build-in function pada compiler C++. Fungsi digunakan agar pemrogram dapat menghindari penulisan bagian program (kode) berulang-



Cara Membuat Fungsi pada Bahasa C

Fungsi pada C++ dapat kita buat dengan cara seperti ini:










Fungsi biasanya akan mengembalikan sebuah nilai dari hasil prosesnya. Karena itu, kita harus menentukan tipe data untuk nilai yang akan dikembalikan.

Apabila fungsi tersebut tidak memiliki nilai kembalian, maka kita harus menggunakan tipe void untuk menyatakan kalau fungsi tersebut tidak akan mengembalikan nilai apa-apa.

Contoh:

void nama_fungsi(){
    cout << "Ini adalah sebuah fungsi\n";
}



Lalu untuk parameter bersifat opsional, boleh ada boleh tidak.

Tergantung dari fungsi yang dibuat. Jika fungsi itu membutuhkan input, maka kita harus membuatkan paramter.

Tapi kalau tidak menerima input apapun, ya tidak perlu dibuat.

Fungsi yang tidak menerima input, kadang juga disebut dengan prosedur.

Okee..

Sekarang mari kita coba membaut fungsi pada program C++.

Silahkan buat file baru bernama contoh_fungsi.cpp kemudian isi dengan kode berikut:

#include <iostream>
using namespace std;

// membuat fungsi say_hello()
void say_hello(){
    cout << "Hello Selamat Datang!\n";
}

int main(){
    // memanggil fungsi say_hello()
    say_hello();

    return 0;
}



Hasilnya:



Fungsi say_hello() dapat kita panggil berulang kali pada fungsi main().

Contoh:

#include <iostream>
using namespace std;

// membuat fungsi say_hello()
void say_hello(){
    cout << "Hello Selamat Datang!\n";
}

int main(){
    // memanggil fungsi say_hello()
    say_hello();
    say_hello();
    say_hello();

    return 0;
}



Maka hasilnya:



Jadi, cukup buat fungsi satu kali. Kita bisa panggil berkali-kali.


Deklarasi dan Definisi Fungsi

Pada contoh di atas, kita membuat fungsi dengan cara mendefinisikan langsung fungsinya.

Kita juga bisa membuatnya dengan deklarasi.

Contoh:

#include <iostream>
using namespace std;

// deklarasi fungsi
void say_hello();

int main(){
    // memanggil fungsi say_hello()
    say_hello();
    say_hello();
    say_hello();

    return 0;
}

// Definisi fungsi
void say_hello(){
    cout << "Hello Selamat Datang!\n";
}



Apa bedanya dengan yang tadi?

Jika kita membaut fungsi secara definisi, kita harus membuat fungsinya di atas fungsi main.

Jika dibuat di bawah fungsi main, maka program akan error.

Soalnya program C++ dieksekusi dari atas ke bawah.

Tapi berkat deklarasi, masalah ini bisa teratasi.

Jadi kamu mau pilih cara yang mana?

Deklarasi dulu atau langsung definisikan fungsinya?


Fungsi dengan Parameter

Parameter adalah variabel yang menyimpan nilai untuk diproses di dalam fungsi.

Parameter berfungsi untuk menyimpan nilai yang akan diinputkan ke fungsi.

Contoh:

void say_hello(string name){
    cout << "Hello " << name << "!\n";
}



Perhatikan!

name adalah sebuah parameter dengan tipe string.

Parameter ini akan menyimpan nilai yang diinputkan ke fungsi say_hello().

Lalu, bagaimana cara kita memberikan input ke fungsi?

Berikut caranya:

say_hello("Petani Kode");



Perhatikan!

"Petani Kode" adalah nilai yang akan kita berikan ke fungsi.

Biar lebih paham… mari kita coba dalam program.

Silahkan buat program baru dengan nama fungsi_parameter.cpp, kemudian isi dengan kode berikut:

#include <iostream>
using namespace std;

void say_hello(string name){
    cout << "Hello " << name << "!\n";
}

int main(){
    say_hello("Dian");
    say_hello("Petani");
    say_hello("Kode");
    return 0;
}



Hasilnya:



Hasil outputnya akan menyesuaikan dengan nilai parameter yang kita berikan ke fungsi.

Lalu bagaimana kalau ada lebih dari satu parameter?

Gampang…

Tinggal ditambahkan dan dipisah dengan tanda koma seperti ini:

void add(int a, int b){
    printf("%d + %d = %d\n", a, b, a+b);
}



Mari kita coba…

Buatlah program baru barnama dua_param.c, kemudian isi dengan kode berikut:

#include <iostream>
using namespace std;

void add(int a, int b){
    printf("%d + %d = %d\n", a, b, a+b);
}

int main(){
    add(1, 4);
    add(8, 2);
    add(3, 2);
    return 0;
}



Hasilnya:




Fungsi yang Mengembalikan Nilai

Pada contoh di atas, kita memberikan nilai input ke fungsi berupa integer…

…lalu di dalamnya dilakukan operasi penjumlahan.

void add(int a, int b){
    printf("%d + %d = %d\n", a, b, a+b);
}



Fungsi ini tidak mengembalikan apa-apa, karena tipe data yang diberikan pada nilai kembalian adalah void.

Fungsi juga kadang harus menghasilkan output.

Mengapa?

Karena kadang kita membutuhkan hasil dari fungsi tersebut untuk digunakan pada proses berikutnya.

Kita bisa menggunakan kata kunci return untuk mengembalikan nilai dari fungsi.

Contoh:

int add(int a, int b){
    return a+b;
}



Maka fungsi add() akan mengembalikan nilai berupa integer dari hasil penjumlahan nilai a dan b.

Mari kita coba contoh yang lain…

Silahkan buat program baru bernama fungsi_bagi.c, kemudian isi dengan kode berikut:

#include <iostream>
using namespace std;

float bagi(int a, int b){
    float hasil = (float)a / (float)b;
    return hasil;
}

int main(){
    printf("Hasil 5/2: %.2f\n", bagi(5, 2));
    return 0;
}



Hasilnya:




Variabel Lokal dan Variabel Global

Variabel lokal dan variabel global akan sering kita temukan dalam pembuatan fungsi.

Variabel global adalah variabel yang bisa diakses dari semua fungsi. Sedangkan variabel lokal adalah variabel yang hanya bisa diakses dari dalam fungsi itu sendiri.

Contoh:

#include <iostream>
using namespace std;

// membuat variabel global
int nilai = 9;

int main(){
    // membuat variabel lokal
    int nilai = 7;

    // mencetak variabel
    printf("Nilai: %d\n", nilai);

    return 0;
}



Pada contoh di atas, kita membuat variabel global bernama nilai.

Fungsi ini berada di luar fungsi main.

Lalu di dalam fungsi main(), kita membuat variabel lagi bernama nilai dengan nilai yang berbeda.

Variabel yang ada di dalam fungsi main() adalah variabel lokal.

Lalu, pertanyaanya:

Berapakah hasil outputnya?

Jawabannya: 7

Mengapa bisa 7?

Karena variabel nilai kita buat ulang di dalam fungsi main.

Sekarang coba hapus variabel lokal yang ada di dalam main, sehingga akan menjadi seperti ini:

#include <iostream>
using namespace std;

// membuat variabel global
int nilai = 9;

int main(){
    // membuat variabel lokal
    //int nilai = 7;

    // mencetak variabel
    printf("Nilai: %d\n", nilai);

    return 0;
}



Maka hasil outputnya akan 9. Karena variabel yang dipakai adalah variabel global.

Kalau tidak percaya, coba buktikan aja sendiri!


Pass by Value dan Pass by Reference

Pass by value dan pass by reference adalah cara untuk memberikan nilai pada paramaeter.

Biasanya kita langsung memberikan nilai kepada parameter dengan cara seperti ini:

kali_dua(4);



Ini disebut pass by value, karena di sana kita memberikan nilai 4 secara langsung.

Nah kalau seperti ini:

kali_dua(&nama_variabel);



Ini disebut pass by reference, karena kita memberikan alamat memori.

Contoh:

#include <iostream>
using namespace std;

void kali_dua(int *num){
    *num = *num * 2;
}

int main(){
    int angka = 9;

    // memanggil fungsi
    kali_dua(&angka);

    // mencetak isi variabel
    // setelah fungsi dipanggil
    cout << "isi variabel angka = " << angka << endl;

    return 0;
}



Hasilnya:



Fungsi kali_dua() memiliki parameter berupa pointer, artinya kita harus memberikan alamat memori untuk pointer ini.

Pada saat pemanggilan, fungsi kali_dua() kita isi parameternya dengan alamat memori dari variabel angka.

Maka hasilnya nilai variabel angka akan dikalikan dengan 2 berdasarkan rumus pada fungsi yang kita berikan.


Fungsi Rekursif pada C++

Fungsi rekursif adalah fungsi yang memanggil dirinya sendiri.

Maksudnya?

Biasanya kita memanggil fungsi pada fungsi main atau fungsi yang lainnya. Namun, pada fungsi rekursif…

…fungsi itu akan memanggil dirinya sendiri di dalam tubuh fungsi.

Biar lebih jelas!

Coba perhatikan contoh berikut:

#include <iostream>
using namespace std;

// deklarasi fungsi
int sum(int n);

int main(){
    int number, result;

    printf("Enter a positive integer: ");
    scanf("%d", &number);

    result = sum(number);

    printf("sum = %d", result);

    return 0;
}

// definisi fungsi
int sum(int num){
    if (num!=0)
        return num + sum(num-1); // fungsi sum() memanggil dirinya sendiri
    else
        return num;
}



Hasilnya:



Mengapa hasilnya bisa 21?

Karena kita menginputkan nilai 6, maka akan sama dengan:

1 + 2 + 3 + 4 + 5 + 6 = 21




Apa Selanjutnya?

Intinya, saat kita membuat program yang besar dan kompleks.. kita harus menggunakan fungsi.

Biar kode program yang kita tulis tidak berantakan dan mudah dibaca.
Selanjutnya cobalah membuat program lebih banyak lagi dengan fungsi di C++.ulang, dapat menyusun kode program agar terlihat lebih rapi dan kemudahan dalam debugging program.













MULTI FUNGSI
#include <iostream>
using namespace std;

int hitung_luas (int panjang, int lebar){
int luas = panjang*lebar ;

return luas;
}

int main(){
int a,b,c,d,hasil;

cout<<"-----------------------------------"<<endl;
cout<<"------ Fungsi Utama ------"<<endl;
cout<<" "<<endl;
cout<<">>> Program Perkalian <<<"<<endl;
cout<<"-----------------------------------"<<endl;
cout<<"Masukkan nilai a :"; cin>>a;
cout<<"Masukkan nilai b :"; cin>>b;
cout<<"Masukkan nilai c :"; cin>>c;
hasil = (a*b*c);
cout<<"Hasil Perkalian adalah :"<<hasil<<endl;
cout<<"-----------------------------------"<<endl;


cout<<" "<<endl;
cout<<"------ Fungsi Pertama ------"<<endl;
cout<<" "<<endl;
cout<<">>> Program Hitung Luas Persegi Panjang <<<"<<endl;
cout<<"-----------------------------------"<<endl;
cout<<"Masukkan nilai panjang :"; cin>>a;
cout<<"Masukkan nilai lebar :"; cin>>b;
hasil = hitung_luas(a,b);
cout<<"Luas persegi panjang adalah :"<<hasil<<endl;

cout<<"-----------------------------------"<<endl;
cout<<" "<<endl;

cout<<"------ Fungsi Kedua ------"<<endl;
cout<<" "<<endl;
cout<<">>> Program Hitung Luas segitiga <<<"<<endl;
cout<<"-----------------------------------"<<endl;
cout<<"Masukkan nilai alas :"; cin>>a;
cout<<"Masukkan nilai tinggi :"; cin>>b;
hasil = 0.5*(a*b);
cout<<"Luas segitiga adalah :"<<hasil<<endl;
cout<<"-----------------------------------"<<endl;
cout<<" "<<endl;
cout<<" "<<endl;

cout<<"> This is usefull..? Say anything.. < "; cin>>a;
cout<<" "<<endl;
cout<<" "<<endl;
cout<<" Terimakasih "<<endl;


    system("PAUSE");

return 0;
}



Ya.... Seperti tadi, saya nggak bisa jelasin bagaimana cara kerjanya karena saya memang tidak bisa menjelaskan...

Untuk Hasilnya, Bisa Dilihat Di bawah

 

RECURSION

Rekursi dalam ilmu komputer[sunting | sunting sumber]

Artikel utama: Rekursi (ilmu komputer)

Metode umum dari penyederhanaan adalah dengan membagi suatu permasalah menjadi beberapa sub-permasalahan dengan tipe yang sama. Sebagai sebuah teknik dalam pemrograman komputer, hal ini disebut dengan divide and conquer dan merupakan kunci dari perancangan berbagai algoritme penting. Divide and conquer menyediakan pendekatan atas-bawah dalam pemecahan masalah, dengan permasalahan diselesaikan dengan menyelesaikan instansi yang lebih kecil. Pendekatan sebaliknya yaitu pemrograman dinamis. Pendekatan ini menyelesaikannya secara bawah-atas, dengan permasalahan diselesaikan dengan menyelesaikan instansi yang lebih besar, sampai ukuran yang diinginkan dicapai.

Contoh klasik dari rekursi adalah definisi dari fungsi faktorial, diberikan dalam kode C:

unsigned int factorial(unsigned int n)
{
  if (n == 0) {
    return 1;
  } else {
    return n * factorial(n-1);
  }
}



Fungsi tersebut memanggil dirinya sendiri secara rekursif terhadap versi input yang lebih kecil (n-1) dan mengkalikan hasil dari pemanggilan rekursif dengan n, sampai pada kasus dasar, sama analoginya dengan definisi matematika dari faktorial.

Rekursi dalam pemrograman komputer dicontohkan saat sebuah fungsi didefinisikan dalam bentuk sederhana, bahkan versi terkecil dari dirinya. Solusi dari permasalahan kemudian dirancang dengan menggabungkan solusi-solusi yang didapat dari versi sederhana dari permasalahan. Salah satu contoh aplikasi rekursi yaitu dalam parsing untuk bahasa pemrograman. Keuntungan utama dari rekursi adalah suatu himpunan tak-terbatas dari kalimat yang memungkinkan, perancangan atau data lainnya dapat didefinisikan, diurai atau dihasilkan dengan suatu program komputer yang terbatas.

Relasi perulangan adalah persamaan-persamaan untuk menentukan satu atau lebih urutan-urutan secara rekursif. Beberapa relasi perulangan tertentu dapat "diselesaikan" untuk mendapatkan definisi bukan-rekursif.

Penggunaan rekursi dalam suatu algoritme memiliki kelebihan dan kekurangan. Kelebihan utamanya adalah biasanya kesederhanaan. Kekurangan utamanya adalah terkadang algoritme tersebut membutuhkan memori yang sangat banyak jika kedalaman rekursi sangat besar.



3.VARIABEL

   A.AUTOMATIC

Dalam pemrograman komputer , variabel otomatis adalah variabel lokal yang dialokasikan dan didelokasi secara otomatis ketika aliran program masuk dan meninggalkan ruang lingkup variabel. Lingkup adalah konteks leksikal, khususnya fungsi atau blok di mana suatu variabel didefinisikan. Data lokal biasanya (dalam kebanyakan bahasa) tidak terlihat di luar fungsi atau konteks leksikal di mana ia didefinisikan. Data lokal juga tidak terlihat dan tidak dapat diakses ke fungsi yang disebut , [catatan 1] tetapi tidak dialokasikan, kembali dalam ruang lingkup sebagai utas eksekusi kembali ke pemanggil.

Variabel lokal otomatis terutama berlaku untuk bahasa yang dibatasi leksikal secara rekursif . [catatan 2] Variabel lokal otomatis biasanya dialokasikan dalam bingkai tumpukan prosedur di mana mereka dinyatakan. [catatan 3] Ini pada awalnya dilakukan untuk mencapai pemulangan kembali dan memungkinkan rekursi , [catatan 4] pertimbangan yang masih berlaku sampai sekarang. Konsep variabel otomatis dalam fungsi rekursif (dan bersarang ) dalam bahasa yang dicakup secara leksikal diperkenalkan kepada khalayak yang lebih luas dengan ALGOL pada akhir 1950-an, dan selanjutnya dipopulerkan oleh banyak keturunannya.

Istilah variabel lokal biasanya identik dengan variabel otomatis, karena ini adalah hal yang sama dalam banyak bahasa pemrograman, tetapi lokal lebih umum - sebagian besar variabel lokal adalah variabel lokal otomatis, tetapi variabel lokal statis juga ada, terutama dalam C. Untuk statis variabel lokal, alokasi statis (masa hidup adalah seluruh pelaksanaan program), tidak otomatis, tetapi hanya dalam ruang lingkup selama pelaksanaan fungsi.

   B.VARIABEL EKSTERNAL

Variabel Eksternal adalah variabel Global. artinya variabel ekternal bersifat global yang dapat di gunakan bersama-sama tanpa harus di deklarasikan berulang-ulang, karena sudah di deklarasikan di luar fungsi.
Pendeklarasian variabel eksternal inim diluar dari fungsi main().
Perhatikan program dibawah ini:





//contoh varibel eksternal


#include<iostream.h>


int a=10; // ini adalah deklarasi untuk variabel eksternal


void lokal();


void main()


{


 cout<<"Penggunaan variabel eksternal"<<endl;


 cout<<"Nilai dalam fungsi main() :"<<a<<endl; //memanggil variabel eksternal a





 cout<<"\nNilai setelah panggilan fungsi lokal():";


 lokal(); //pemanggilan fungsi lokal


 cout<<"\n";


}


void lokal()


{


 cout<<a+100<<",";  


}


Pada contoh diatas dapat kita lihat bahawa varibel main dapat menggunakan nilai variabel eksternal a, yang di deklarasikan di luar main(), dan dapat juga digunakan fungsi void lokal() untuk menambahkan dengan 100.
dan hasil outputnya adalah sbb:


Hasil output




STATIK REGISTER

1) variabel otomatis

penjelasan:
variabel otomatis adalah variable yang hanya dikenal di dalam suatu blok saja (dalam tanda {…}), baik itu blok pemilihan, pengulangan ataupun fungsi. dikatakan ‘otomatis’ karena variable ini dialokasikan pada saat pendeklarasian dan akan didealokasikan secara otomatis ketika program keluar dari suatu blok. walaupun bersifat opsional, namun untuk mempertegas bahwa variable tersebut sebagai variable otomatis, kita dapat menggunakan kata kunci auto pada saat pendeklarasian.
syntax:
auto tipe_data nama_variabel

contoh:
#include
int main(void)
{
int a;
if(a>0)
{
auto int var_otomatis;
CODE
}
}



contoh hasil yang akan diperoleh dari program di atas adalah:
masukkan nilai pangkat:3
5^3=125


2)variabel statis:

penjelasan:
Variabel statis adalah suatu variable yang menyimpan nilai permanen dalam memori, artinya variable tersebut akan menyimpan nilai terakhir yang diberikan. Untuk menyatakan bahwa suatu variable adalah variable statis adalah dengan menggunakan kata kunci static.
syntax:
static tipe_data nama_variabel
contoh:
#include
int KaliSepuluh(void)
{
static int a=1;
a=a*10;
return a;
}

int main(void)
{
int x,y,z;
x=KaliSepuluh();
y=KaliSepuluh();
z=KaliSepuluh();

printf(“Nilai x=%d\n”,x);
printf(“Nilai y=%d\n”,y);
printf(“Nilai z=%d\n”,z);
}



contoh hasil yang akan diperoleh adalah:
nilai x =10
nilai y=100
nilai z= 1000


3) variabel eksternal:

penjelasan:
bahasa c mengizinkan kita untuk menuliskan syntax program ke dalam file yang terpisah dengan tujuan untuk modularisasi program. untuk itu apabila kita ingin mendeklarasikan variabel yang dapat dikenali dan diakses oleh masing-masing file yang terpisah tersebut, maka variable itu harus kita deklarasikan sebagai variable eksternal . adapun caranya adalah dengan menambahkan kata kunci ekstern pada saat pendeklarasian.
syntax:
extern tipe_data nama_variabel
contoh:
dalam file utama.c.
#include
int var_eksternal;
int main(void)
{
var_eksternal=100;
printf(“Nilai var_eksternal:%d\n”,var_eksternal);

SetNilai();
printf(“Nilai var_eksternal:%d\n”,var_eksternal);
}



dalam file eksternal.c.
extern int var_ eksternal;

void SetNilai(void)
{
var_eksternal=500;
}



apabila dikompilasi dan dijalankan maka program di atas akan memberikan hasil sebagai berikut:
nilai var_eksternal:100
nilai var_eksternal:500


4) variabel register:

penjelasan:
berbeda dengan variable biasa yang akan bertempat di memori, variable register ini akan disimpan di dalam register cpu. dengan demikian, apabila kita ingin mengisikan atau mengubah nilai variable register, maka kita tidak perlu melakukan akses terhadap memori sehingga proses yang dilakukan pun lebih cepat.perlu diperhatikan bahwa variable register ini hanya dapat diterapkan ke tipe bilangan bulat, karakter, dan pointer saja. selain itu variable ini hanya boleh dideklarasika sebagai variable lokal ataupun parameter dari fungsi. untuk mendeklarasikannya kita harus menggunakan kata kunci register.
syntax:
register tipe_data nama_variabel;
contoh:
#include
int Pangkat(register int B, register int e)
{
hasil=1;
for(;e;e--)
{
hasil *= B;
}
return hasil;
}

int main(void)
{
printf(“2^6=%d”,Pangkat(2,6));
}



hasil yang akan diperoleh dari program di atas adalah:
2^6=64

selain itu ada juga yg disebut variabel volatile yaitu variabel yang nilainya dapat berubah dikarenakan faktor eksternal. deklarasi variabel volatile yaitu, volatile tipe_data nama_variabel





STORAGE CLASS

Class Storage dapat kita gunakan untuk menentukan usia dan kehidupan dan ruang lingkup dari varibel. Bagaimana penyimpanan (Storage) itu dialokasikan untuk variabel serta bagaimana variabel itu diperlakukan oleh compiler, semuanya tergantung dari Class Storage.

Pada dasarnya, Class Storage dibagi menjadi lima tipe:

Variabel Global
Variabel Local
Variabel Register
Variabel Static
Variabel Extern



Variabel Global pada C++
Variabel Global adalah variabel yang sudah didefinisikan diawal, sebelum semua badan dari fungsi dan tersedia di seluruh program. Berikut adalah contohnya:



using namespace std;
int globe;    // Variabel Global
void func();
int main()
{
    .....
}



Variabel Local pada C++
Variabel Local adalah suatu variabel yang dapat di definisikan dan tersedia hanya pada ruang lingkup (Scope) tertentu. Variabel Local juga dapat disebut dengan Variabel Otomatis karena variabel ini dapat muncul ketika ruang lingkupnya dimasukkan dan secara otomatis akan keluar ketika ruang lingkupnya berakhir.

Keyword auto dapat kita gunakan, tetapi secara default semua variabel lokal adalah auto (otomatis). Jadi, kita tidak perlu menambahkan keyword auto sebelum deklarasi variabel.



variabel register 

Variabel Register ini merupakan salah satu jenis dari variabel lokal. Keyword dapat digunakan untuk memberitahukan Compiler untuk mengakses variabel ini secepat mungkin. Variabel ini disimpan di dalam Register agar dapat meningkatkan kecepatan akses.Tetapi, kalian tidak akan pernah menggunakan atau menghitung alamat dari variabel register dan juga variabel register hanya dapat di deklarasikan di dalam block. Artinya, kalian tidak dapat memiliki variabel register global ataupun statis.Variabel Static pada C++



Variabel Static adalah variabel yang penyimpanannya sudah di inisialisasi dan dialokasikan hanya sekali diawal ketika program dijalankan dan tidak peduli berapa banyak atau sering digunakan pada program. Variabel Static dapat mempertahankan nilainya sampai program itu berakhir. Berikut adalah contohnya:



void fun()
{
    static int i = 10;
    i++;
    cout << i;
}
int main()
{
    fun();    // Output = 11
    fun();    // Output = 12
    fun();    // Output = 13
}


i adalah Static, maka akan selalu mempertahankan nilainya melalui pemangginalan fungsi dan hanya di inisialisasikan sekali diawal.

Specifier Static juga dapat di gunakan pada Class, tetapi kita akan membahas hal tersebut pada bagian selanjutnya.




Variabel Extern pada C++
Keyword ini dapat kita gunakan untuk mengakses variabel di dalam file yang sudah di definisikan dan di deklarasikan pada file lain. Artinya, keberadaan Variabel Global pada satu file sudah di deklarasikan menggunakan keyword extern pada file lain:

Contoh, terdapat dua file C++. Berikut adalah kode dari File pertama:
file1.cpp



#include <iostream>
using namespace std;
int globe;
void func();
int main()
{
    ...
    ...
}


Berikut adalah kode dari File kedua:
file2.cpp



extern int globe;
int b = globe + 10;


Dari kedua file diatas, Variabel Global pada satu file digunakan pada file lain dengan menggunakan keyword extern.



COMPILE MULTI FILE 

Multi-file programs
In a program consisting of many different functions, it is often convenient to place each function in an individual file, and then use the make utility to compile each file separately and link them together to produce an executable.

There are a few common-sense rules associated with multi-file programs. Since a given file is initially compiled separately from the rest of the program, all symbolic constants which appear in that file must be defined at its start. Likewise, all referenced library functions must be accompanied by the appropriate references to header files. Also, any referenced user-defined functions must have their prototypes at the start of the file. Finally, all global variables used in the file must be declared at its start. This usually means that definitions for common symbolic constants, header files for common library functions, prototypes for common user-defined functions, and declarations for common global variables will appear in multiple files. Note that a given global variable can only be initialized in one of its declaration statements, which is regarded as the true declaration of that variable [conventionally, the true declaration appears in the file containing the function main()]. Indeed, the other declarations, which we shall term definitions, must be preceded by the keyword extern to distinguish them from the true declaration.

As an example, let us take the program printfact4.c, listed previously, and break it up into multiple files, each containing a single function. The files in question are called main.c and factorial.c. The listings of the two files which make up the program are as follows:
/* main.c */
/*
  Program to print factorials of all integers
  between 0 and 20
*/

#include <stdio.h>

/* Prototype for fucntion factorial() */
void factorial();    

/* Global variable declarations */
int j;               
double fact;

int main() 
{
  /* Print factorials of all integers between 0 and 20 */
  for (j = 0; j <= 20; ++j)
    {
      factorial();
      printf("j = %3d    factorial(j) = %12.3e\n", j, fact);
    }
  return 0;
}

and
/* factorial.c */
/* 
   Function to evaluate factorial (in floating point form)
   of non-negative integer j. Result stored in variable fact.
*/

#include <stdio.h>
#include <stdlib.h>

/* Global variable definitions */
extern int j;               
extern double fact;

void factorial() 
{
  int count;

  /* Abort if j is negative integer */
  if (j < 0) 
    {
      printf("\nError: factorial of negative integer not defined\n");
      exit(1);
    }

  /* Calculate factorial */
  for (count = j, fact = 1.; count > 0; --count) fact *= (double) count;

  return;      
}

Note that all library functions and user-defined functions referenced in each file are declared (either via a header file or a function prototype) at the start of that file. Note, also, the distinction between the global variable declarations in the file main.c and the global variable definitions in the file factorial.c.

sumber:

https://www.mathworks.com/help/matlab/matlab_prog/loop-control-statements.html

https://www.w3schools.in/c-tutorial/decision-making/if-else/

https://en.wikipedia.org/wiki/Do_while_loop

https://www.geeksforgeeks.org/switch-statement-cc/

https://www.programiz.com/c-programming/c-break-continue-statement

https://docplayer.info/46246666-8-1-fungsi-deklarasi-dan-definisi-nya.html

http://inicumangw.blogspot.com/2018/09/program-multi-fungsi-dalam-1-kode.html

https://id.wikipedia.org/wiki/Rekursi

https://translate.google.com/translate?u=https://en.wikipedia.org/wiki/Automatic_variable&hl=id&sl=en&tl=id&client=srp

http://pemrograman-c.blogspot.com/2012/01/variabel-eksternal.html

http://mcunovel.blogspot.com/2011/11/jenis-variabel-dalam-bahasa-c.html

https://www.elcreativeacademy.com/2019/11/storage-class-pada-c-plus-plus.html



http://farside.ph.utexas.edu/teaching/329/lectures/node22.html