C#nedir?com
 
YAZAR HAKKINDA
Çiğdem Çavdaroğlu
Çiğdem Çavdaroğlu
http://www.csharpnedir.com/
İletişme geçmek için tıklayın.
28 Makalesi yayınlanmakta.
Yazar hakkında detaylı bilgi için tıklayın.
Yayınlanan diğer makaleleri için tıklayın.
İlgili etiketler: degeri degiskeni dosyaya fonksiyon fonksiyonu isimli karakter katarinin kaydin kayitlari kontrol parametre prototip return sonuna C / Sys Prog. Çiğdem Çavdaroğlu
 
YAZI HAKKINDA
Türü : Makale
Serbest Köşede C#nedir?com üyelerinin hazırladıkları yazılar yayınlanır. Bu yazılar editör incelemesine girmeden yayınlanır.
Seviyesi : Orta
Kategori : C / Sys Prog.
Yayınlanma Tarihi : 23.5.2005
Okunma Sayısı : 15229
Yorum Sayısı : 0     yorum yaz
Site İçi AramaSİTE İÇİ ARAMA
Üye Girişini AçÜye GİRİŞİ
Üye girişi için tıklayın.
Kullanıcı Adı
Şifre
 
Beni her zaman hatırla
Bir hafta boyunca kullanıcı bilgilerinizi kullanıcı çıkışı yapana kadar hatırlar. (Paylaşılan bilgisayarlarda önerilmez.)
 
Şifremi / Kullanıcı Adımı unuttum.
 
.net TV RSS Serbest KÖŞE (?)
Serbest Köşede C#nedir?com üyelerinin hazırladıkları yazılar yayınlanır. Bu yazılar editör incelemesine girmeden yayınlanır.
emre TAŞ
XML - Deniz Kılınç
emre TAŞ
yazının devamı >
emre TAŞ
Decompiling and Reverse Engineering .Net Radyo
emre TAŞ
yazının devamı >
emre TAŞ
Masaüstü mü ? İnternet Mi? .Net Radyo
emre TAŞ
yazının devamı >
emre TAŞ
.Net Kavramları - .Net Radyo
emre TAŞ
yazının devamı >
emre TAŞ
Yeni Başlayanlar için - .Net Radyo
emre TAŞ
yazının devamı >
Makale Gönder Bende Yazmak İstiyorum
.net TV RSSBlogroll
Turhal Temizer 'in Blogu
Conda install environment.yml Package 31.3.2020
Turhal Temizer 'in Blogu
Mac OS/X Removing CUDA 31.3.2020
Burak Selim Şenyurt
Sekiz Saatlik Sonsuz Döngü 31.3.2020
Burak Selim Şenyurt
Switch Case Kullanmadan Kod Yazılabilir mi? 31.3.2020
  Diğer Herşey
Sponsorlar
BT Akademi
Medya Portakal
Video Hosting Sponsoru
Csharpnedir.com bir Ineta üyesidir
Uzman Abi
Her Yönüyle C# - Sefer Algan
Karakter Katarları Üzerinde İşlemler ve Bağlı Liste Uygulaması - 3
 
