DERLEYİCİLER VE C DİLİNİN ÖZELLİKLERİ

ÖRNEK PROGRAMLAR

Üst düzey dillerden biri ile yazılmış olan bir programı, makine diline çeviren programa derleyici denir. TURBO C de böyle bir derleyicidir. TURBO C isminin belirttiği gibi "hızlı C" şeklinde değil de, Borland firmasının çıkardığı C lisanı derleyicisi versyonu olarak düşünmek gerekir.



C dilini diğerlerinden ayıran özellikleri şöyle sıralayabiliriz.

a) C dili orta sınıf bir dildir.

b) C dili yapısal bir dildir.

c) C dili gerçek programcıların kabul ettiği bir dildir.

d) C dili değişik bilgisayarlara kolayca adapte olan bir dildir.



C, genel amaçlı bir dil olarak hazırlanmıştır. PC’nin, BASIC veya PASCAL gibi diller kullanılarak ulaşılamayan bazı bölümlerin kullanılmasını sağladığı için, uygulama programcılarının bir çoğu C’yi yeğlerler. C, bilgisayarın herhangi bir yerine kolayca ulaşmamızı sağlar.



C kullanırken yapabileceğimiz en önemli hatayı, yalnızca bilgisayarı kapatıp açarak düzeltebiliriz. C, PC’nin ortaya çıkması ile başlamadı. C’nin kökeni çok daha eskiye gider. C, 70’li yılların başında, AT&T tarafından, mini bilgisayarlarda kullanılmak üzere tasarlanmıştır. Bu dilin beğenilmesi sonucunda, C kısa zamanda yayıldı. Sonunda C, UNIX adı verilen bir işletim sisteminin oluşturulmasında kullanıldı. 1978’de American National Standarts Institude (ANSI) tarafından standart hale getirilen C dili orta sınıf bir dildir.



TURBO C’YE GENEL BİR BAKIŞ



Turbo C, diğer C editör ve derleyici uyarlamalarından farklı bir biçimde işler. Derleyiciler genellikle DOS işletisinden çağrılır ve buradan diskete/diske daha önceden kaydedilmiş olan bir metin kütüğünün çevrilmesine yöneltilirler.



Yapısal programlama, program karmaşıklığını azaltmak ve programları daha kolay anlaşılabilir, okunabilir, geliştirilebilir, değiştirilebilir biçime getirmeyi amaçlayan genel bir programlama yöntemidir.



Metin kütüğünü yazmak için, bir metin editörü veya bir kelime işlemci kullanılmalıdır. Derleyicilerin pek azının kendi editörleri vardır.



TURBO C ÇEVRESİ



Birleşik TURBO C çevresi, editör ve derleyiciyi tek bir programda birleştirdiği için, programın yazılmasını ve edit edilmesini kolaylaştırır.



Bir programı oluşturmak için, TURBO C editörüne girin ve program metnini yazın. Programın tümünü yazdıktan sonra, TURBO C derleyicisini doğrudan editörden çalıştırabilirsiniz. Programı derlenmeden önce diske/diskete kaydetmeniz gerekli değildir. Tek bir tuşa basarak programı derleyebilirsiniz.



Üzerinde çalıştığınız kütük, bellekte tutulduğu için, birleşik çevre derleme işini bütün derleyicilerden daha hızlı yapar. Ayrı bir editör ve derleyici yerine tek bir program kullanmanın hızlı olmanın yanında başka avantajları da vardır.



Birleşik TURBO C çevresinde, editör derleyicinin bulduğu hataları her zaman bilir. TURBO C editörü, derleyicinin bulduğu her hatanın yerini size gösterir.



Birleşik TURBO C çevresi kullanıldığında oluşan yapı;

· programın yazılması

· programın işletilmesi

· programın değiştirilmesi

· programın işletilmesi



MENÜ SİSTEMİ:



TURBO C değişik bir menü sistemi kullanır. Menüler programlama sırasında sık sık kullanılırlar. Bir menü her zaman, ne yapabileceğinizi çok açık biçimde gösterir.

ÖRNEK

# include <stdio.h>

# define PI 3.1415 /* PI için değer belirlenmesi */

main( )

float b=PI;

float a;

a=PI;

printf("a’nın değeri %f\n", a);

printf("a’nın değeri %f\né, PI);

}



MATEMATİKSEL İŞLEMLER



C dili hemen hemen her matematiksel uygulamada kullanılabilir.

+ toplama

- çıkarma

* çarpma

/ bölme

aritmetik işlemler için kullanılırlar.



MODÜLÜS : İki sayının modülüsü, bir sayının diğerine bölünmesinden oluşan kalandır. Modülüs işlemi için % işareti kullanılır. 5%2 örneğinde 5 sayısı 2’ye tam olarak iki defa bölünür ve 1 artar. Bu nedenle 5 ve 2’nin modülüsü 1 dir.



ÖRNEK

# include <stdio.h>

main( )

{

int a;

a=6%3;

printf("a’nın değeri %d\n", a);

}



örneğinde a=0’dır. 6’da 3 iki defa vardır, kalan sıfırdır.



# include <stdio.h>

main( )

{

int a;

a=2%6;

printf("a’nın değeri %d\n", a);

}



örneğinde sonuç 2’dir. 2 sayısında 6 hiç olmadığı için kalan 2’dir



ÖNCELİK :



C’de işlemlerin, öncelik adı verilen bir özellikleri vardır. Önceliği yüksek olan işlemler önce yapılırlar. Beş temel işlem öncelik sırası aşağıda verilmiştir.



İŞLEM ÖNCELİK

* / % ilk

+ - son



NOT : Aynı öncelikte iki işlem arasında seçim yapmak gerektiğinde, işlem soldan sağa doğru çözülür.



ÖRNEK :

# include <stdio.h>

main( )

{

float a;

a=5+6*7/2;

printf("a’nın değeri %f\n", a);

}



Bu program nasıl bir değer verir? Bu eşitlikte, hem çarpmanın hem de bölmenin toplamaya göre öncelikleri vardır. İlk olarak bu iki işlemden biri yapılmalıdır. Çarpma daha solda olduğu için ilk önce yapılır.



Bu iţlem 6*7=42 sonucunu verir.

a=5+42/2; Daha sonra bölme işlemi yapılır.

a=5+21; ve toplama işlemi yapılır.

a’nın değeri 26.000000



Öncelik kurallarını karıştırmamak için parantezler kullanılır. parantez içindeki işlemler önce yapılır.



a=((5+6)*7)/2; gibi



EŞİTLİKLERDE DEĞİŞKEN KULLANIMI



