Dizileri ve çok boyutlu dizileri gördük. Katar dediğimiz şey de aslında bir dizidir. Değişken tipi char yani karakter olan diziler, 'katar' ya da İngilizce adıyla 'string' olarak isimlendirilirler.
Katarları, şimdiye kadar gördüğümüz dizilerden ayıran, onları farklı kılan özellikleri yoktur. Örneğin bir tam sayı ( int ) dizisinde, tam sayıları saklarken; bir karakter dizisinde -yani katarda- karakterleri ( char ) saklarız. Bunun dışında bir fark bulunmaz. Ancak sık kullanılmalarına paralel olarak, katarlara ayrı bir önem vermek gerekir. Yaptığınız işlemler bilimsel ve hesaplama ağırlıklı değilse, hangi dili kullanırsanız kullanın, en çok içli dışlı olacağınız dizi tipi, karakter dizileridir. İsimler, adresler, kullanıcı adları, telefonlar vs... sözle ifade edilebilecek her şey için karakter dizilerini kullanırız. Katarlar işte bu yüzden önemlidir!
Karakter dizilerine İngilizce'de String dendiğini belirtmiştik. String; ip, bağ, kordon gibi anlamlar taşıyor. İlk olarak katar adını kim münasip gördü bilmiyorum. Muhtemelen bellek hücrelerine peşi sıra dizilen karakterlerin, vagonlara benzetilmesiyle, String değişken tipi Türkçe'ye katar olarak çevrildi. ( Arapça kökenli Türkçe bir kelime olan katar, 'tren' anlamına gelmektedir. ) Daha uygun bir isim verilebilirdi ya da sadece 'karakter dizisi' de diyebilirdik. Fakat madem genel kabul görmüş bir terim var; yazımız içersinde biz de buna uyacağız. String, katar ya da karakter dizisi hiç farketmez; hepsi aynı kapıya çıkıyor: Değişken tipi karakter olan dizi...
Katarlarla, daha önce gördüğümüz diziler arasında bir farkın olmadığını söylemtiştik. Bu sözümüz, teorik olarak doğru olsa da, pratikte ufak tefek farkları kapsam dışı bırakıyor. Hatırlayacaksınız, dizilerde elemanlara değer atama ya da onlardan değer okuma adım adım yapılan bir işlemdi. Genellikle bir döngü içersinde, her dizi elemanı için scanf( ) veya printf( ) fonksiyonunu çağırmamız gerekiyordu. Katarlar için böyle bir mecburiyet bulunmuyor. Tek bir kelimeyi, tek bir scanf( ) fonksiyonuyla okutabilir ve elemanlara otomatik değer atayabilirsiniz. Yani "Merhaba" şeklinde bir girdi-input gelirse, 3.dizi elemanı 'r' olurken; 6.dizi elemanı 'b' olur. Önceki dizilerde gördüğümüzün aksine, eleman atamaları kendiliğinden gerçekleşir. Aşağıdaki örneği inceleyelim:
#include<stdio.h>
int main( void )
{
char isim[30];
printf( "İsim giriniz> ");
scanf( "%s", isim );
printf( "Girdiğiniz isim: %s\n", isim );
return 0;
}
Örneğimizde 30 karakterlik bir karakter dizisi tanımlayarak işe başladık. Bunun anlamı girdileri saklayacağımız 'isim' katarının 30 karakter boyutunda olacağıdır. Ancak bu katara en fazla 29 karakterlik bir kelime atanabilir. Çünkü katarlarda, kelime bitiminden sonra en az bir hücre boş bırakılmalıdır. Bu hücre 'Boş Karakter' ( NULL Character ) tutmak içindir. Boş karakter "\0" şeklinde ifade edilir. C programlama dilinde, kelimelerin bittiğini boş karakterlerle anlarız. Herhangi bir katarı boş karakterle sonlandırmaya, 'null-terminated' denmektedir.
Bu arada katarlara değer atarken ya da katarlardan değer okurken, sadece katar adını yazmamızın yettiğini farketmişsinizdir. Yani scanf( ) fonksiyonu içersine & işareti koymamız gerekmiyor. Çünkü scanf( ), katarın ilk adresinden başlayarak aşağıya doğru harfleri tek tek ataması gerektiğini biliyor. ( Aslında biliyor demek yerine, fonksiyonun o şekilde yazıldığını söylememiz daha doğru olur. )
Katarların, esasında bir dizi olduğundan bahsetmiştik. Şimdi bunun uygulamasını yapalım. Katara değer atamak için yine aynı kodu kullanırken; katardan değer okumak için kodumuzu biraz değiştirelim:
#include<stdio.h>
int main( void )
{
char isim[30];
int i;
printf( "İsim giriniz> ");
scanf( "%s", isim );
printf( "Girdiğiniz isim: ");
for( i = 0; isim[i]!='\0'; i++ )
printf( "%c", isim[i] );
printf("\n");
return 0;
}
Daha önce tek bir printf( ) fonksiyonuyla bütün katarı yazdırabilirken, bu sefer katar elemanlarını tek tek, karakter karakter yazdırmayı tercih ettik. Çıkan sonuç aynı olacaktır fakat gidiş yolu biraz farklılaştı. Özellikle for döngüsü içersinde bulunan " isim[i]!='\0' " koşuluna dikkat etmek gerekiyor. İsteseydik, " i < 30 " yazar ve katarın bütün hücrelerini birer birer yazdırabilirdik. Fakat bu mantıklı değil! 30 karakterlik bir dizi olsa bile, kullanıcı 10 harften oluşan bir isim girebilir. Dolayısıyla kalan 20 karakteri yazdırmaya gerek yoktur. Kelimenin nerede sonlandığını belirlemek için "isim[i]!='\0'" koşulunu kullanıyoruz. Bunun anlamı; isim katarının elemanları, "\0" yani boş karakterere ( NULL Character ) eşit olmadığı sürece yazdırmaya devam edilmesidir. Ne zaman ki kelime biter, sıradaki elemanın değeri "\0" olur; işte o vakit döngüyü sonlandırmamız gerektiğini biliriz.
Yukardaki örneğimize birden çok kelime girdiyseniz, sadece ilk kelimenin alındığını farketmişsinizidir. Yani "Bugün hava çok güzel." şeklinde bir cümle girdiğiniz zaman, katara sadece "Bugün" kelimesi atanır. Eğer aynı anda birden fazla kelime almak istiyorsanız, ayrı ayrı belirtilmesi gerekir.
#include<stdio.h>
int main( void )
{
char isim[25], soyad[30];
printf( "Ad ve soyad giriniz> ");
scanf( "%s%s", isim, soyad );
printf( "Sayın %s %s, hoş geldiniz!\n", isim, soyad );
return 0;
}
Gördüğünüz gibi aynı anda iki farklı kelime alıp, ikisini birden yazdırdık. Fakat scanf( ) fonksiyonu "Bugün hava çok güzel." cümlesini tek bir katara alıp, atamak için hâlen yetersizdir. Çünkü boşluk gördüğü noktada, veriyi almayı keser ve sadece "Bugün" kelimesinin atamasını yapar. Boşluk içeren bu tarz cümleler için puts( ) ve gets( ) fonksiyonları kullanılmaktadır. Aşağıdaki örnek program, 40 harfi geçmeyecek her cümleyi kabul edecektir:
#include<stdio.h>
int main( void )
{
char cumle[40];
printf( "Cümle giriniz> ");
gets( cumle );
printf( "Girdiğiniz cümle:\n" );
puts( cumle );
return 0;
}
gets( ) isminden anlayacağınız ( get string ) gibi katara değer atamak için kullanılır. puts( ) ( put string ) ise, bir katarın içeriğini ekrana yazdırmaya yarar. gets( ) atayacağı değerin ayrımını yapabilmek için '\n' aramaktadır. Yani klavyeden Enter'a basılana kadar girilen her şeyi, tek bir katara atayacaktır. puts( ) fonksiyonuysa, printf( ) ile benzer çalışır. Boş karakter ( NULL Character ) yani '\0' ulaşana kadar katarı yazdırır; printf( ) fonksiyonundan farklı olarak sonuna '\n' koyarak bir alt satıra geçer. Oldukça açık ve basit kullanımlara sahip olduklarından, kendiniz de başka örnekler deneyebilirsiniz.
Bir katar tanımı yaptığınız anda, katarın bütün elemanları otomatik olarak '\0' ile doldurulur. Yani katarın bütün elemanlarına boş karakter (NULL Character) atanır. Dilerseniz, katarı yaratırken içine farklı değerler atayabilirsiniz. Katarlarda ilk değer ataması iki şekilde yapılır.
Birinci yöntemle değer ataması yapacaksanız, istediğiniz kelimeyi bir bütün olarak yazarsınız:
#include<stdio.h>
int main( void )
{
// Her iki katarada ilk deger
// atamasi yapiliyor. Ancak
// isim katarinda, boyut
// belirtilmezken, soyad katarinda
// boyutu ayrica belirtiyoruz.
char isim[] = "CAGATAY";
char soyad[5] = "CEBI";
printf( "%s %s\n", isim, soyad );
return 0;
}
İkinci yöntemdeyse, kelime bütün olarak yazılmaz. Bunun yerine harf harf yazılır ve sonlandırmak için en sonuna boş karakter ( NULL ) eklenir:
#include<stdio.h>
int main( void )
{
char isim[] = { 'C', 'A', 'G', 'A',
'T', 'A', 'Y', '\0' };
char soyad[5] = { 'C', 'E', 'B', 'I', '\0' };
printf( "%s %s\n", isim, soyad );
return 0;
}
Ben ilk değer ataması yapacağım durumlarda, ilk yolu tercih ediyorum. İkinci yöntem, daha uzun ve zahmeti...
Daha önce float tipindeki bir sayının, noktadan sonra iki basamağını göstermek türünden şeyler yapmıştık. Örneğin printf( ) fonksiyonu içersinde, sayıyı %.2f şeklinde ifade ederseniz, sayının virgülden sonra sadece iki basamağı gösterilir. Yada %5d yazarak tam sayıları gösterdiğiniz bir durumda, sayı tek bir rakamdan dahi oluşsa, onun için 5 rakamlık gösterim yeri ayrılır. Aynı şekilde biçimlendirilmiş ( formatlı ) gösterim, katarlarda da yapılmaktadır.
Katarları biçimlendirilmiş şekilde göstermeyi, örnek üzerinden anlatmak daha uygun olacaktır:
#include<stdio.h>
int main( void )
{
char cumle[20] = "Denemeler";
// Cumleyi aynen yazar:
printf( "%s\n", cumle );
// 20 karakterlik alan ayirir
// ve en saga dayali sekilde yazar.
printf( "%20s\n", cumle );
// 20 karakterlik alan ayirir
// ve en saga dayali sekilde,
// katarin ilk bes kelimesini
// yazar
printf( "%20.5s\n", cumle );
// 5 karakterlik alan ayirir
// ve en saga dayali sekilde yazar.
// Eger girilen kelime 5 karakterden
// buyukse, kelimenin hepsi yazilir.
printf( "%5s\n", cumle );
// 20 karakterlik alan ayirir
// ve sola dayali sekilde yazar.
// Sola dayali yazilmasi icin
// yuzde isaretinden sonra, -
// (eksi) isareti konulur.
printf( "%-20s\n", cumle );
return 0;
}
Örneğimizde bulunan formatlama biçimlerini gözden geçirirsek:
Katarlarla daha kolay çalışabilmek için, bazı hazır kütüphane fonksiyonlarından bahsedeceğiz. Bu fonkisyonlar, string kütüphanesinde bulunuyor. Bu yüzden, programınızın başına, #include<string.h> eklemeniz gerekiyor.
Dizi boyutuyla, katar uzunluğunun farklı şeyler olduğundan bahsetmiştik. Dizi boyutu, 40 karakter olacak şekilde ayarlanmışken, dizi içinde sadece 7 karakterlik "Merhaba" kelimesi tutulabilir. Bu durumda, dizi boyutu 40 olmasına rağmen, katar boyutu yalnızca 7'dir. Katarların boyutunu saptamak için, boş karakter ( NULL Character ) işaretinin yani "\0" simgesinin konumuna bakılır. Her seferinde arama yapmanıza gerek kalmasın diye strlen( ) fonksiyonu geliştirilmiştir. strlen( ) kendisine argüman olarak gönderilen bir katarın boyutunu geri döndürür. Aşağıdaki gibi kullanılmaktadır:
#include<stdio.h>
#include<string.h>
int main( void )
{
printf( "Katar Uzunluğu: %d\n", strlen("Merhaba") );
return 0;
}
Bir katarı, bir başka katara kopyalamak için strcpy( ) fonksiyonunu kullanırız. Katarlar aynı boyutta olmak zorunda değildir. Ancak kopya olacak katar, kendisine gelecek kelimeyi alacak boyuta sahip olmalıdır. Fonksiyon prototipi aşağıdaki gibidir, geriye pointer döner.
char *strcpy( char[ ], char[ ] );
strcpy( ) fonksiyonunu bir örnekle görelim:
#include<stdio.h>
#include<string.h>
int main( void )
{
char kaynak[40]="Merhaba Dünya";
char kopya[30] = "";
strcpy( kopya, kaynak );
printf( "%s\n", kopya );
return 0;
}
strncpy( ) fonksiyonu, yine kopyalamak içindir. Fakat emsalinden farklı olarak, kaç karakterin kopyalanacağı belirtilir. Protopi aşağıda verilmiştir:
char *strncpy( char[ ], char[ ], int );
Yukardaki örneği strncpy( ) fonksiyonuyla tekrar edelim:
#include<stdio.h>
#include<string.h>
int main( void )
{
char kaynak[40]="Merhaba Dünya";
char kopya[30] = "";
strncpy( kopya, kaynak, 9 );
printf( "%s\n", kopya );
return 0;
}
Yukardaki programı çalıştırırsanız, kopya isimli katara sadece 9 karakterin aktarıldığını ve ekrana yazdırılan yazının "Merhaba D" olduğunu görebilirsiniz.
strcmp( ) fonksiyonu, kendisine verilen iki katarı birbiriyle karşılaştırır. Katarlar birbirine eşitse, geriye 0 döner. Eğer ilk katar alfabetik olarak ikinciden büyükse, geriye pozitif değer döndürür. Şayet alfabetik sırada ikinci katar birinciden büyükse, geriye negatif değer dönmektedir. Bu dediklerimizi, daha iyi anlaşılması için bir tabloya dönüştürelim:
| Dönen Değer | Açıklama |
| < 0 | Katar1, Katar2'den küçüktür. |
| 0 | Katar1 ve Katar2 birbirine eşittir. |
| > 0 | Katar1, Katar2'den büyüktür. |
strncmp( ) için de aynı kurallar geçerlidir. Tek fark, karşılatırılacak karakter sayısını girmemizdir. strcmp( ) fonksiyonunda iki katar, null karakter işareti çıkana kadar karşılaştırılır. Fakat strncmp( ) fonksiyonunda, başlangıçtan itibaren kaç karakterin karşılaştırılacağına siz karar verirsiniz.
Her iki fonksiyonu da kapsayan aşağıdaki örneği inceleyelim:
#include<stdio.h>
#include<string.h>
int main( void )
{
int sonuc;
char ilk_katar[40]="Maymun";
char ikinci_katar[40]="Maytap";
sonuc = strcmp( ilk_katar, ikinci_katar );
printf( "%d\n", sonuc );
sonuc = strncmp( ilk_katar, ikinci_katar, 3 );
printf( "%d\n", sonuc );
return 0;
}
İlk önce çağrılan strcmp( ), null karakterini görene kadar bütün karakterleri karşılaştıracak ve geriye negatif bir değer döndürecektir. Çünkü "Maymum" kelimesi alfabede "Maytap" kelimesinden önce gelir; dolayısıyla küçüktür. Fakat ikinci olarak çağırdığımız strncmp( ) geriye 0 değeri verecektir. Her iki katarın ilk üç harfi aynıdır ve fonksiyonda sadece ilk üç harfin karşılaştırılmasını istediğimizi belirttik. Dolayısıyla karşılaştırmanın sonucunda 0 döndürülmesi normaldir.
strcat( ) ve strncat( ) fonksiyonları, bir katarı bir başka katarla birleştirmeye yarar. Fonksiyon adlarında bulunan cat, İngilizce bir kelime olan ve birleştirme anlamına gelen 'concatenate'den gelmiştir. strcat( ) kendisine verilen katarları tamamen birleştirirken, strncat( ) belirli bir eleman sayısına kadar birleştirir. strcat ile ilgili basit bir örnek yapalım.
#include<stdio.h>
#include<string.h>
int main( void )
{
char ad[30], soyad[20];
char isim_soyad[50];
printf( "Ad ve soyadınızı giriniz> " );
scanf( "%s%s", ad, soyad );
// isim_soyad <-- ad
strcat( isim_soyad, ad );
// isim_soyad <-- ad + " "
strcat( isim_soyad, " " );
// isim_soyad <-- ad + " " + soyad
strcat( isim_soyad, soyad );
printf( "Tam İsim: %s\n", isim_soyad );
return 0;
}
Dilerseniz, strncat( ) fonksiyonunu da siz deneyebilirsiniz.
Bir katar içinde, bir başka katarı aradığınız durumlarda, strstr( ) fonksiyonu yardımınıza yetişir. strstr( ) fonksiyonu, bir katar içinde aradığınız bir katarı bulduğu takdirde bunun bellekteki adresini geriye döndürür. Yani dönen değer çeşidi bir pointer'dır. Eğer herhangi bir eşleşme olmazsa geriye bir sonuç dönmez ve pointer null olarak kalır. Elbette insanlar için hafıza adreslerinin veya pointer değerlerinin pek bir anlamı olmuyor. Bir katar içinde arama yapıyorsanız, aradığınız yapının katarın neresinde olduğunu tespit etmek için aşağıdaki kodu kullanabilirsiniz:
/* strstr( ) fonksiyon ornegi */
#include<stdio.h>
#include<string.h>
int main( void )
{
char adres[] = "Esentepe Caddesi Mecidiyekoy Istanbul";
char *ptr;
// 'adres' katari icinde, 'koy' kelimesini
// ariyoruz. Bu amacla strstr( ) fonksiyonunu
// kullaniyoruz. Fonksiyon buyuk-kucuk harf
// duyarlidir. Eger birden fazla eslesme varsa,
// ilk adres degeri doner. Hic eslesme olmazsa,
// pointer degeri NULL olur.
ptr = strstr( adres, "koy" );
if( ptr != NULL )
printf( "Başlangıç notkası: %d\n", ptr - adres );
else
printf( "Eşleşme bulunamadı.\n" );
return 0;
}
strchr( ) ve strrchr( ) fonksiyonları, tıpkı strstr( ) gibi arama için kullanılır. Ancak strstr( ) fonksiyonu katar içinde bir başka katarı arayabilirken, strchr( ) ve strrchr( ) fonksiyonları katar içinde tek bir karakter aramak için kullanılır. strchr( ), karakterin katar içindeki ilk konumunu gösterirken; strrchr( ) fonksiyonu, ilgili karakterin son kez geçtiği adresi verir.
#include<stdio.h>
#include<string.h>
int main( void )
{
char adres[] = "Esentepe Caddesi Mecidiyekoy Istanbul";
char *ilk_nokta, *son_nokta;
ilk_nokta = strchr( adres, 'e' );
son_nokta = strrchr( adres, 'e' );
if( ilk_nokta != NULL ) {
printf( "Ilk gorundugu konum: %d\n", ilk_nokta - adres );
printf( "Son gorundugu konum: %d\n", son_nokta - adres );
}
else
printf( "Eşleşme bulunamadı.\n" );
return 0;
}
Verilen katarı, sayıya çevirmek gerekebilir. Eğer elinizdeki metni, bir tam sayıya ( int ) çevirecekseniz, atoi( ) fonksiyonunu kullanmanız gerekir. Şayet dönüşüm sonunda elde etmek istediğiniz değişken tipi, virgüllü sayı ise ( float ), atof( ) fonksiyonu kullanılır. Her iki fonksiyon stdlib.h kütüphanesi içindedir. Bu fonksiyonları kullanırken, #include<stdlib.h> komutunu program başlangıcına yazmalısınız.
#include<stdio.h>
#include<stdlib.h>
int main( void )
{
char kok_iki[] = "1.414213";
char pi[] = "3.14";
char tam_bir_sayi[] = "156";
char hayatin_anlami[] = "42 is the answer";
printf( "%d\n", atoi( tam_bir_sayi ) );
printf( "%d\n", atoi( hayatin_anlami ) );
printf( "%f\n", atof( kok_iki ) );
printf( "%f\n", atof( pi ) );
return 0;
}
Her iki fonksiyonda rakam harici bir şey görene kadar çalışır. Eğer nümerik ifadeler dışında bir karakter çıkarsa, fonksiyon o noktada çalışmayı keser.
İşlediğimiz bütün derslerde main( ) fonksiyonu vardı. main( ) fonksiyonuyla ilgili incelememizi de, fonksiyonlarla ilgili dokuzuncu dersimizde yapmıştık. Ancak main( ) fonksiyonuna hiçbir zaman parametre aktarmadık; aksine parametre almayacağını garantilemek için sürekli olarak main( void ) şeklinde yazmıştık. Artık main( ) fonksiyonuna nasıl parametre verileceğini göreceğiz. Aşağıdaki kod, parametresi olan bir main( ) fonksiyonunu göstermektedir:
#include<stdio.h>
int main( int argc, int *arg[] )
{
int i;
for( i = 0; i < argc; i++ ) {
printf( "%d. argüman: %s\n", i, arg[i] );
}
return 0;
}
Bu kodu yazıp, "yeni_komut.c" adıyla kaydedin. Ardından eğer Linux ve gcc kullanıyrsanız, aşağıdaki komutu kullanarak kodun derlemesini yapın.
$ gcc yeni_komut.c -o yeni_komut
Yukardaki komut, "yeni_komut" adında çalıştırılabilir bir program dosyası oluşturacak. Windows ve Dev-C++ kullanıyorsanız böyle bir komuta gerek yok. Kodu kaydedip, derlediğiniz zaman, çalışma klasörünüzde "yeni_komut.exe" adında bir dosya zaten oluşacaktır.
İkinci aşamada, programa parametre göndererek çalıştıracağız. Bunun için gerek Linux gerekse Windows kullanıcılarının yapacağı şey birbirine çok benziyor. Linux kullanıcıları aşağıdaki gibi bir komut girecekler:
$ ./yeni_komut Merhaba Dünya Hello World
Windows kullanıcılarınınsa, DOS komut istemini açıp, programın kayıtlı olduğu klasöre gelmeleri gerekiyor. Diyelim ki, "yeni_komut.exe" "C:\Belgelerim" içinde kayıtlı... O hâlde aşağıdaki komutu giriyoruz:
C:\Belgelerim> yeni_komut Merhaba Dünya Hello World
Her iki işletim sisteminde elde edeceğiniz sonuç aynı olacaktır:
0. argüman: ./yeni_komut 1. argüman: Merhaba 2. argüman: Dünya 3. argüman: Hello 4. argüman: World
Dışardan gelen argümanla çalışan bir başka main( ) fonksiyonu oluşturalım. Toplama ve çıkartma işlemini alacağı argümanlara göre yapan bir programı aşağıda bulabilirsiniz:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main( int argc, char *arg[] )
{
// Eger eksik arguman soz konusuysa,
// program calismamalidir.
if( argc < 4 ) {
printf( "Hata: Eksik argüman!\n");
return;
}
float sayi_1, sayi_2;
char islem_tipi[2];
sayi_1 = atof( arg[1] );
strcpy( islem_tipi, arg[2] );
sayi_2 = atof( arg[3] );
// Verilen sembolun neye esit oldugu asagidaki
// if-else if merdiveniyle saptaniyor.
if( !strcmp( islem_tipi, "+" ) )
printf( "Toplam: %.2f\n", sayi_1 + sayi_2 );
else if( !strcmp( islem_tipi, "-" ) )
printf( "Fark: %.2f\n", sayi_1 - sayi_2 );
else
printf( "Hatalı işlem!\n" );
return 0;
}
Programı çalıştırmak için şu tarz bir komut verdiğimizi düşünelim:
$ ./hesapla 4 + 12
Programı bu şekilde çalıştırdığınız zaman argümanların, parametrelere atanması aşağıdaki gibi olur:
| arg[ 0 ] | arg[ 1 ] | arg[ 2 ] | arg[ 3 ] |
| ./hesapla | 4 | + | 12 |
Bütün fonksiyonlara, program içersinden argüman aktarımı yaparken; main( ) fonksiyonuna program dışından değer gönderebiliyoruz. Unix komutlarının hemen hemen hepsi bu şekildedir. DOS komutlarının birçoğu da böyle yazılmıştır. main( ) fonksiyonun parametre alıp almaması gerektiğine, ihtiyacınıza göre sizin karar vermeniz gerekir.
Soru 1: Kendisine verilen bir katarın boyutunu bulan fonksiyonu yazınız. ( Çözüm için strlen( ) fonksiyonunu kullanmayınız. )
Soru 2: Tersinden de aynı şekilde okunabilen kelime, cümle veya mısraya 'palindrome' denmektedir. Adı palindrome( ) olan ve verilen katarın tersinin kendisine eşit olduğu durumda geriye 1; aksi hâlde 0 döndüren fonksiyonu yazınız.
Soru 3: Aşağıdaki gibi çalışıp, çıktı üretebilecek "ters_cevir" programını oluşturunuz.
$ ./ters_cevir Merhaba Dunya Nasilsin? abahreM aynuD ?nislisaN
| << Geri | İleri >> |