Kapat
Sayfayı Yazdır Sık Kullanılanlara Ekle Arkadaşıma Gönder MySpace Del.Ico.Us Digg Facebook Google Mixx Reddit StumbleUpon
Yazı dizimizin üçüncü ve son makalesine başlamadan önce, şimdiye kadar yaptıklarımıza kısaca bir göz atalım. İlk olarak C dilinde karakter katarlarının kullanımına ilişkin birtakım bilgiler verdik. "char" türünden göstericilere ve dizilere göz attık. Daha sonra uygulamamızın çatısını oluşturan listemizi oluşturduk. Listemiz "struct record" türünden elemanlara sahipti. "record" ve "recordList" yapılarımız için "CreateRecord" ve "CreateList" başlangıç fonksiyonlarını oluşturduk. Listemizdeki her eleman bir isme ve o isme ilişkin numara bilgisine sahipti. Listeye baştan ve sondan kayıt ekleyen "AddRecordStart, AddRecordEnd" fonksiyonlarımızı yazdık. İlk makalemizin sonunda listedeki tüm kayıtları ekrana yazdıran "DisplayList" fonksiyonunu yazdık. İkinci makalemizde listenin herhangi bir sıra numarasına kayıt ekleyen "InsertRecordToList" fonksiyonunu, belli bir sıra numarasındaki kaydı silen "DeleteRecordFromList" fonksiyonunu, listede verilen bir isme ya da numaraya ilişkin kayıtları arayıp bulan ve silen "DeleteAllRecordsFromListByNumber" ve "DeleteRecordFromListByName" fonksiyonlarını ve listede isme göre kayıt arayan "FindRecordInList" fonksiyonunu yazdık. İkinci makalenin sonunda ise listede belli bir kaydı güncelleyen fonksiyonları yazdık. Üçüncü ve bu konunun son makalesinde ise listedeki isimler üzerinde arama işlemleri yapacağız. Bu arama işlemlerinde kullanmak üzere karakter katarları üzerinde işlemler yapan bazı fonksiyonlar yazacağız. Son olarak da listemizdeki kayıtların veri elemanlarının değerlerini, bir dosyaya kaydedeceğiz. Önce karakter katarları üzerinde işlem yapan fonksiyonlarımızdan başlayalım. Daha sonra bu fonksiyonları listemize ait fonksiyonlarda kullanalım.

Öncelikle bir karakter katarında belli bir karakterin olup olmadığını bulan, eğer var ise TRUE, yok ise FALSE döndüren fonksiyonumuzu yazalım :

BOOL IsContainCharacter(const char *str,char ch); /* prototip bildirimi*/

BOOL IsContainCharacter(const char *str,char ch)
{
    int i = 0;
    while (str[i] != ’\0’)
       if (str[i] == ch)
          return 1;
    return 0;
}

"IsContainCharacter" fonksiyonumuz (char *) türünden olan "str" isimli parametresi ile fonksiyona geçilen karakter katarı içerisinde "ch" parametresi ile geçilen karakteri arar. Eğer bulursa TRUE değerine, bulamazsa FALSE değerine geri döner. Fonksiyondaki while döngüsü, str katarının sıradaki karakteri null karakter (’\0’) olmayana dek döner. Karakter katarları ile ilgili bilgi verirken, derleyicilerin karakter katarları sonuna null karakterini eklediğini belirtmiştik. Buradaki while döngüsünde de, karakter katarı içerisinde belli bir karakteri arama işlemi, katarın sonuna gelininceye dek sürdürülmektedir. Döngü içerisindeki if ifadesinde katarın sıradaki karakterinin ch değişkenindeki değere eşit olup olmadığı sınanıyor. Eğer eşit ise aradığımız karakter bulunmuş demektir.

Şimdi bir karakter katarının belli bir karakter katarı ile başlayıp başlamadığını bulan fonksiyonumuzu yazalım :

BOOL StartWith(const char *str, const char *subStr); /* Prototip bildirimi */

BOOL StartWith(const char *str, const char *subStr)
{
    int index = 0;

    while (str[index] != ’\0’ && subStr[index] != ’\0’) {
        if (str[index] != subStr[index++])
            return FALSE;
    }

    if (subStr[index] != ’\0’)
       return FALSE;

    return TRUE;
}