Tipi yazdıktan sonra, değişken isimleri araya virgüller koyarak aynı tipte birden fazla değişken tanımlanabilir.



Tip isim1, isim2, isim3;

int a,b,c;



ÖRNEK

# include <stdio.h>

main( )

{

int x,y,a;

x=4;y=2;

a=x*x+y*y; printf("a’nın değeri %d\n", a);

}



NOT : Bir değişkenin içeriğini kullanmadan önce, değişkenin bir değere eşitlenmiş olmasına dikkat edilmelidir. Program derlenirken warning(uyarı mesajı) verebilir. Bu nedenle C, değişkenlerin tanımı yapılırken değişkenlere değer atanmasına olanak sağlar.



Bu tümce ţöyledir.



Tip isim1=değer;

veya

tip isim1=değer1, isim2=değer2;



ÖRNEK

# include <stdio.h>

main( )

{

int a,x=0,y=0;

y=2;

a=x*x+y*y;

printf("a’nın değeri %f\n",a);

}



FONKSİYON ÇAĞRILARI KÜTÜPHANELER



Bir standart fonksiyon kullanabilmek için, C’ye bu fonksiyonun tanımının nerede bulunabileceğini belirtmek gerekir. Bu # include derleyici komutu ile yapılır.



Bu tür standart fonksiyon kütükleri bir dizi bildirim tümcesi içerir. Bu komut digesi, başlatım kütüklerinde toplanır. Bu kütükler kütük adı eki olarak .h alırlar. Biz şimdiye kadar yalnızca stdio.h başlatım kütüğünü kullandık.



Stdio.h kütüğü C’nin bütün standart giriş/çıkış fonksiyonlarını kullanmasına olanak sağlar.

En önemlilerinden bazıları şunlardır.



Stdio.h : C’nin en önemli kütüphanesi. Programın bütün üstdüzey giriş ve çıkışlarını yapar.



Math.h : Bütün matematiksel uygulamalarda kullanılır. tanjant, sinüs, cosinüs... gibi fonksiyonların kullanılmasına olanak sağlar.



Ctype.h : Bir değişkenin tipini kontrol eden bir dizi kısa yordam. Örneğin bir karakter değişkeninin nokta içerip içermediğine bakabilirsiniz.



Stdlib.h : Rasgele sayı üreten, sıralama yapan, Dos’a çıkan veya başka gerekli işleri yapan karışık bir yordam grubu.





C FONKSİYONLARI



Fonksiyon, belli bir işi yapmak üzere tasarlanmış program parçasıdır. Parametre (değer) kullanabilirler ve kullanmayabilirler. Fonksiyon bittiği zaman bir değer verbilir veya vermeyebilir. Printf(), en azından bir parametre kullanan bir C fonksiyonudur. Bu karakterleri ekrana yazdırır ve bir değer vermeden ana programa geri döner.



ÖRNEK

# include <stdio.h>

# include <ctype.h>

main( )

{

char a,b;

b=’F’;

a=tolower(b);

printf("a’nın değeri %c", a);

}



tolower( ) fonksiyonu C’nin ctype.h kütüphanesindedir. Bu fonksiyon büyük harfi küçük harfe çevirir.



Printf( ) fonksiyonu genel amaçlı bir format çevirim fonksyonudur. İki parametresi vardır. İlki bir karakter dizgisidir. % işareti ikinci parametrenin nereye konulacağını ve hangi biçimde yazılacağını gösterir.



FORMAT BELİRLEMESİ

char %c

int %d

float %f

ASCII DEĞER: Bilgisayarda, her bir karakter belli bir sayıya eşitlenir. Bu sayıya ASCII değeri adı verilir. Örneğin A harfi 65 olarak saklanır.



ÖRNEK

# include <stdio.h>

main( )

{

char=65;

printf("a=%c veya %d\n", a, a);

}



program sonucu a=’A’ veya a=65 olur.



SCANF( ) FONKSİYONU



Klavyeden değer okumak için kullanılır. scanf( ) ile kullanılan parametreler, printf( ) ile kullanılanlarla aynı kurala uyarlar.scanf( )’in format dizgileri genellikle format belirlemelerinden oluşur.



scanf("%d", &cevap);



Bu tümce bir tamsayı okur ve cevap adlı bir değişkeni bu tamsayıya eşitler.



Scanf( ) bir format dizgisi ve & işareti ile başlayan değişken isimleri listesi gerektirir, tüm değişken isimlerinin & ile başlaması gerekir. Scanf( ) <ENTER> tuşuna basılana kadar hiç bir şey okumaz. <ENTER> tuşuna basar basmaz, scanf( ) basılan tuşları okumaya baţlar.



ÖRNEK

# include <stdio.h>

main( )

{

int sayı;

scanf("%d", &sayı);

printf("sayınıa=%d\n", sayı);

}



ÖRNEK

# include <stdio.h>

main( )

{

char kar1,kar2,kar3,kar4;

scanf("%c%c%c%c", &kar1, &kar2, &kar3, &kar4);

printf("%c%c%c%c", kar1, kar2, kar3, kar4);

}



ÖRNEK

# include <stdio.h>

main( )

{

float a,b,c,d;

scanf("%f%f", &a, &b);

scanf("%f%f", &c, &d);

printf("%f%f%f%f", d, c, b, a);

}



NOT: Format belirlemesinin türünün, değişkeninki ile aynı olması gerekir. Sayısal değerler girilirken değerleri birbirinden boşluk, tab veya return tuşu ile birbirinden ayırmak gerekir. Char tipi değişkenlerde ise bu işlem yapılmaz.



KONTROL TÜMCELERİ



Kontrol tümceleri programın akışını kontrol ederler.

KONTROL YAPISI SINIFLARI



Kontrol yapıları üç ayrı grupta toplanabilir.



· if (eğer) tümceleri; farklı koşullar altında farklı tümcelerin işletilmesini sağlarlar.



· döngüler; bir dizi tümcenin bir kaç defa tekrarlanabilmesine olanak sağlarlar



· fonksiyonlar; bir dizi tümcenin programın değişik noktalarında kullanılmasını

sağlarlar. Her kontrol yapısı kontrol ettiği bir tümceyi veya tümce bloğunu içerir.



{

a=a+3;

z=a+b;

}

veya



{a=a+3;z=a+b}



tümceleri birer bloktur.



IF TÜMCELERİ



Bir if (eğer) tümcesi bir eşitliği kontrol eder ve eşitlik doğru ise, kontrol ettiği tümce işletilir. Eşitlik yanlış ise tümce göz ardı edilir.



