Bu derste matematiksel işlemlerde kullanacağımız deyimleri, farklı tiplerdeki (float, int…) matematiksel ifadeleri aynı anda kullanarak yapılacak işlemleri, matematik kütüphanesindeki fonksiyonların işlevlerini ve kullanımlarını, daha düzenli kodlama için işimizi kolaylaştıracak bazı ipuçları konularını ele alacağız. Bu dersteki işlemleri nerdeyse tüm programlarda kullanacağız. Çünkü matematiksel işlemler ve kodlarımızdaki düzen işimizin kalitesini ön plana çıkarır ve karmaşıklığı azaltır. Öncelikle aritmetik deyimlerle başlayalım:

Aritmetik Deyimler :

Matematiksel işlemleri yaparken kullanacağımız semboller temelde 5 tanedir. Bunlar;

• Toplama (+) : Sağındaki ve solundaki iki bilgiyi uygun şekilde toplar. Örneğin;

  int sayi = 5 + 12;  //5 ve 12 sayılarını toplayıp sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 17dir.
  sayi += 2;          //Bu ifade sayi = sayi + 2; anlamına gelir.
                      //Yani kendi değerini 2 arttırır.
                      //Şuan sayi değişkeninin değeri 19dur.

• Çıkarma (-) : Solundaki ifadeden sağındaki ifadeyi çıkarır. Örneğin;

  int sayi = 12 -5;  //12'den 5 çıkarıp sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 7dir.
  sayi -= 2;          //Bu ifade sayi = sayi - 2; anlamına gelir.
                      //Yani kendi değerini 2 azaltır.
                      //Şuan sayi değişkeninin değeri 0dır.

• Çarpma (*) : Sağındaki ve solundaki iki bilgiyi uygun şekilde çarpar. Örneğin;

  int sayi = 5 * 12;  //5 ve 12 sayılarını çarpıp sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 60dır.
  sayi *= 2;          //Bu ifade sayi = sayi * 2; anlamına gelir.
                      //Yani kendi değerini 2 ile çarpar.
                      //Şuan sayi değişkeninin değeri 120dir.

• Bölme (/) : Solundaki ifadeyi sağındaki ifadeye böler. Bölüm ifadesini gösterir. Örneğin;

  int sayi = 12 / 6;  //12 sayısını 6'ya böldük ve sayi değişkenine atadık.
                      //Şuan sayi değişkeninin değeri 2dir.
  sayi /= 2;          //Bu ifade sayi = sayi / 2; anlamına gelir.
                      //Yani kendi değerini 2'ye böler.
                      //Şuan sayi değişkeninin değeri 1dir.

• Kalan Bulma (%) : En az 4 işlem kadar önemli bir deyimdir. Uygun yerlerde kullanılırsa harika işlere yarar. Sağındaki ifadenin solundaki ifadeye bölümünden kalanını verir. Örneğin;

  int sayi = 12 % 5;  //12 sayısını 5'e bölümünden kalanı bulur.
                      //Ve sayi değişkenine atar.Şuan sayi değişkeninin değeri 2dir.
  sayi %= 2;          //Bu ifade sayi = sayi % 2; anlamına gelir.Yani;
                      //Kendi değerinin 2 ile bölümünden kalanını yeni değeri yapar.
                      //Şuan sayi değişkeninin değeri 0dır.

Arttırma ve Azaltma :

Programımız çalışırken ne yaptığını, nasıl çalıştığını bilmek isteriz. Bunun için de mantıksal sayaçları devreye sokarız. Bir sayacın işleyişini belirmek için ise arttırma ve azaltma işlemlerini sık sık kullanacağız. Örneklere başladığımızda daha iyi göreceğiz. Şimdilik nasıl çalıştığını öğrenmemiz yeterli.

int sayi = 50;
int yeni_sayi;
 
sayi++;         //Bu ifade sayi bilgisini 1 arttırır.
                //Yani sayi = sayi + 1; ile aynı anlamdadır.
                //Şuan sayi değeri 51dir.
 