"StartWith" isimli fonksiyonumuz, parametre olarak aldığı str katarının, subStr katarı ile başlayıp başlamadığını bulur. Fonksiyonun başında tamsayı türünden "index" isimli bir değişken tanımlıyoruz. Bu değişkeni karakter katarlarının karakterleri üzerinde sırasıyla dolaşmak için kullanacağız. Bu nedenle başlangıç değeri olarak sıfır atadık. While döngüsünde koşul ifadesi olarak, her iki katarın da sonuna gelinip gelinmediği kontrol ediliyor. İki katardan herhangi birisinin sonuna gelinmişse arama işlemi sonlandırılmalıdır. Döngü içerisinde, "str" katarının sıradaki karakterinin, "subStr" katarının sıradaki karakterine eşit olup olmadığı kontrol ediliyor. Eğer eşit değil ise "return FALSE;" ifadesi ile döngüden çıkılır ve fonksiyon sonlandırılır. Eğer döngü koşul ifadesini başarıyla geçerek sonlanmışsa, son noktada "subStr" katarının sonuna gelinip gelinmediği kontrol edilmelidir. Çünkü ilk katarın uzunluğu ikinci katarın uzunluğundan daha az olabilir. Eğer karakterler birbirlerine eşit ise, ve ikinci katar birinciden daha uzun ise, bu durumda da fonksiyon FALSE değerini döndürmelidir. Eğer bu koşul da geçilirse fonksiyon TRUE değerine geri döner.

Şimdi fonksiyona gönderilen karakter katarının, diğer karakter katarının içerisinde herhangi bir sıra numarasından itibaren var olup olmadığını bulan "IsContainString" isimli fonksiyonumuzu yazalım. Bu fonksiyona parametre değişkeni olarak sırasıyla "CSharpNedir?" ve "Nedir" karakter katarları gönderilirse fonksiyon TRUE değerine dönmelidir. Bu durumda yukarıda yazdığımız "StartWith" fonksiyonumuz işimizi görmeyecektir. Bu fonksiyonda yapacağımız aramayı şekille ifade edelim :

 

Bu durumda, devam edeceğimiz her adımda, içinde arama yapılan karakter katarının sıradaki sıra numarasından sonuna kadar olan kısmını kopyalayarak başka bir katar elde etme yolunu seçebiliriz. İlk önce bu kopyalama işlemini yapacak olan fonksiyonumuzu yazalım :

char *CopyString(const char *str,char *destStr,int fromIndex); /* Prototip bildirimi */

char *CopyString(const char *str,char *destStr,int fromIndex)
{
    while (str[fromIndex] != ’\0’)
       destStr[j++] = str[fromIndex++];

    destStr[j] = ’\0’;
    return destStr;
}

"CopyString" isimli fonksiyonumuz, "str" parametresi ile belirtilen karakter katarının "fromIndex" parametresi ile belirtilen sıra numarasından başlayarak sonuna kadar olan kısmını "destStr" parametre değişkenine kopyalar ve yine bu değişkenin adresine geri döner. Fonksiyondaki while döngüsü, "str" katarının sonuna gelinmediği müddetçe dönüyor. Döngü içerisinde de "destStr" parametre değişkenine, "str" değişkenindeki karakterler sırayla kopyalanıyor. Fonksiyon bu haliyle, karakter katarı aramak için tasarladığımız yapıya uygundur. Şimdi asıl fonksiyonumuza geçelim :

BOOL IsContainString(const char *str,const char *subStr); /* Prototip bildirimi*/

BOOL IsContainString(const char *str,const char *subStr)
{
    int loop;
    int index = 0;
    int len = strlen(str);
    int same;

    char *tstr = malloc(MAX_STRING_LENGTH);

    if (strlen(subStr) < 1) {
        free(tstr);
        return FALSE;
    }

    while (index < len) {
       tstr = CopyString(str,tstr,index);
       same = 1;
       loop = 0;

       while (tstr[loop] != ’\0’ && subStr[loop] != ’\0’)
          if (tstr[loop] != subStr[loop]) {
             same = 0;
             break;
          }
          else loop++;

        if (subStr[loop] != ’\0’)
           same = 0;

        if (same) {
            free(tstr);
            return TRUE;
        }

        index++;
    }

    free(tstr);
    return FALSE;
}