İlk biçimi; if (eşitlik)

tümce;



C’de eşitlik için = = (çift eşit) işaretleri kullanılır.



a= =0;a==b;a= =1...

gibi



ÖRNEK

# include <stdio.h>

main( )

{

int a;

printf("a’nın değerini girin:");

scanf("%d", &a);

if (a= =1)

printf("a birdir\n");

}



ÖRNEK

# include <stdio.h>

main( )

{

int a;

printf("a’nın değeri :");

scanf("%d", &a);

if (a= =1)

{

a=a+100;

printf("a’nın değeri = %d\n", a); } }



NOT: Bir if cümlesi içerisinde eşitleme işlemi yapılabilir. Fonksiyonlar genellikle, işlemi yapabildikleri zaman doğru yapamadıkları zaman yanlış değerini alırlar.



ÖRNEĞİN atoi( ) fonksiyonu dizgileri sayıya çevirir.

atoi("451") dizgiyi yani "451"’i sayıya çevirebilir ve sonuç olarak doğru verir.



atoi("Ali") dizgiyi "Ali"’yi sayıya çeviremez ve yanlış verir.





ÖRNEK

# include <stdio.h>

main( )

{

int sayı;

if (sayı=atoi("592")) /* "==" değil */

printf("Dizgi bu sayıdır: %d\n", sayı);

}



İLİŞKİ İŞARETLERİ

a<b küçüktür

a>b büyüktür

a<=b küçük veya eţit

a>= büyük veya eţit

a!=b eşit değil



Bütün bu işlemlerde a veya b yerine herhangi bir değer, değişken veya eşitlik konulabilir.



a>=780

76<=9

x+23!=y-z

8-3==887-deger

IF-ELSE DEYİMİ : Genel yapısıaşağıdaki şekildedir.



İf (eşitlik)

tümce1;

else

tümce2;



eşitlik doğru ise tümce1 işletilir yanlış ise tümce2 işletilir.



ÖRNEK

# include <stdio.h>

main( )