sayi--;         //Yine yukarıdaki ifade ile aynı mantıkta.
                //Şuan sayi değeri 50dir.
 
yeni_sayi = sayi++;   //Bu işlem aslında şunları yapar;
                      //'önce' sayi değişkenini yeni_sayi değişkenine atar.
                      //'sonra' sayi değişkenini 1 arttırır.
                      //Şuan sayi değişkeni 51, yeni_sayi 50dir.
 
yeni_sayi = ++sayi;   //Bu işlem ise ters sırada ilerler;
                      //'önce' sayi değişkenini 1 arttırır.
                      //'sonra' sayi değişkenini yeni_sayi değişkenine atar.
                      //Şuan sayi değişkeni 52, yeni_sayi 52dir.

Arttırma ve azaltma işlemleri bu şekildedir. Burada dikkat etmemiz gereken şey, bu işlemlerin sadece integer tipindeki ifadelerde yapılmasıdır.

Tip Dönüşümleri :

Matematiksel işlemler yaparken kullandığımız veri tipleri arasındaki ilişki çok önemlidir. C/C++ dillerinde bir int ifadeyle bir float ifadeyi işleme soktuğumuzda sonuç eğer float yani kesirli bir değer çıkıyorsa biz bu ifadeyi integer yani tam sayı olarak tanımlanmış bir değişkene atayamayız. Ya da iki tane integer ifadenin bölümü eğer float bir değer ise işleme soktuğunuz değişken tipleri int olduğu için sonuç yuvarlanıp integer olarak gösterilecektir. İşte böyle durumlarda tip zorlaması dediğimiz işlemleri yapacağız. Birkaç örnek ile bunları açıklayalım;

int sayi1 = 14, sayi2 = 4;
int sonuc;
 
sonuc = sayi1 / sayi2;  //Yani 14/4= 3.5 olacağından sonuç float ifadedir.
                        //sonuc değişkenini int olarak tanımladığımız için
                        //sonuc değişkeninin yeni değeri 3 olacaktır.
                        //Bu sorunu çözmek için sonuc değişkenini float yapmalıyız.
float sonuc;
sonuc = sayi1 / sayi2;  //sonuc değişkenini float yapmamıza rağmen yine 3 olacak.
                        //Çünkü işleme soktuğumuz iki ifade de int.
                        //Sorunu çözmek için tip zorlaması yapmalıyız.
sonuc = (float)sayi1 / (float)sayi2;
sonuc = (float)sayi1 / sayi2;
sonuc = sayi1 / (float)sayi2;    //Bu işlemlerden herhangi biri sorunu çözecektir.
 
sonuc = (float)(sayi1 / sayi2);  //Bu ifade ise yine 3 cevabını verecektir.
                                 //Çünkü işlem önceliğinden dolayı önce bölme işlemi
                                 //yapılıp sonra tip zorlama yapılmış olacak.
                                 //Yani ikinci parantezin içi 3 bulunmuş olacak.
                                 //Ve sonuç 3.0 olacak. Buna da dikkat etmeliyiz.

Math Library (Matematik Kütüphanesi) :

Bazı matematiksel işlemler her ne kadar kağıt kalemle çok kolay olsa da bilgisayara bunu anlatmak satırlarca kod yazmayı gerektirebiliyor. Yine uzman kişiler tarafından hazırlanan en stabil matematiksel fonksiyonlar math.h kütüphanesinde yer almaktadır. Bunların önemli olanlarını yazacak olursak;

• sin(x); cos(x); tan(x); : Trigonometrik fonksiyonlar.
• log(x); log10(x); : e ve 10 tabanlarında logaritma fonksiyonları.
• pow(x,y); : x üzeri y ifadesi.
• sqrt(x); : x ifadesinin karekökü.
• floor(x); ceil(x); : x ifadesinin alt ve üst sınır fonksiyonları.
• fabs(x); : x ifadesinin mutlak değeri.