"CopyString" isimli fonksiyonu çağırırken kullanmak üzere (char *) türünden "tstr" isimli bir değişken tanımlıyoruz ve standart malloc fonksiyonu ile bu değişken için dinamik alan tahsis ediyoruz. Burada malloc fonksiyonuna parametre olarak gönderdiğimiz "MAX_STRING_LENGTH", kaynak kodun başında "#define" önişlemci komutu kullanılarak sembolik sabit olarak belirtiliyor. Çalışma zamanında taşma hatasıyla karşılaşmamak için bu sembolik sabitin tanımlandığı değere dikkat edilmelidir. Daha sonra, aranacak karakter katarının uzunluğunu standart strlen fonksiyonunu kullanarak kontrol ediyoruz. Eğer uzunluk 1’den küçük ise fonksiyon FALSE değerine geri dönüyor. Burada "return" ifadesinden önce dinamik olarak tahsis ettiğimiz alanı standart free fonksiyonu ile serbest bırakıyoruz. Fonksiyondaki while döngüsü, "index" parametresinin değeri, "len" parametresinin değerinden küçük olduğu müddetçe dönüyor. Bu şekilde her adımda, içinde arama yapılacak katarı, ilgili sıra numarasından başlamak suretiyle "tstr" değişkenine kopyalanıyor, ve "tstr" nin aranan karakter katarını içerip içermediği kontrol ediliyor. Döngünün içerisindeki ikinci while döngüsü, "StartWith" fonksiyonundaki döngüye benzer biçimde çalışıyor. Aranan karakter katarı bulunduğu anda döngüden çıkılıyor. Dinamik olarak tahsis ettiğimiz alanı, fonksiyon sonunda standart free fonksiyonu ile serbest bırakıyoruz. Eğer aranan karakter katarı bulunamazsa fonksiyon FALSE değeri döndürüyor.

Şimdi listemize ait fonksiyonlarımızı yazmaya devam edelim. Öncelikle listede belli bir isme sahip kaydın numara değerine geri dönen "FindNumberFromName" fonksiyonunu yazalım. Bu fonksiyon, aranan isimle, listedeki kayıtlara ait isimlerin tam eşitliğini kontrol edecek, bu nedenle standart strcmp fonksiyonunu kullanabiliriz.

int FindNumberFromName(recordList list, char *name); /* Prototip bildirimi*/


int FindNumberFromName(recordList list, char *name)
{
    record *tmpRecord = list->start;

    while (tmpRecord) {
       if (!strcmp(tmpRecord->rName,name))
          return tmpRecord->rNumber;

       tmpRecord = tmpRecord->rNext;
    }

    return -1;
}

Fonksiyonda, parametre olarak geçilen "list" isimli liste içerisinde, "name" parametre değişkeni ile aynı karakter katarına sahip kayıt aranıyor. Eğer böyle bir kayıt bulunursa fonksiyon bu kaydın "rNumber" veri elemanının değerine geri dönecek. İlk olarak listenin başındaki kaydın adresini "tmpRecord" isimli göstericiye atıyoruz. İzleyen while döngüsü, "tmpRecord" kaydı null olmayana dek devam ediyor. Hatırlayacağınız üzere liste sonunda bulunan kaydın "rNext" isimli veri elemanına NULL değer atamıştık, ve liste sonuna gelindiğini bu koşul ile sınıyorduk. While döngüsü içerisinde, "tmpRecord" kaydının "rName" veri elemanının değeri ile "name" isimli parametre değişkeni, standart strcmp fonksiyonuna parametre olarak gönderiliyor. Standart strcmp fonksiyonu, ilk parametre değişkeni olarak gönderilen karakter katarı, sözlük sırasına göre, ikinci parametre değişkeni olarak gönderilen karakter katarından küçük ise negatif değere, ikinci karakter katarına eşit ise sıfır değerine ve ikinci karakter katarından büyük ise pozitif değere geri dönüyordu. If ifadesindeki "!strcmp(tmpRecord->rName,name)" koşulu da iki karakter katarının eşit olması durumunda doğru olacak ve if ifadesindeki "return tmpRecord->rNumber;" kodu çalışacaktır. Bu kod da, kaydın "rNumber" veri elemanının değerini döndürüyor. Eşitsizlik durumunda ise, "tmpRecord" göstericisine bir sonraki kaydın adresi atanıyor ve döngü dönmeye devam ediyor. Eğer döngü içerisinde "return" ifadesi ile fonksiyondan geri dönülmemişse, aranan isme sahip bir kayıt bulunamamıştır, bu durumda "return" ifadesi ile fonksiyonu -1 değerine döndürdük. Burada geri dönüş değeri olarak, listede numara değeri olarak kullanmayacağımız, özel bir değer seçmeliyiz. Daha sonra fonksiyonu çağırdığımız yerde, geri dönüş değerinin belirlediğimiz bu değer olup olmadığını kontrol ederek kayıt bulunup bulunmadığını anlayabiliriz.