{

int a, b;

printf("a=\n");

scanf("%d", &a);

printf("b= \n");

scanf("%d", &b);

if (a+b>=5)

printf("4’ten daha fazlalar\");

else

printf("4’den daha azlar\n"); }





KARMAŞIK EŞİTLİKLER



İki veya daha fazla eşitliği karşılaştırarak karmaşık eşitlikler oluşturulabilir. Bunun için and (ve), or (veya) kullanılır C’de; and için &&, or için || işaretleri kullanılır.



if (a==0 && b==0) Bu örnekte hem a=0, hem de b=0 ise doğru değeri verilir.



if (a==0 || b==0) tümcesinde a veya b sıfır ise doğru değeri verilir.



ÖRNEK

# include <stdio.h>

main( )

{

int a, b;

printf("a=\n");

scanf("%d", &a);

printf("b= \n");

scanf("%d", &b);

if (a==5 && b==5)

printf("ikisi de uyuyor\n");

}



Aritmetiksel işlemler gibi ilişkisel ve mantıksal işlemler de sonuç olarak bir değer verirler. İf tümcesindeki parantezin içinde yalnızca bir değer olması yeterlidir.



İf (değer)

tümce;



Değer doğru ise tümce işletilir. C’de 0 olmayan bütün sayılar doğrudur. Sıfır yanlışı

gösterir. İlişkisel ve mantıksal işlemlerde doğru genellikle -1, yanlış 0 değerini verirler.



ÖNCELİK SIRASINA GÖRE İŞLEMLER



Sembol Anlamı Öceliği



* çarpma 1

/ bölme 1

% modülüs 1

+ toplama 2

- çıkarma 2

< küçüktür 3

> büyüktür 3

<= küçükeţit 3

>= büyükeţit 3

== eţit 3

!= eşitdeğil 3

&& mantıksal ve 4

|| mantıksal veya 4

= eţitlik 5



ÖRNEK

# include <stdio.h>

main( )

{

int a=5, b=4, c=1;

if (a+b<=c*45)

printf("Bu doğrudur\n"); }



DÖNGÜLER (LOOPS)



Döngü adı verilen kontrol yapısı bir tümce blokunu bir kaç kez işletir. Döngü sayısının nasıl belirleneceği, döngünün tipine bağlıdır. C’de üç tip döngü vardır.



· while döngüsü

· for döngüsü

· do döngüsü



WHILE DÖNGÜSÜ



Bu döngü bir koşul doğru olduğu sürece tümce blokunu tekrarlar. Koşul geçerli olmadığı anda program döngüyü izleyen komutlara geçer. Koşul tümcesinin kullanımı ile aynıdır. Genel şekli;



while (koţul)

blok1;



ÖRNEK

# include <stdio.h>

main( )

{

int a;

a=10;

while (a>0)

{

a=a-1;

printf("a’nın değeri= %d\n", a);

}

printf("döngü bitti\n");

}



SONSUZ DÖNGÜ

ÖRNEK

# include <stdio.h>

main( )

{

int a;

a=10;

while (a>0)

{

printf("a’nın değeri= %d\n", a); }

printf("döngü bitti\n"); }



a değişkeni hiç değişmediği için koşul hiç değişmez ve döngü tekrarlanıp durur.



ARTIMLAR VE EKSİLİMLER



Döngü kullanımında kontrol değişkenine 1 eklenir (ileri sayma) veya 1 çıkartılır. (geri sayma)

Aritmetik olarak a=a+1 veya a=a-1 biçiminde yapılır. Ancak C bu işlemler için daha kısa yollar sunar. İşlem işaretlerinden ++ ve - artım ve eksilim işaretleri olarak tanınırlar. ++ değişken 1 ekler, -- değişkenden 1 çıkarır. Yukarıdaki örnek şu şekilde yapılabilir di.



# include <stdio.h>

main( )

{

int a=10;

while (a>0)

{

a--;

printf("a’nın değeri= %d\n", a); }

printf("döngü bitti\n"); }



Bu işlemlerin avantajı, bir eşitliğin içinde kullanılabilmeleridir. Her bir işlem iki biçimde kullanılabilir.

--a

a--

++a

a++

Sembol değişkenden önce gelirse artım veya eksilim işlemin bulunduğu tümceden önce yapılır. Sembol değişkenden sonra gelirse işlem tümceden sonra yapılır.



a=a-1;

printf("a’nın değeri= %d\n", a);

Bu aşağıdaki tek satıra dönüştürülebilir.



printf("a’nın değeri= %d\n", --a);



Aşağıdaki tümceyi ele alalım;



printf("a’nın değeri= %d\n", a--);



Bu aşağıdaki iki tümce ile aynı işi yapar;



printf("a’nın değeri= %d\n", a);

a=a-1;



NOT: Bu işlemler bulundukları eşitliğin bir parçası olmadıklarından diğer işlemlerden biraz farklı çalışırlar. Diğer tüm işlemlerden daha büyük bir önceliğe sahiptirler.



ÖRNEK

a=c++*12+saatlerin_toplamı;



Önceliği en yüksek işlem ++ olduğu için eşitlik şu duruma gelir.



a=c*12+saatlerin_toplamı;



c=c+1;



Burada c++ olduğu için a üzerinde bir etkisi yoktur.



A=++c*12+saatlerin_toplamı;



Burada ++c olduğundan ++ işleminin a üzerinde bir etkisi vardır.



c=a+++b; eşitliğinde belirsizlik vardır. C, artımı a değişkenine bağlar fakat istenmeyen durumlardan kaçınmak için



c=a+++b; eşitliği ya c=a++ +b; veya c=(a++) +b; şeklinde yazılır.





FOR DÖNGÜSÜ



For döngüsü program kontrolünü biraz daha basitleştirir. While döngüsü kadar esnek olmamasına rağmen anlaşılması ve kullanımı daha kolaydır. Genel bir kural olarak, bütün döngülerin üç ayrı parçası olmalıdır.



·ilk durum belirlenmelidir. (a=10

·durumu değiştirilmelidir. (a--

·döngünün sürüp sürmeyeceğinin belirlenmesi için durumu belirlemenin bir

yolu olmalıdır. (a>0)



for döngüsünün kullanımı şöyledir.



for (ilk durum; koşul ; değiştirici tümceler)

blok;



ÖRNEK

# include <stdio.h>

main( )

{

int a;

for (a=10; a>0; a--)

printf("a’nın değeri %d\n", a);

printf("döngü bitti");

}



for(a=10; a<0

printf("a’nın değeri\n");



sonsuz döngü; tümcenin yanlış olduğu hemen görülebilir.



ÖRNEK

# include <stdio.h>

main( )

{

int a;

printf("ilk değeri girin="); /*Başlangıç koşulunun girilmesi*/

scanf("%d", &a);

for(;a>0;a--)

printf("a’nın değeri %d\n", a);

printf("döngü bitti\n");

}



ÖRNEK

# include <stdio.h>

main( )

{

char ch=0;

while (ch!=’q’)

{

printf("döngü başlangıcı\n"); /* Bir miktar tümce */

printf("bitirmek için q’ya devam etmek için herhangi bir tuşa basın;");

ch=getch( );

printf("\n");

}

}



Bu program q harfi yazılana kadar açıklama satırı ile aynı blokta bulunan tümceleri tekrarlar. Yazılan tuşu okumak için getch( ) fonksiyonu kullanılır. getch( ) <ENTER> tuşuna basılmasını beklemez.



For döngüsü genellikle tekbir değişkenin değiştiği durumlarda kullanılır.



ÖRNEK

# include <stdio.h>

main( )

{

int a,b;

a=0;

b=100;

while (a!=b)

{

printf("ilk değer: \n"); scanf("%d", &a);

printf("2.değer: \n"); scanf("%d", &b);

}

printf("Bu sayılar eşittir\n"); }



Yukarıda verilen örneğin for döngüsü kullanılarak yapılması, bunun yazılması ve de

anlaşılması daha zordur. While ile yapılan program tercih edilir. Döngünün bitiş noktasının program yazılırken bilindiği uygulamalarda for döngüsü kullanılır.



ÖRNEK

# include <stdio.h>

main( )

{

int a,b;

for (a=0, b=100;a!=b)

{

printf("ilk= %d\n"); scanf("%d", &a);

printf("ikinci= %d\n"); scanf("%d", &b);

}

printf("Bu sayılar eşittir\n");

}



ÖRNEK



for(i=0;i<10;i++)



Bu döngü tam olarak 10 defa işletilir ve yalnızca döngü tümcesine bakılarak bu durum

anlaşılabilir. While döngüleri genellikle koşul değişkenlerinin bir kaç değişik şekilde

değiştirilebildiği durumlarda kullanılır.



while(i<10 && ch!=’q’)



Bu döngünün kaç defa işletileceği ancak döngü içindeki tümcelere bakılarak anlaşılır.

DO DÖNGÜSÜ



Do döngüsü for ve while döngüsünde kontrol edilen bitiş koşullarını döngü tümceleri işletildikten sonra kontrol eder. Bunun en önemli etkisi bir do döngüsündeki tümcelerin en az bir kez işletilmesidir. Genel kullanımı şöyledir;



do

blok;

while (koţul);



While döngüsünde olduğu gibi blok içindeki tümceler koşul doğru olduğu sürece iţletilirler. Koţul kontrol edilmeden önce blok içindeki tümceler bir defa iţletilir.



ÖRNEK

# include <stdio.h>

main( )

{

int ch;

do

{

printf("Bitirmek için q’ya basın:\n");

ch=getch( ); }

while(ch!=’q’);

printf("döngü bitti\n"); }



ÖRNEK

# include <stdio.h>

main( )

{

do

{

printf("bitirmek için q’ya basınız\n");

}

while(getch( )!=’q’);

printf("döngü bitti\n"); }



FONKSİYONLAR



Programın farklı yerlerinde benzer işlemler yapılması gerekiyorsa gerekli komutlar tekrarlanmalıdır. Fonksiyonlar bu konuda yardımcı olurlar. Fonksiyonlar programınızı ayrı ve kolay anlaşılabilir parçalara bölmenize olanak sağlarlar.



FONKSİYON BİLDİRİMLERİ



Bütün fonksiyonlar iki parçadan oluţurlar;



· bildirim

· gövde



Basit bir fonksiyon bildirimi olan main( )’i gördük. Bunu izleyen blok, main( ) fonksiyonunun gövdesidir.



Fonksiyonların genel sintaksı aşağıdaki gibidir.



tip fonksiyon_ismi (parametre1, parametre2, ..., parametreN)

parametre bildirimleri;

blok;



Tip fonsiyonun verceği değerin tipini gösterir.



ÖRNEK

# include <stdio.h>

merhaba_de( )

{

printf("Merhaba\n");

printf("Bu bir fonksiyon ile yazıldı\n");

}

main( )

{

printf("Bir defa çağır\n");

merhaba_de( );

printf("Bir kaç defa çağır\n");

merhaba_de( );

merhaba_de( );

}



Fonksiyon bildirimi main( ) fonsiyonundan önce yapılmıştır. Fonksiyon yalnızca fonksiyon ismi, parantezler ve bir ;’den oluşan tek bir tümce kullanılarak çağrılabiliyor.



Derleyici ;’ fonksiyon bildirilerini fonksiyon çağrılarından ayırmak kullanır.



RETURN TÜMCESİ



Bir fonksiyondan kendisini çağıran programa geri dönmek için return tümcesi kullanılır. Return’u herhangi bir terim izleyebilir.



Return (terim)

şeklindedir. Çağıran fonksiyon gerekirse gönderilen terimi göz ardı edebilir.



int toplam(a, b)

int a,b;

{

int c;

c=a+b;

return c; }



Bu program ana programdan iki değer alır (a ve b) bunlar toplanır ve sonuç c’ye yerleştirilir. Sonra fonksiyon bu sonucu ana programa göndererek fonksiyonu sona erdirir.



PARAMETRELER



Parametre program ile fonksiyon arasında bilgi aktarmakta kullanılan özel bir değişkendir. Parametre tanımlamaları fonksiyon isminden hemen sonra tanımlanır. Fonksiyon isminden önce tip bildirimi yapılır, bu fonksiyonun ana programa hangi tipte değer göndereceğini belirtir.



Herhangi bir değer vermeyen bir fonksiyonun tipi void olarak bildirilir. Bir fonksiyonun gönderdiği değerleri kullanabilmek için bir değişkeni fonksiyonun ismine eşitlemek gerekir.



ÖRNEK

# include <stdio.h>

int toplam(a, b)

int a, b;

{

int c;

c=a+b;

return c;

}

main( )

{

int a;

a=toplam(3, 4);

printf("toplam= %d\n", a);

}



Bir bildirimde tip belirtilmezse C int tipi bir değer istediğimizi varsayar. Bununla birlikte bazı hatalarla karşılaşmamak için tip belirtilmelidir.



Fonksiyon bir değer vermesini istemiyorsanız void sözcüğünü kullanmalısınız.



YEREL DEĞİŞKENLER



Yukarıdaki örnekte toplam( ) fonksiyonundaki a, main( )’deki a’dan farklıdır. Çünkü a yerel bir değişkendir. Bu değişken ve parametreler yalnızca bildirdikleri fonksiyonun içinde tanınabilirler. Hiç bir fonksiyon başka bir fonksiyonun içinde bildirilen parametre ve değişkenleri tanıyamaz. Bu nedenle bir programda aynı isimde birden fazla değişken kullanılabilir.



PROTOTİP



Prototip TURBO C’ye fonsiyonun formatını gösterir. C’de bunu kullanır ve fonksiyon çağrısı yapılmadan önce bütün değerlerin uygun tiplerine çevrilmelerini sağlar. Bildirim şekli şöyledir;



tip fonsiyon_ismi(tip,tip, ...,tip);



Bir bildirimden farklı olarak prototipin sonuna bir noktalı virgül konulmalıdır.



İnt toplam(int, int);

gibi



ÖRNEK

# include <stdio.h>

int toplam(int,int);

int toplam(a,b)

int a,b;

{

int c;

c=a+b;

return c; }

main( )

{

int a;

a=toplam(3.1,4.2);

printf("a’nın değeri= %d\n", a);

}





parametre kullanmayan fonksiyonlar için



void merhaba_de(void);



şeklinde prototip tanımlanır.



İÇ İÇE FONKSİYONLAR



# include <stdio.h>

int toplam(int,int);

void bekle(void);

toplam(a,b)

int a,b;

{

int c;

printf("%d ile %d toplanacak\n",a,b);

bekle( );

c=a+b;

return c;

}

void bekle(void)

{

printf("Devam etmek için herhangi bir tuşa basın\n");

getch( );

}

main( )

{

int x,y;

y=5;

x=toplam(4,y);

printf("sonuç=%d\n",x);

}



DİZİLER



Dizi aynı ad altında toplanmış ve aynı tipte olan değişkenlerin sıralı bir listesidir. C’de bir dizi için bildirim yapılırken kullanılan genel kural şudur.



tip dizi_ismi[eleman_sayısı];



Bütün diziler 0 ile baţlar.



ÖRNEK

# include <stdio.h>

main( )

{

int sayı_listesi[10]; /* 10 tamsayı içieren bir dizi */

sayı_listesi[4]=823;

sayı_listesi[0]=38;

printf("eleman %d : %d\n",4,sayı_listesi[4]);

pirntf("eleman %d : %d\n",0,sayı_listesi[0]);

}



ÖRNEK

# include <stddio.h>

main()

{

int i, tpl;

int a[10], b[10], c[10];

for (i=0;i<=9;i++)

a[i]=b[i]=c[i]=0;

tpl=0;

for (i=0;i<=9;i++)

{

a[i]=i;

b[i]=i*i;

c[i]=2*a[i]+b[i];

tpl=tpl+c[i];

}

printf (" sayi karesi 2*sayi+karesi \n");

for (i=0;i<=9;i++)

printf("%8d %8d %8d \n", a[i],b[i],c[i]);

printf(" toplam =%d \n",tpl);

}



ÖRNEK

# include <stddio.h>

int i;

int kare[21];

{

for (i=1;i<=20;i++)

kare[i]=i*i

}



ÖRNEK

# include <stdio.h>

main( )

{

int i;

float sonuc[10];

printf("10 tane reel sayı girin\n");

for (i=0;i<10;i++);

{

printf("No %d:",i+1);

scanf("%f, &sonuç[i]);

}

printf("sayılar girildi\n");

printf("sonuç için 1 ile 10 arasında bir sayı\n");

printf("çıkış için 0 yazın\n);

do

{

printf(":"); scanf("%d", &i);

if (i>0 && i<11) /* geçerli bir eleman (1-10) */

printf("Eleman %d, %f içeriyor\n", i, sonuç[i-1]); /* elemanlar 0 ile 9 arasında */

}

while (i!=0)

}



KARAKTER DİZGİLERİ



Bir sözcük veya tümceyi bir değişkende saklamak istediğimizde bunu yapmanın bir yolu tümceyi bir karakter dizisine yerleştirmektir.



Bir dizgi, bir dizi olduğu için = işareti kullanılamaz.



Bir dizgiyi bir karakter dizisinden diiğerine taşımak için dizgi kopyalama fonksiyonu olan strcpy( )’yi kullanmak gerekir. Bu fonksiyonun iki parametresi vardır. Kaynak dizgisi ve hedef dizgisi.



char hedef[80];

char kaynak[80];

strcpy (hedef,kaynak);



ÖRNEK

# include <stdio.h>

main( )

{

char dizgi1[80], dizgi2[80];

printf("lütfen bir dizgi girin\n:");

scanf("%s", &dizgi1);

printf("bu dizgi2’ye aktarılıyor\n");

strcpy(dizgi2, dizgi1);

printf("Dizgi %s\n", dizgi2);

}



NOT :Bir dizi aynı ad altında bir araya gelmiş olan bir grup değişkenden oluşur. Dizinin her bir değerine elman adı verilir. Bir elemanı belirtmek için kullanılacak sayı pozitif bir tam sayı olmalıdır ve bu elemanın içerdiği değer herhangi bir tipte olabilir.

MATRİS İLE İLGİLİ ÖRNEK:
# define sira 3
# define kolon 3
# include <stdio.h>
main()
{
int i, j, k, katsayı;
int matris [sira][kolon];
for (i=0;i<sira;i++)
for (j=0;j<kolon;j++)
matris[i][j]=0;
for (i=0;i<sira;i++)
{
j=0;
while (j<kolon)
{
printf("matris[%d][%d]=",i,j);
scanf("%d",&katsayi);
if (katsayi<0)
break;
matris[i][j]=katsayi;
j++;
}
}
for (i=0;i<sira;i++)
{
for (j=0;j<kolon;j++)
printf("matris[%d][%d]=%d",i,j,matris[i][j]);
printf("\n");
}
}
BREAK DEYİMİ
C de döngüden çıkmak için kullanılır. Bilgisayar döngünün sonunu beklemeden, istenilen koşulun sağlandığını kabul ederek, bir sonraki satırdaki komutları işletir.
for, while veya do..while döngülerinde kullanılır. if..else ile kullanılamaz.
Örnekte, katsayi sıfırdan küçük olursa, o sıradaki diğer elemanların hep sıfır değeri alması istendi. Bu durumda break ile bilgisayar j döngüsünden çıkıp bir sonraki i değerini alarak işleme devam eder.
ÖRNEK (CONTINUE deyimi) : C 'de continue "kaldığın yerden devam et", döngüyü tamamlayıncaya kadar devam et anlamındadır.
# include <stdio.h>
main()
{
int i, j;
int a[5];
for (i=0;i<5;i++)
a[i]=0;
for (i=0;i<5;i++)
scanf("%d",&a[i]);
for (i=0;i<5;i++)
{
if ( a[i]<0)
continue;
printf("%d TAMAM \n", a[j]);
} }
Bu örnekte, eğer a[j] değeri sıfırdan küçükse döngünün sonuna, yani { işaretine kadar gitmeden başa dön, j nin bir sonraki değerini alarak işleme devam et denmektedir.
program çalıştırıldığında; 11 -22 33 -44 55 değerleri girilirse
11 TAMAM
33 TAMAM
55 TAMAM
çıktısı elde edilir.
ÖRNEK : Enter tuşuna basıncaya kadar verilen tüm karakterleri ASCII koduna çeviren program.
# include <stdio.h>
main()
{
int i;
cahar c;
for (i=0;(c=getchar())!='\n';++i)
printf("%d \n",c);
}
ÖRNEK ( Özel operatörler ve ifadeler)
# include <stdio.h>
main()
{
int a, b, i;
for (i=0;i<=10;i++)
a=a+i;
printf("toplam a nın değeri = %d \n",a);
for (i=0;i<=10;i++)
b+=i;
printf("toplam b nin değeri = %d \n", b);
}
Bu örnekte a=55 ve b=55 değeri elde edilir.
Genel olarak x=x+y yerine x+=y yazılabilir. Yani,
x=x op y yerine x op =y komutu yazılabilir.
Örneğin;
x=x*(y+1) yerine x *=(y+1) yazılabilir.
ÖRNEK toplamını a, b, n 'in çeşitli değerleri için hesaplanacağını düşünüp bunun için bir fonksiyon yazalım.
# include <stdio.h>
main()
{
double seri();
int i;
for (i=1;i<=5;++i)
printf("%d %1.6f %1.6f %1.6f \n", i, seri(1,i,0), seri(2,i,1));
}
double seri(a,n,b)
int a,n,b;
{
double s, r;
int j;
r=0;
s=0;
for (j=1;j<=n;++i)
{
r=a*j-b;
s=s+(1/r);
}
return(s);
}
ÖRNEK (Kısaltılmış if)
# include <stdio.h>
main()
{
int i; float a, b, z;
a=4; b=1.5; z=0;
for (i=0; b<=a+100.0; i++)
{
a=(a+7.3)*i;
b=(b+1.0)*(i+1.0);
if (a>b)
z=a;
else
z=b;
printf(%12.7f \n", z); } }
NOT : C ' de mümkün olan diğer bir kısaltma da if ... else deyimlerinde ? işaretinin operatör olarak kullanılmasıdır. Yukarıdaki programın aynısı bu operatör kullanılarak aşağıda verilmiştir.
# include <stdio.h>
main()
{
int i; float a, b, z;
a=4; b=1.5; z=0;
for (i=0; b<=a+100.0; i++)
{
a=(a+7.3)*i;
b=(b+1.0)*(i+1.0);
z=(a>b) ? a: b;
printf(%12.7f \n", z); } }
Not: z=(a>b) ? a: b; ifadesinde önce (a>b) işelem konur, eğer true (yani pozitif, doğru) ise 2.parametre olan a işlem görür, yani z=a; daha sonra ise yani (a>b) değilse son parametre olan b işlem görüyor, yani z=b; olur.
BAZI ÖNEMLİ MATEMATİK FONKSİYONLARI
Eklenecek kütüphaneler:
# include <math.h>
# include <stdlib.h>
radyan = acı*pi/180, x double tipli değişken
sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), sinh(x), cosh(x), tanh(x), sech(x)
************************************************** ************
sqrt(x) : x in karekökünü hesaplar
log(x) : e tabanına göre logaritma alır (ln(x))
log10(x) : 10 tabanına göre logaritma alır
pow(x,y) : değerini hesaplar
exp(x) : değerini hesaplar
ceil(x) : x den küçük olmayan en küçük tamsayıyı hesaplar (tamdeğer)
fabs(x) : x in mutlak değerini hesaplar
fmod(x,y) : x/y oranında kalanı hesaplar.
abs(x) : tamsayı olan x in mutlak değerini verir.
labs(x) : long türünden olan x in mutlak değerini verir.
max(x,y) : x, y nin enbüyüğünü bulur
min(x,y) : x, y nin enküçüğünü bulur
rand() : 0 ile 32767 arasında rasgele bir sayı seçer
rand(x) : 0 ile x arasında rasgele bir sayı seçer
randomize(); rasgele sayı için başlangıç değerini değiştirir
( <time.h> da eklenmelidir)
ÖRNEK PROGRAMLAR
************************************************** *****************
faktoryel hesaplayan program
************************************************** *****************
#include<stdio.h>
/* 1 den 100 e kadar olan sayilarin faktoriyeli */
main()
{ int a,i;
double f;
f=1;
clrscr();
for (a=1;a<101;a++)
{ f=f*a;
printf(" %d faktoriyel %f \n",a,f);
i++;
if (i>10)
{i=1;
getch(); }
}
getch();
}
************************************************** ********************
Asal sayıları bulan program
************************************************** ********************
/* BIRDEN 2000 E KADAR ASAL SAYILARI BULAN PROGRAM */
#include <stdio.h>
#include <math.h>
float tam(sayi)
float sayi;
{
int i;
i=sayi;
return i+.0;
}
int asal(sayi)
int sayi;
{
int i,sonuc;
sonuc=1;
for (i=2;i<sayi/2+1;i++)
{
if ((sayi+.0)/i==tam((sayi+.0)/i))
{
sonuc=0;
i=sayi;
}
}
if (sayi==-1 ||sayi==0||sayi==1) sonuc=0;
return sonuc;
}
main()
{
int j;
clrscr();
for(j=2;j<2000;j++)
if (asal(j)==1) printf("%4d",j);
getch();
}

*******************************************

e değerini hesaplayan program

*******************************************

#include <stdio.h>

#include<math.h>

double fakt(sayi)

int sayi;

{

int i;

double fak=1.0;

for (i=1;i<sayi+1;i++)

fak=fak*i;

return fak;

}

double expu(x)

float x;

{

int i;

double e=0.0;

for (i=0;i<41;i++)

e=e+pow(x,i)/fakt(i);

return e;

}

main()

{

float x;

clrscr();

printf("Exp i alinacak sayiyi giriniz..:");

scanf("%f",&x);

printf("Yaklaşık exp(%f)=%.20f\n",x,expu(x));

printf("program fonksiyonu exp(%f)=%.20f",x,exp(x));

getch();

}





************************************************** ***

Bazı betimsel istatistikleri hesaplayan program

************************************************** ***

#include<stdio.h>

#include<math.h>

# define boyut 1000

main()

{

int t,a,n,i,j;

int dizi[boyut], max,min,gen;

double var,ort,ss,med;

int vr;

clrscr();

printf("dizi kac elemanli = ");

scanf("%d",&n);

printf("elemanlari girin \n ");

for (i=1;i<n+1;i++)

{ printf(" %d",i);printf(".eleman=");

scanf("%d",&dizi[i]);}

/* siralama */

for(i=1;i<n;i++)

for(j=i+1;j<n+1;j++)

if (dizi[i]>dizi[j])

{ a=dizi[i];

dizi[i]=dizi[j];

dizi[j]=a;

}

printf("SIRALI HALi.. ");

for(i=1;i<n+1;i++)

printf("%d ",dizi[i]);

printf("\n");

/* max min */

max=dizi[n];min=dizi[1];gen=max-min;

printf("maximum= %d \n",max);

printf("minimum= %d \n",min);

printf("orneklem genisligi= %d \n",gen);

/* ortalama s.sapma varyans*/

t=vr=0;ort=var=ss=0;

for(i=1;i<n+1;i++)

t=t+dizi[i];

ort=t/n;

for(i=1;i<n+1;i++)

vr=vr+pow((dizi[i]-ort),2);

var=vr/(n-1);

ss=sqrt(var);

printf("ortalama %f \n",ort);

printf("varyans %f \n",var);

printf("s.sapma %f \n",ss);

printf("ortanca ");

if (pow(-1,n)<0) med=dizi[(n+1)/2];

else med=(dizi[n/2]+dizi[n/2+1])/2;

printf("%f \n",med);

getch();

}







************************************************** ***

program adi : kokbul.c

Çeşitli fonksiyonların köklerini değişik yöntemlerle bulan program

************************************************** ***

#include<stdio.h>

#include<math.h>

#include <conio.h>

#include <stdlib.h>

#include <graphics.h>



int e=2.71182818;

char *dizi[14];

void aktar(void)

{

int sayac;

int graphdriver=DETECT,graphmode;

initgraph(&graphdriver,&graphmode,"");

setbkcolor(1);

setcolor(14);

settextstyle (GOTHIC_FONT,HORIZ_DIR,1);

setcolor(11);

setlinestyle(0,0,3);

settextstyle(DEFAULT_FONT,HORIZ_DIR,2);

outtextxy(250,15,"SORULAR");

gotoxy(1,1);printf("Selcuk Cobanoglu");

gotoxy(4,2);printf("95052732");

line(0,50,700,50);

settextstyle(SMALL_FONT,HORIZ_DIR,7);



dizi[1]=" X-SIN(X)-1=0 ";

dizi[2]=" X-e^(-X)=0 ";

dizi[3]=" X^3+10X-11.6=0 ";

dizi[4]=" X*e^X-1=0 ";

dizi[5]=" X^3-100=0 ";

dizi[6]=" e^X-3*X=0 ";

dizi[7]=" X*TAN(X)-0.5=0 ";

dizi[8]=" COS(X)=3*X ";

dizi[9]=" X^3-3X+1=1 ; Xo=1.5 ";

dizi[10]=" e^X-LN(X)=20 ";

dizi[11]=" e^X=(2*X)+21 ; Xo=3 ";

dizi[12]=" LN(X)=1+1/(X^2) ";

{

settextstyle(SMALL_FONT,HORIZ_DIR,1);

setcolor(1);

for (sayac=1;sayac<13;sayac++)

{

gotoxy(30,4+sayac);printf("%d",sayac);printf(dizi[sayac]);

printf("\n");

}

}

}

/******************************************/

double fonk(double x,int fno)

{

double f1;

switch(fno)

{

case 1:{f1= x-sin(x)-1;break;}

case 2:{f1= x-pow(e,-1*x);break;}

case 3:{f1= pow(x,3)+10*x-11.6;break;}

case 4:{f1= x*pow(e,x)-1;break;}

case 5:{f1= pow(x,3)-100;break;}

case 6:{f1= pow(e,x)-3*x;break;}

case 7:{f1= x*tan(x)-0.5;break;}

case 8:{f1= cos(x)-3*x;break;}

case 9:{f1= pow(x,3)-3*x;break;}

case 10:{f1= pow(e,x)-log(x)-20;break;}

case 11:{f1= pow(e,x)-2*x-21;break;}

case 12:{f1= log(x)-1-1/pow(x,2);break;}

}

return f1;

}

/************************************/

double turev(double x,int fno)

{

double t1;

switch(fno)

{

case 1:{t1= 1-cos(x);break;}

case 2:{t1= 1+pow(e,-1*x);break;}

case 3:{t1= 3*pow(x,2)+10;break;}

case 4:{t1= pow(e,x)+x*pow(e,x);break;}

case 5:{t1= 3*pow(x,2);break;}

case 6:{t1= pow(e,x)-3;break;}

case 7:{t1= tan(x)+x*(1+pow(tan(x),2));break;}

case 8:{t1= -1*sin(x)-3;break;}

case 9:{t1= 3*pow(x,2)-3;break;}

case 10:{t1= pow(e,x)-1/x;break;}

case 11:{t1= pow(e,x)-2;break;}

case 12:{t1= 1/x+2/pow(x,3);break;}

}

return t1;

}

/************************************/

double ifonk(double x,int fno)

{

double f1;

switch(fno)

{

case 1:{f1= sin(x)+1;break;}

case 2:{f1= pow(e,-1*x);break;}

case 3:{f1= (11.6-pow(x,3))/10;break;}

case 4:{f1= pow(e,-1*x);break;}

case 5:{f1= 10/pow(x,0.5);break;}

case 6:{f1= log(3*x);break;}

case 7:{f1= atan(1/(2*x));break;}

case 8:{f1= cos(x)/3;break;}

case 9:{f1= pow(x,3)-3*x;break;}

case 10:{f1= log(log(x)+20);break;}

case 11:{f1= log(2*x+21);break;}

case 12:{f1= pow(e,1+1/(x*x));break;}

}

return f1;

}

/************************************/

void cevap(no,yontem)

int no,yontem;

{

int sayac;

float xx,x,x1,x2,eps;

printf("Xo 'i Giriniz..:");

scanf("%f",&xx);

printf("Epsilon'u Giriniz");

scanf("%f",&eps);

printf("\n");

if (yontem==1 && no!=10 && no!=12)

{

/***YARILAMA YONTEMI********/

sayac=1;

x1=-1*5;

x2=5;

x=(x1+x2)/2;

printf("Xo=%f\n",x);

while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)

{

if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;

x=(x1+x2)/2;

printf("X%d=%f\n",sayac,x);

sayac++;

}

printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));

}

if (yontem ==2 && no!=10 && no!=6 && no !=12)

{

/***REGULA FALSI YONTEMI****/

sayac=1;

x1=-1*10;

x2=5;

x=(x1+x2)/2;

printf("Xo=%f\n",x);

while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)

{

if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;

x=(x1*fonk(x2,no)-x2*fonk(x1,no))/(fonk(x2,no)-fonk(x1,no));

printf("X%d=%f\n",sayac,x);

sayac++;

}

printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));

}

if (yontem==3)

{

/*** NEWTON RAPSON YONTEMI***/

sayac=1;

x=xx;

printf("Xo= %f\n",x);

while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)

{

x=x-(fonk(x,no)/turev(x,no));

printf("X%d= %.6f\n",sayac,x);

x1=x;

}

printf("\nE%d=%.6f\n",sayac-1,ifonk(x,no));

}

if (yontem==4)

{

/***BASIT ITERASYON YONTEMI****/

sayac=1;

x=xx;

printf("Xo= %f\n",x);

while (-1*eps>=x-ifonk(x,no) || x-ifonk(x,no)>=eps)

{

x=fonk(x,no);

printf("X%d= %.6f\n",sayac,x);

}

printf("\nE%d=%.6f\n",sayac-1,x-ifonk(x,no));

}

}

/************************************/

main()

{

int s,y;

aktar();

gotoxy(45,40);printf("Secenek Gir..:");

scanf("%d",&s);

gotoxy(50,50);printf(" \n YONTEMLER \n");

gotoxy(50,51);printf("1 => YARILAMA\n");

gotoxy(50,52);printf("2 => REGULA FALSI\n");

gotoxy(50,53);printf("3 => NEWTON RAPSON\n");

gotoxy(50,54);printf("4 => BASIT ITERASYON\n\n");

gotoxy(50,55);printf("Secenek Giriniz..:");

scanf("%d",&y);

if (s>0 && s<14) cevap(s,y);

getch();

}







************************************

matrislerle ilgili iţlem yapan program

************************************

#include<stdio.h>

/* matrislerin toplami max min toplami max-min satir top min olan sutun*/

main()

{

int n;

int ma[100][100],mb[100][100],mc[100][100];

int i,j,k,s;

int maxa,maxb,mina,minb,satir[100],sutun[100];

int iza[100][100],izb[100][100],a[100],b[100];

clrscr();

printf("n= ");

scanf("%d",&n);

for (i=1;i<n+1;i++)

for (j=1;j<n+1;j++)

ma[i][j]=0;

mb[i][j]=0;

mc[i][j]=0;

printf("A matrisi (nxn) \n");

for(i=1;i<n+1;i++)

for(j=1;j<n+1;j++)

scanf("%d",&ma[i][j]);

printf("B matrisi (nxn) \n");

for(i=1;i<n+1;i++)

for(j=1;j<n+1;j++)

scanf("%d",&mb[i][j]);

for(i=1;i<n+1;i++)

for(j=1;j<n+1;j++)



mc[i][j]=ma[i][j]+mb[i][j];

for(i=1;i<n+1;i++)

for(j=1;j<n+1;j++)

printf("%d ",mc[i][j]);

printf(" \n ");

/* max - min bulma */

maxa=ma[1][1];mina=ma[1][1];

maxb=mb[1][1];minb=mb[1][1];

for(i=1;i<n+1;i++)

for(j=1;j<n+1;j++)

{if (maxa<ma[i][j]) maxa=ma[i][j];

if (maxb<mb[i][j]) maxb=mb[i][j];

if (mina>ma[i][j]) minb=ma[i][j];

if (minb>mb[i][j]) minb=mb[i][j];}

printf("a matrisinin en buyuk degeri= %d \n",maxa);

printf("b matrisinin en buyuk degeri= %d \n",maxb);

printf("a matrisinin en kucuk degeri= %d \n",mina);

printf("b matrisinin en kucuk degeri= %d \n",minb);

/* satir ve sutunda max min */

for(i=1;i<100;i++)

{satir[i]=0;sutun[i]=0; }

for(i=1;i<n+1;i++)