Gördüğünüz gibi bu ifadeler birer fonksiyondur. Parantez içine yazdığımız x veya y’lere parametre diyoruz (fonksiyonlar konusunda daha detaylı göreceğiz.). Bu parametrelerin tipi önemlidir. Fonksiyonlara gönderdiğiniz paramatre bir integer ise fonksiyonun dışar gönderdiği sonuç da integer olacaktır. Float gönderirsek float, double gönderirsek double… math.h kütüphanesindeki fonksiyonlara göndereceğimiz açı değerleri derece değil radyan cinsinden olmalıdır buna çok dikkat ediniz. (x*PI)/180 yani (x*3.14)/180 ile radyan dönüşümü yapabilirsiniz. Şimdi bunlarla ilgili birkaç örnek yapalım:

#include <math.h>  //Kütüphanemizi import etmeyi unutmuyoruz.
int sonuc;         //
sonuc = pow(2,4);  //pow fonksiyonu 2'nin 4'üncü kuvvetini hesaplayıp
                   //cevabı sonuc değişkenine atayacak.
                   //yani şuan sonuc değişkeninin değer 16 olmuştur.
sonuc = sin( (30*3.14)/180 ); //30 dereceyi radyan cinsine cevirdik ve
                   //sin fonksiyonuna gönderdik.
                   //sonuc değişkeni int olduğu için yeni değeri 0 olacaktır.
                   //sonuc değişkeninin tipini float yaptığımızda
                   //yeni değeri 0.49977 olacaktır.

Math.h kütüphanesindeki diğer fonksiyonlar ve detayları için cplusplus.com adresinden yararlanabilirsiniz.

Kodlama Düzeni :

Programımızı yazarken aşağıdaki gibi bir düzen izlememiz gerekmektedir. Bu alanı lütfen dikkatlice inceleyin;

#include <iostream> /***************************************************/
#include <conio.h>  /*Bu alanda kütüphaneler ve değişmezler tanımlanır.*/
#define PI 3.14     /***************************************************/
 
/**********************************************************************/
/*Bu alanda fonksiyon,class,struct veya global değişkenler tanımlanır.*/
/**********************************************************************/
 
int main(void){         /************************************BAŞLANGIÇ*/
      float sayi;       /* Burası main(ana) fonksiyonumuz.Programmızın*/
                        /* Esas kodlarını burada kullanacağız.        */
      getch();          /**********************************************/
  }                     /****************************************BİTİŞ*/
 
/**********************************************************************/
/*             Bu alanda da fonksiyon tanımlanabilir.                 */
/**********************************************************************/

Yukarda değindiğimiz düzen komutların doğru çalışması içindi. Şimdi de kodların düzenli durması ve anlaşılır olabilmesi için yapılması gerekenlerden bahsedelim.

Yazdığımız bir programın başka birisi tarafından daha net anlaşılması ve geliştirilebilmesi için bazı ufak kurallara uymamız gerekmektedir. Bunlardan en önemlisi daha alt katmanlardaki komutların daha iç sütunlara yazılmasıdır. Hemen bi örnek ile açıklayalım :

#include <stdio.h>
 
int main(void){                  //Katman1 başlangıç.
   int sayi = 1991, i;           //Katman1 içindeki komut.
   for(i=0;i<1991;i++){          //Katman2 başlangıç.
      printf("Sayi : %d\n",sayi);  //Katman2 içindeki komut.
      }                          //Katman2 bitiş.
   }                             //Katman1 bitiş.

Gördüğünüz gibi alt katmanlara girdikçe kodlarımızı daha içerde yazdık. Bu hem kodların anlaşılır olmasını sağlar hem de kodun nerde başlayıp nerede bittiğini daha iyi gösterir. Ayrıca bu tarz kod yazmak global bir kültür olmuştur. Alışkanlık haline getirmeniz sizin için iyi olacaktır.