Şimdi yazacağımız fonksiyon, listedeki kayıtları dolaşarak, belli bir karakter katarını içeren kayıt sayısını bulacak. Bu fonksiyonda, makalemizin başında yazmış olduğumuz fonksiyonları kullanacağız.

int NumberOfContainString(recordList list, char *str); /* Prototip bildirimi */

int NumberOfContainString(recordList list, char *str)
{
    int result = 0;
    record *tmpRecord = list->start;

    while (tmpRecord) {
       if (IsContainString(tmpRecord->rName,str))
          result++;
       tmpRecord = tmpRecord->rNext;
    }

    return result;
}

Fonksiyonun geri dönüş değeri olarak kullanacağımız tamsayı türünden "result" isimli değişkene başlangıçta sıfır değerini atıyoruz. Bu değişken bulunan kayıtların sayısını tutacak. Listedeki kayıtları dolaşırken kullanacağımız (record *) türünden "tmpRecord" isimli bir gösterici tanımlayıp, bu göstericiye ilk değer olarak listenin başında yer alan kaydın adresini atıyoruz. While döngüsü, göstericimiz NULL değere sahip olmadığı müddetçe dönecek. Döngü içerisinde "tmpRecord" göstericisinin gösterdiği kaydın "rName" veri elemanının değerini ve aradığımız karakter katarını tutan "str" isimli parametre değişkenini, daha önce yazmış olduğumuz "IsContainString" isimli fonksiyonumuza gönderiyoruz. Eğer aranan karakter katarı, kaydın "rName" veri elemanında bulunursa fonksiyon TRUE değeri döndürür ve bu durumda "result" değişkenimizin değerini bir artırıyoruz. Göstericiye, bir sonraki kaydın adresini atıyoruz, bu şekilde listedeki tüm kayıtların isim bilgisi kontrol ediliyor. Fonksiyon "result" değişkeninin değerine geri dönüyor.

Listemizde yer alan tüm kayıtları bir dosyaya yazdıralım. Önce bir kaydı dosyaya yazdıracak fonksiyonumuzu oluşturalım. Bu fonksiyon, parametre değişkeni olarak, açılmış bir dosyanın "handle" değerini ve yazılacak kaydı gösteren (record *) türünden bir göstericiyi almalıdır.

void WriteRecordToFile(FILE *fp,record *rp); /* Prototip bildirimi */

void WriteRecordToFile(FILE *fp,record *rp)
{
     fprintf(fp,"%s - %d\n",rp->rName,rp->rNumber);
}

Fonksiyonda standart fprintf fonksiyonunu kullanarak, kaydın "rName" ve "rNumber" veri elemanlarının değerlerini dosyaya yazdırdık. fprintf fonksiyonu, printf fonksiyonu gibi çalışır; tek farkı ise yazılacak bilgiyi ekrana değil, ilk parametresinde gönderilen dosya işaretçisinin gösterdiği dosyaya yazdırmasıdır. (Eğer ilk parametre değişkeni olan dosya göstericisi olarak "stdout" geçerseniz, bilgi ekrana yazdırılır; burada "stdout" stdio.h standart başlık dosyasında tanımlı bir dosya işaretçisidir ve program başlatıldığında işletim sistemi tarafından otomatik olarak yaratılır. "stdout", ekrana bağlıdır.) Şimdi listedeki tüm kayıtları dosyaya yazdıracak fonksiyonumuzu yazalım :

