BİL131 – DERS 7 // 10.12.2013

0 40
FONKSİYONLAR
C, çeşitli görevleri yürütmek üzere programcıların kendi fonksiyonlarını tanımlamalarına olanak sağlar. Programcı-tanımlı fonksiyonlar, programın, her birinin kendi içinde belli bir görevi olan daha küçük parçalara (modüllere) ayrılmasını sağlarlar. Bu şekilde, bir C programı bu tip fonksiyonların zekice kullanımıyla modüllere ayrılabilir.
Sıkça kullanılan komutlar, gerektiğinde tekrar ulaşılması için tek bir fonksiyonun içine yazılabilir. Böylelikle, fonksiyon kullanımı aynı komutların tekrar tekrar yazılması gerekliliğini ortadan kaldırmış olur.
C’de sıklıkla kullanılan matematiksel hesaplamalar için library fonksiyonları mevcuttur. Bu fonksiyonlar gerekli işlemleri yapmak üzere bir fonksiyon çağrısıyla çalıştırılırlar.
Fonksiyon kullanımı aynı zamanda programcının sıklıkla kullandığı rutinlerin bir library (kitaplık)’sini oluşturmasına olanak sağlar. Her rutin ayrı bir fonksiyon olarak tanımlanarak belli bir library dosyasında saklanabilir.
4.1 GİRİŞ
Fonksiyon, belli bir görevi yerine getiren program parçasıdır. Her C programı bir veya daha fazla fonksiyon içerir. Bu fonksiyonlardan biri main (ana fonksiyon) olmalıdır. Program her zaman main içindeki komutları işleyerek çalışmaya başlar. Diğer fonksiyonlar main’in altında çalışırlar.
Çok sayıda fonksiyon içeren bir programda fonksiyon tanımları istenen sırayla yapılabilir, fakat bütün fonksiyonlar birbirlerinden bağımsız olmalıdır. Fonksiyonlar programın başka bir kısmı tarafından erişildiklerinde kendilerinden istenen işi yaparlar. Aynı fonksiyon programın içinde farklı yerlerden çağırılabilir. İşlem bittikten sonra, program fonksiyonun çağrıldığı yerden çalışmaya devam eder.
Bilgiler fonksiyona argüman (ya da parametre) denilen özel tanımlamayıcılarla geçirilirken, return (dönüş) ifadesiyle fonksiyondan alırlar (döndürülürler). Bazı fonksiyonlar veri kabul etmelerine rağmen, hiçbir şey döndürmeyebilirler (örneğin, library fonksiyonu printf).
Bazıları ise (library fonksiyonu scanf gibi) birden çok değer döndürürler. .
4.2 FONKSİYON TANIMLAMA
Fonksiyon tanımı döndüreceği değerin tipi ve parametreleri deklare edilerek yapılır. Fonksiyon tanımı şöyle yazılabilir:
veri-tipi isim(argüman deklarasyonları)
{
değişken deklarasyonları
fonksiyon ifadeleri
}
Fonksiyon tanımının ilk satırındaki veri-tipi fonksiyon tarafından döndürülen değerin tipine, isim fonksiyonun adına, argüman deklarasyonları parantez içinde virgüllerle ayrılmış argümanların isimlerine ve tiplerine karşılık gelmektedir. Fonksiyon tam sayı veya karakter döndürüyorsa tipin belirlenmesi göz ardı edilebilir (karakterlerin tam sayı değerler olarak gösterildiğini hatırlayınız). Fonksiyonun tanımı hiçbir argüman içermiyorsa, fonksiyonun adından sonra boş parantezler konulmalıdır.
Örnek 4.1.
float rectangle(float length, float width)
{
. . .
}
Fonksiyon tanımı rectangle’ı float tipli bir değer döndüren bir fonksiyon olarak tanımlamaktadır. Fonksiyon, float tipli iki argümana da sahiptir. Argümanlar programın fonksiyonu çağırdığı yerden fonksiyona veri aktarılmasını sağlarlar.
parametre olarak da adlandırılırlar. function reference (fonksiyona referans) içinde bunlara karşılık gelen argümanlara gerçek argüman (actual arguments) denir. Argüman olarak kullanılan tanımlayıcılar “yerel” (lokal) olduklarından, fonksiyon dışında algılanmazlar. Bu yüzden, argümanların isimleri fonksiyonun dışında yer alan diğer tanımlayıcıların isimleriyle aynı olabilirler. Fonksiyonun içeriği fonksiyon-ifadeleriyle izlenen değişken deklarasyonlarından oluşur.
Değişken deklarasyonu fonksiyon tarafından kullanılan değişkenlerin adlarını ve tiplerini belirler. Bunlar yerel değişkenlerdir ve yalnızca tanımlandıkları fonksiyon içinde algılanırlar (fonksiyon dışında algılanmazlar). Fonksiyon-ifadeleri fonksiyon tarafından yapılacak olan işi belirler. Bir ifade dizisidir. Diğer ifade dizileri gibi, koşul ifadeleri, başka ifade dizileri, kontrol ifadeleri vs. içerebilirler.
Örnek 4.2. Aşağıdaki fonksiyon iki tam sayı değer alıp büyük olanı belirlemektedir. Kendisini çağıran programa iki tam sayıdan büyük olanını döndürür (gönderir).
/* İki tam sayıdan büyük olanını belirle*/
int maximum(int x, int y)
{
int z;
(x >= y) ? x y;
return (z);
}
maximum fonksiyonu programın kendisini çağıran yerine tam sayı değer döndürmektedir.  x ve y adlı iki tam sayı tipli argümana sahiptir ve yerel tam sayı tipli z parametresini sonucu tutmak için kullanmaktadır.
Veri, fonksiyondan programın kendisini çağırdığı yere return ifadesiyle döndürülmektedir. return ifadesi
return expression;
şeklinde yazılır.
Expression’ın değeri program tarafından çağrıldığı yere döndürülür.Expression’ı yazmak isteğe bağlıyken, return ifadesi expression’sız da yazılabilir.
return;
return ifadesi basit anlamda hiçbir veri transferi yapılmadan, program tarafından fonksiyonun çağrıldığı yere dönülmesini sağlar.
Fonksiyonlar çağrıldıkları yere return komutuyla sadece tek bir değer döndürebilirler. Fonksiyonlar her biri farklı bir expression içeren birden fazla sayıda return ifadesi içerebilirler. Farklı dallanmalar barındıran fonksiyonlar genelde birden fazla return’e sahiptirler. Küçük harfi büyük harfe çeviren lower_to_upper fonksiyonu üzerinde duralım.
Örnek 4.3.
/* Programcı tanımlı dönüştürme fonksiyonu*/
lower_to_upper(char c1)
char c1;
{
char c2;
c2 (c1 >= ‘a’ && c1 <=’z’ ? (‘A’ + c1 – ‘a’ ) : c1;
return(c2);
}
İlk satırda c1 argümanıyla izlenen lower_to_upper fonksiyon adı bulunmaktadır. c1, çağrıldığı yerde fonksiyona gönderilen küçük harfi temsil etmektedir. İkinci satırda, c1 argümanı karakter tipli bir değişken olarak tanımlanmıştır. Fonksiyonun ana bölümü karakter tipli yerel değişken c2’nin deklarasyonunu içermektedir. c2’nin deklarasyonunun ardından gelen ifade ise c1’in küçük harf olup olmadığını test ederek dönüştürme işlemini yapmaktadır. Orijinal karakter küçük harf değilse aynen döndürülür. Son olarak, return ifadesi dönüştürülen karakterin çağrıldığı yere döndürülmesini sağlar.
Örnek 4.4. Aşağıdaki fonksiyon iki tam sayı değeri alıp büyük olanı belirleyerek ekrana yazdırır. Fonksiyon programın ana kısmına hiçbir şey döndürmez.
/* İki tam sayı değerden büyük olanını belirle/
maximum(x, y)
int x, y;
{
61
int z;
(x >= y) ? x y;
printf(“\n\n Maksimim değer = %d”, z);
return;
}
İlk satırda belirtilen veri tipi return ifadesindeki anlatımla uyuşmalıdır. Fonksiyon hiçbir şey döndürmüyorsa, void anahtar kelimesi fonksiyon tanımlanırken bir şey döndürülmeyeceğini belirtmek üzere kullanılmalıdır.
Örnek 4.4. İki tam sayı değeri alıp bunlardan büyük olanını yazdıran programı  tekrar düşünelim. Bu fonksiyonun hiçbir şey döndürmediğini anımsayınız. Bu yüzden, pek çok uyarlayıcı fonksiyonun şu şekilde yazılmasına olanak sağlar:
/* İki tam sayı değerden büyük olanını belirle*/
void maximum(x, y)
int x, y;
{
int z;
z =(x >=y) ? x : y;
printf(“\n\nMaksimim değer = %d”, z);
}
4.3 FONKSİYON ÇAĞIRMA
Fonksiyonlar, isimleri ve ardından parantez içinde virgüllerle ayrılmış argümanları yazılarak çağırılabilirler. Fonksiyon hiçbir argüman gerektirmiyorsa, fonksiyonun adından sonra bir çift boş parantez konmalıdır. Aşağıdaki yapıdadır:
Fonksiyon_adı(argüman listesi)
Fonksiyon_adı çağrılan fonksiyonun adını, argüman listesi de fonksiyonun argümanlarını oluşturan anlatımlardır. Fonksiyona çağrı yapılan yerdeki argümanlar gerçek (actual) argümanlarken, fonksiyon tanımında yazılan argümanlar formel argümanlar olarak geçerler.
Örnek 4.5.
Aşağıdaki program kübün hacmini hesaplayan bir fonksiyon içermektedir.
/*Kübün hacmini hesaplamak */
#include <stdio.h>
main()
{
int taraf, s;
int cube(int taraf); /* fonksiyon deklarasyonu*/
printf(” Kübün tarafının uzunluğunu verin \n “);
scanf(“%d “, &taraf);
/* kübün hacmini hesapla ve ekranda göster */
cube(taraf); /* fonksiyona çağrı */
printf(“\n Kübün hacimi %d”, s);
}
/* Kübün hacmini hesaplayan fonksiyonun tanımlanması */
int cube(int x)
{
int z;
z= x*x*x;
return(z);
}
cube fonksiyonu main programı içinde
s = cube(taraf) .
ifadesiyle çağrılmaktadır.
Fonksiyon tanımında cube fonksiyonu x parametresindeki side değerinin kopyasını almaktadır. Cube’da hesaplanarak bulunan sonuç, z geçici parametresine atılmaktadır.
return(z) ifadesi z değerini programda çağrıldığı yere döndürmektedir.
Örnek 4.6.
Aşağıdaki program üç tam  sayıdan en büyüğünü belirlemektedir. Bütün mantık, ilk iki değerden büyük olanı belirlemek ve bunu üçüncü değerle karşılaştırmaktan ibarettir. Değerlerin en büyüğü daha sonra ana program tarafından ekrana yazılır.
/*Üç tam sayı değerden en büyüğünü belirle*/
#include <stdio.h>
main()
{
int a, b, c, d;
int maximum(int x, int y); /* fonksiyon deklarasyonu*/
/* tam sayı değerleri oku */
printf(” a,b ve c integer değerlerini verin \n “);
scanf(“%d %d %d “, &a, &b, &c);
/* en büyük değeri hesapla ve ekrana bas */
maximum(a, b); /* fonksiyona çağrı */
printf(“\n Maksimim %d”, maximum(c, d));
}
/* iki tam sayı değerden büyük olanı belirle */
maximum(int x, int y)
{
int z;
(x >= y) ? x : y;
return(z);
}
Programın ana kısmında maximum fonksiyonu değişik yerlerden iki kez çağrılmaktadır. İlk çağrıda, maximum fonksiyonu a ve b değerlerini alıp büyük olanı belirleyerek sonuçu d değişkenine atmaktadır. İkinci çağrıda fonksiyonun girdileri c ve d’dir.
Maximum fonksiyonuna erişen iki çağrının yerine tek bir çağrının şu şekilde yapılabileceğine dikkat ediniz.
printf(“\n Maksimim = %d”, maximum(c, maximum(a, b)));
Bu ifadede, maximum’a yapılan çağrılardan biri, diğer çağrının argümanıdır. Böylece, çağrılar biri diğerinin içinde olmak üzere gömülü yapıldığından, d ara değişkenine gerek kalmamıştır. Bu tip gömülü çağrılar olanaklıdır, fakat bunların mantığı yeni bir programcıya pek açık gelmeyebilir.
Örnek 4.7.
 Pozitif bir tam sayının faktöriyelini hesaplayan program aşağıda verilmiştir.
/* Tam sayı değerin faktöriyelini hesapla*/
#include <stdio.h>
long int factorial(int n)
{
int i;
long int prod = 1;
if (n > 1)
for (i = 2; i <= n; ++i)
prod *= i;
return(prod);
}
main()
{
int n;
printf(“\n n = “);
scanf(“%d”, &n);
/* faktöriyeli hesapla ve ekrana yaz*/
printf(“\n n! = %d”, factorial(n));
}
4.4 FONKSİYON PROTOTİPLERİ
Eğer bir fonksiyon tam sayı olmayan bir değer döndürüyorsa ve de fonksiyon çağrısı fonksiyon tanımlanmadan önce yapılıyorsa, programın içinde birfonksiyon deklarasyonu yapılması gerekir. Fonksiyon deklarasyonunun yapısı şu şekildedir:
döndürülen-tip isim(parameterlerin tipleri);
döndürülen-tip fonksiyon tarafından döndürülen değerin veri tipine, isimfonksiyonun ismine karşılık gelmektedir. Parameter types fonksiyondaki parametrelerin tiplerini (ve bazen isimlerini) içermektedir.
Bu şekilde yazılan fonksiyon deklarasyonları fonksiyon prototipi olarak adlandırılır. Fonksiyon prototipi fonksiyon tarafından döndürülen değerin tipini, parametrelerin sayısını ve tiplerini, fonksiyonun bunları hangi sırada beklediklerini uyarlayıcıya söyler. Fonksiyon prototipleri fonksiyona yapılan çağrılar ve kendilerine karşılık gelen fonksiyon tanımları arasındaki hataların kontrol edilmesini kolaylaştırdıklarından oldukça faydalıdırlar.
Örnek 4.8. Çeşitli fonksiyon deklarasyonları (fonksiyon prototipleri) aşağıda gösterilmektedir. Her bir deklarasyon iki farklı şekilde verilmiştir.
int square(int); veya int square(int side);
float roots(int, float); veya float roots(int i, float x);
void f1(char, long, double); veya void f1(char c, long j, double z);
void demo(void); veya void demo();
void tipi fonksiyonun herhangi bir değer döndürmediğine işarettir. Return tipi belirtilmemişse, uyarlayıcı tarafından int olarak kabul edilir. fonksiyon hiçbir parametre almıyorsa, fonksiyon isminden sonra (void) ya da boş parantezler yazılmalıdır.
Fonksiyon çağrılırken, gerçek argümanların isimleri deklarasyonda gösterilen isimlerle aynı olmak zorunda değildirler. Fakat, gerçek argümanların veri tipleri deklarasyondaki veri tipleriyle uyuşmalıdır.
Örnek 4.9. Bir C programının genel yapısı aşağıda gösterilmiştir.
main()
{
int a, b, c, d, i; /* değişken deklarasyonları*/
/* fonksiyon deklarasyonları (fonksiyon prototipleri)*/
int func1(int a, int b);
void func2(int c, int d);
. . .
func1(a, b);
. . .
func2(c,d);
. . .
}
int funct(int a, int b);
{
/*fonksiyon tanımının içeriği*/
}
void funct(int a, int b);
{
/*fonksiyon tanımının içeriği*/
}
4.5 FONKSİYONA ARGÜMAN GEÇİRME
Fonksiyon çağrılarında gerçek argümanlar fonksiyonun içine kopyalanır. Böylelikle, formel argümanın değeri fonksiyon içinde değiştirilebilirken, fonksiyonu çağıran rutin içindeki gerçek argümanın değeri değişmeden kalır. Bir argümanın değerini fonksiyona geçirmek için kullanılan bu yöntemdeğerle geçirme olarak bilinir.
Örnek 4.10. Aşağıda argümanının değerini değiştiren bir fonksiyon içeren bir C programı verilmiştir.
#include <stdio.h>
main()
{
int a = 2;
void modify(int a);
printf(“\n a = %d (“(fonksiyondan önce)”, a);
modify(a);
printf(“\n a = %d (“(fonksiyondan sonra)”, a);
}
void modify(int a)
{
a *= 3;
printf(“\n a = %d (“(fonksiyonun içinde)”, a);
}
programın çıktısı şöyle olacaktır:
a = 2 ( fonksiyondan önce)
a = 6 ( fonksiyonun içinde)
a = 2 ( fonksiyondan sonra)
4.6 YİNELEME (RECURSION)
Fonksiyon kullanımının etkin yöntemlerinden biri de yineleme (recursion)’dır. Yineleme, belli bir koşul sağlanana dek, fonksiyonun kendisini tekrar tekrar çağırması anlamındadır. Bu işlem, her bir sonucun bir önceki sonuca bağlı olarak değer aldığı tekrarlı hesaplamalar için kullanılır. Pek çok ötelemeli sonuç bu şekilde bulunabilir. Bir problemi yineleme yaparak çözebilmek için iki koşul sağlanmış olmalıdır: Birincisi, problem yinelemeli şekilde yazılabilmeli, ikincisi de problemin içinde yinelemeyi durduracak bir koşul bulunmalıdır.
Örnek 4.11. Faktöriyel Hesaplama.
#include <stdio.h>
main()
{
int n;
long int factorial(int n);
printf(“n=”);
scanf(“%d”,&n);
printf(“n!=%ld \n”,factorial(n));
}
long int factorial(int n)
{
if (n<=1)
return(1);
else
return(n*factorial(n-1));
}
factorial fonksiyonu, her çağrıda azalmak üzere (n-1) gerçek argümanla kendini tekrar tekrar çağırmaktadır. Gerçek argümanın değeri 1’e eşit olduğunda yineleme çağrıları sona erer.
4.7 DEPOLAMA SINIFLARI
Her değişken ismi ve veri tipiyle tanınır. Veri tipi, tam sayı, ondalık sayı veya karakter gibi verinin tipine karşılık gelir. Değişkenlerin diğer bir karakteristik özelliği ise depolama sınıfları (storage class)’dır. Depolama sınıfları bir değişkenin program içindeki sürekliliğini ve amacını belirler. Başka bir deyişle, değişkenin tanındığı program parçasıdır.
C programları çeşitli fonksiyonları kullanabilir. Bazı durumlarda programcı aynı değişkeni farklı fonksiyonlarda kullanabilir. Bu problem, bütün programın içinde tanınması gereken “global” değişkenlerin tanımlanmasını gerektirir. Bazen fonksiyon yalnızca kendi içinde tanınan yerel değişkenlerini kullanır. Bu durumda, yerel bir değişken tanımlandığı fonksiyonun dışına çıkıldığında değerini koruyamaz.
Fakat bazı durumlarda, fonksiyona daha sonra tekrar girilebilmesi ve hesaplamanın sürdürülebilmesi amacıyla, bazı yerel değişkenlerin değerlerini koruması istenebilir.
C’de dört farklı depolama-sınıfı vardır: automatic, external, static veregisterSırasıyla auto, extern, static ve register anahtar kelimeleriyle tanımlanırlar. Bazen bir değişkenle ilişkilendirilmiş bir depolama sınıfı, programın içinde değişken deklarasyonunun yapıldığı yerle anlaşılabilir. Fakat diğer durumlarda, belli bir depolama sınıfını belirten anahtar kelime değişken deklarasyonundan önce konulmalıdır.
4.7.1 Otomatik değişkenler
Automatic (otomatik) değişkenler her zaman bir fonksiyon içinde deklare edilirler ve o fonksiyonun içinde yerel olarak kalırlar. Yani işlevleri o fonksiyonla sınırlandırılmıştır. Farklı fonksiyonlarda tanımlanan otomatik değişkenler aynı isme sahip olsalar da birbirlerinden bağımsız olacaklardır. Otomatik değişkenler auto anahtar kelimesi kullanılarak şu şekilde deklare edilebilir:
auto tip değişken isimleri
Değişkenler, deklarasyonları içinde farklı bir depolama sınıfı belirtilmedikçe otomatik olarak deklare edilirler. Bu formel argüman deklarasyonları için de geçerlidir. Fonksiyonda kullanılan değişken yerel bir değişkense autokelimesi kullanılmayabilir.
Örnek 4.12. Aşağıdaki fonksiyonda i ve number değişkenleri otomatik tam sayı tipler, x ve y değişkenleri otomatik ondalık tipler olarak deklare edilmişlerdir.
int average (int n)
{
auto int i, number; /*veya int i,number; */
auto float x,y; /* veya float x,y; */
. . .
}
4.7.2 Harici Değişkenler
Otomatik değişkenler yalnızca tanımlandıkları fonksiyon içinde erişilebilirler. Otomatik değişkenlerin aksine, harici değişkenler tek bir fonksiyonla sınırlandırılmamışlardır. İşlevleri tanımlandıkları yerden programın geri kalanı boyunca sürer. Yani, genellikle iki veya daha fazla fonksiyon içinde, hatta tüm program içinde bile geçerli olabilirler. Harici değişkenler amaçları dahilinde her fonksiyon tarafından erişilebilirler. İşlenirken kendilerine atanan değeri sürekli korurlar. Bu yüzden, harici bir değişkene bir fonksiyon tarafından atanan değer, başka bir fonksiyon tarafından da (harici değişkene erişerek) kullanılabilir. Harici değişkenlerin kullanımı, fonksiyonlar arasındaki veri transferi için uygun bir metot sunmaktadır. Fonksiyonların iki veya daha fazla değer döndürmesi gerektiği durumlarda otomatik değişkenler yerine harici değişkenler kullanılması daha uygundur.
Örnek 4.12. Aşağıdaki fonksiyon harici değişkenlerin kullanımını göstermektedir.
#include <stdio.h>
#include <math.h>
double a,b,x,y; /*global (harici) değişkenler*/
main()
{
double xlocal, ylocal;
void func1(void);
scanf(“%lf”,&a);
scanf(“%lf”,&b);
func1();
68
xlocal=2*pow(x,2);
ylocal=2*pow(y,2);
printf(“\n xlocal=%8.6lf ylocal=%8.6lf”,xlocal,ylocal);
}
void func1(void)
{
x=10*exp(a);
y=20*log(b);
}
a,b,x ve y global (harici) değişkenlerdirler. İki fonksiyon tarafından da algılanırlar. xlocal ve ylocal değişkenleri otomatik değişkenlerdir. Yanlıca main fonksiyonu içinde işlevseldirler.
4.7.3 Statik Değişkenler
Tek bir fonksiyonun içinde tanımlanan statik değişkenler otomatik değişkenlerle aynı işleve sahiptirler, tanımlandıkları fonksiyon içinde yereldirler. Fakat otomatik değişkenlerden farklı olarak, programın çalıştığı süreçte değerlerini korurlar. Önceden çıkılmış bir fonksiyona tekrar girildiğinde, o fonksiyonda tanımlanmış statik değişkenler değerlerini korumuş olarak bulunacaklardır. Bu özellik, program çalıştığı sürece fonksiyonların bilgilerini tutmasını sağlar.
Değişken deklarasyonlarının static anahtar kelimesiyle başlaması dışında, fonksiyonun içinde otomatik değişkenlerle aynı mantıkta tanımlanırlar. Fonksiyon içinde diğer değişkenler gibi kullanılabilirler. Ancak, tanımlandıkları fonksiyonun dışından erişilemezler.
4.7.4 Register (Kayıtçı) Değişkenleri
Veri nesneleri hafıza kayıtçılarında saklandıklarında değişken deklarasyonu için register depolama sınıfı kullanılır. Fonksiyon içinde deklare edilen kayıtçı değişkeninin değeri o fonksiyonla sınırlandırılmıştır.
Bu yüzden, kayıtçı değişkenleri de otomatik değişkenler gibi deklare edildikleri fonksiyon içinde yereldirler. Fonksiyon içinde az sayıda kayıtçı değişkeni deklare edilebilir. Bu bilgisayara ve kullanılan C uyarlayıcısına bağlı bir durumdur. Uyarlayıcı uygun bir fiziksel kayıtçıda yer açamaz. Erişebileceği az sayıda kayıtçı (hafıza yeri) vardır; çoğunluğu sistem için gereklidir ve başka amaçlar için kullanılamaz.
Aşağıdaki örnekte, k, l, m tam sayı değişkenleri register depolama sınıfıyla birlikte deklare edilmişlerdir. Bu değişkenlerin değerleri kayıtçılarda saklanacaktır.
register int k, l, m;
register değişkeninin deklarasyonu çalışma zamanının azaltılmasını ve hızız arttırılmasını sağlar. bu durumda değişken değerleri bilgisayarın hafızası yerine kayıtçılarda tutulacaktır. Programcı en çok kullanılan değişkenlerden bazılarını seçerek bunları register depolama sınıfına ait olarak deklare edebilir.
{
register int k;
for(k=0; k<N; ++k)
{
. . .
}
}

Senin bu konuya yorumun ne olacak?

Gerekli *

HAKKIMIZDA

facebook twitter youtube flickr ENOTLAR TV LOGOSU_Artboard 13 - ENOTLAR TV LOGO

Arşivler

KAREKOD-umuz

Lower-Third-(Enotlar)