void WriteAllRecordsToFile(const char *fileName,recordList list); /* Prototip bildirimi */

void WriteAllRecordsToFile(const char *fileName,recordList list)
{
    FILE *fp;
    record *tmpRecord = list->start;

    if ((fp = fopen(fileName,"w")) == NULL) {
       printf("Dosya acilamadi\n");
       exit(EXIT_FAILURE);
    }

    while (tmpRecord) {
       WriteRecordToFile(fp,tmpRecord);
       tmpRecord = tmpRecord->rNext;
    }
    fclose(fp);
}

Fonksiyonumuz parametre değişkeni olarak oluşturulacak dosyanın adını ve dosyaya yazılacak kayıtları tutan listeyi alıyor. Öncelikle (FILE *) türünden bir gösterici tanımlıyoruz. Bu gösterici, açacağımız dosyayı gösteren dosya işaretçisidir. Dosya işlemlerini yapan diğer standart fonksiyonları çağırırken bu dosya işaretçisini kullanacağız. Listeyi dolaşırken kullanacağımız (record *) türünden bir gösterici tanımlayarak bu göstericiye ilk değer olarak listenin başındaki kaydın adresini atıyoruz. Daha sonra dosyayı, fopen fonksiyonu ile yazma modunda ("w") açıyoruz. Eğer dosya herhangi bir sebepten dolayı açılamazsa fopen fonksiyonu NULL değere geri döner, bu durumda "Dosya açılamadı" mesajı vererek programdan çıkışımızı sağlayacak exit fonksiyonunu çağırıyoruz. Eğer dosya açılmışsa while döngüsü işlemeye başlar. Bu döngünün her adımında sıradaki kayıt, az önce yazmış olduğumuz "WriteRecordToFile" fonksiyonuna gönderiliyor ve kayıt "fp" dosya işaretçisinin gösterdiği dosyaya yazılıyor. Döngünün her adımında "tmpRecord" isimli göstericiye listede bir sonraki sırada yer alan kaydın adresini atıyoruz ve bu gösterici NULL değere sahip olduğunda döngüden çıkıyoruz. Bu noktada listemizdeki tüm kayıtlar dosyaya yazılmış durumdadır. Fonksiyondan çıkmadan önce açmış olduğumuz dosyayı, fclose fonksiyonunu çağırarak kapatıyoruz. Programı çalıştırdığınızda, çalıştırılabilir dosyanızın (.exe) bulunduğu dizinde verdiğiniz isme sahip bir dosya oluşturulmuş olmalıdır.

Liste içerisinde, belli bir karakter ile başlayan kayıtları bulmak isteyebiliriz. Örneğin ismi "a" ile başlayan kayıtları ekrana yazdırmak isteyebiliriz. Bu isteğimizi karşılayacak bir fonksiyon yazalım. Önce, listede söz konusu karakter ile başlayan kayıtların, liste içerisindeki sıra numaralarını bulan bir fonksiyon yazalım.

void FindRecordsStartWith(recordList list,const char *str, int *index); /* Prototip bildirimi */

void FindRecordsStartWith(recordList list,const char *str, int *index)
{
    int i = 0, lIndex = 0;
    record *tmpRecord = list->start;

    while (tmpRecord) {
       if (StartWith(tmpRecord->rName,str))
           index[i++] = lIndex;
       lIndex++;
       tmpRecord = tmpRecord->rNext;
    }
    index[i] = -1;
}

Fonksiyonumuz, parametre değişkeni olarak gönderilen liste içerisinde dolaşarak, ismi "str" nin belirttiği karakter ya da karakter katarı ile başlayan kayıtların liste içerisindeki sıra numaralarını, yine parametre değişkeni olarak gönderilen (int *) türünden "index" isimli parametre değişkenine atayacak. Bu parametre değişkeni için fonksiyonu çağırdığımız yerde tanımlayacağımız tamsayı türünden bir dizinin adresini gönderebiliriz. Listede dolaşırken kayıtları "tmpRecord" isimli göstericiye atıyoruz. while döngümüz bu göstericinin değeri NULL olmadığı müddetçe dönüyor. Döngü içerisinde, sıradaki kaydın "rName" veri elemanında saklanan isim bilgisinin, "str" ile belirtilen karakter katarı ile başlayıp başlamadığı kontrol ediliyor. Bu kontrol için de daha önce yazmış olduğumuz "StartWith" isimli fonksiyonumuzu kullanıyoruz. Eğer bu fonksiyondan TRUE değeri alırsak, "index" isimli parametre değişkenimizin sıradaki elemanına, kaydın liste içerisindeki sıra numarasını atıyoruz. Fonksiyondan çıkmadan önce, diziye son eleman olarak -1 değerini atıyoruz. Bu değeri dizi sonuna gelinip gelinmediğini kontrol etmek için kullanacağız. Hiçbir elemanın sıra numarası negatif bir değer olamayacağı için -1 değerini seçmemizde bir sakınca yok. Şimdi bu diziyi parametre değişkeni olarak alacak ve sıra numaralarından kayıtlara ulaşıp bilgilerini ekrana yazdıracak fonksiyonumuzu yazalım.

void WriteRecordByIndex(recordList list,int index); /* Prototip bildirimi*/

void WriteRecordByIndex(recordList list,int index)
{
    record *tmpRecord;
    int tmpIndex = index;

    if (index > list->size || index < 0)
       return;

    tmpRecord = list->start;

    if (index == 0) {
       WriteRecordToFile(stdout,tmpRecord);
       return;
    }

    while (index--)
       tmpRecord = tmpRecord->rNext;

    WriteRecordToFile(stdout,tmpRecord);
}

Fonksiyonun başında sıra numarası değerinin doğruluğu kontrol ediliyor. Bu değer, listenin toplam kayıt sayısından küçük, sıfırdan büyük veya sıfıra eşit olmalıdır. Eğer bu koşul sağlanmıyorsa fonksiyondan çıkılıyor. Eğer sıra numarası sıfır ise listedeki ilk kaydın bilgileri ekrana yazdırılıyor ve fonksiyondan çıkılıyor. Diğer durumlarda ilgili kayıt "while(index--)" ifadesi ile bulunuyor. Bu döngüden çıkıldığında "tmpRecord" göstericisi aradığımız kaydı gösteriyor olacaktır. Kaydın bilgilerini ekrana nasıl yazdırdığımıza dikkat edin : "WriteRecordToFile(stdout,tmpRecord);" Bunun için dosyaya kaydın bilgilerini yazmak için tanımladığımız fonksiyonu kullandık. Bu fonksiyona dosya işaretçisi olarak "stdout" gönderdiğimizde, işletim sistemi tarafından otomatik olarak tanımlanan bu işaretçi ekranı gösterdiği için yazma işlemi de ekrana yapılacaktır.

Bir makalemizin daha sonuna geldik, bir dahaki makalemizde görüşmek üzere..

Kaynak kod için tıklayın.

 

Makale:
Karakter Katarları Üzerinde İşlemler ve Bağlı Liste Uygulaması - 3 C ve Sistem Programlama Çiğdem Çavdaroğlu
  • Yazılan Yorumlar
  • Yorum Yaz
Bu konu hakkında yayınlanan yorum bulunmamaktadır.
"Yorum Yaz" tabını kullanarak sizde yorumlarınızı yazabilirsiniz.
Yorum yazabilmek için üye girişi yapmalısınız. Üye girişi için tıklayın.
Üye değilseniz Üyel Ol linkine tıklayarak üyeliğinizi hemen başlatabilirisniz.
 
  • Bu Konuda Son 10
  • Eklenen Son 10
  • Bu Konuda Geçmiş 10
Bu Konuda Yazılmış Yazılmış 10 Makale Yükleniyor
Son Eklenen 10 Makale Yükleniyor
Bu Konuda Yazılmış Geçmiş Makaleler Yükleniyor