folder Tahribat.com Forumları
linefolder C - C++
linefolder C De Yazmak İstedigim Bi Program ?



C De Yazmak İstedigim Bi Program ?

  1. KısayolKısayol reportŞikayet pmÖzel Mesaj
    aLsanCaK
    aLsanCaK's avatar
    Kayıt Tarihi: 30/Kasım/2007
    Erkek

    birazdan bir yerden bularak duzenlemeye calistigim kodlari paylasicam ( bir ton error ve warning var) ama zaman kazanmak acisindan konuyu simdi aciyorum, ben duzenleyene kadar yazan cikabilir diye :) program soyle olacak;

     

    menu

    1 kitap ekle ( kitap adi, kitabin yazari, fiyati)

    2 kitaplari listele ( fiyati kucuk olandan buyuk olana dogru butun kitaplari listeleyecek)

    3 cikis

     

    c++ ile olmayacak ozellikle c ile olmasi gerekiyor .. simdiden tesekurler

  2. KısayolKısayol reportŞikayet pmÖzel Mesaj
    Fikret
    Fikret's avatar
    Kayıt Tarihi: 01/Ekim/2007
    Erkek

    C bilmiyorum fakat yardımım dokunur diyerekten yazayım.

    veritabanı bağlantısını ve sql cümlelerini araştır. select ve insert sorguları bu program için işini görür :)

  3. KısayolKısayol reportŞikayet pmÖzel Mesaj
    JPriest
    JPriest's avatar
    Kayıt Tarihi: 09/Mart/2007
    Erkek

    Eğer ödevse bu veri tabanından ziyade struct (yapı) öğrenilmesi için verilmiştir. Birazdan anlarız.

    Edit : evet öyleymiş. File i/o, struct, pointer işlemleri.

  4. KısayolKısayol reportŞikayet pmÖzel Mesaj
    aLsanCaK
    aLsanCaK's avatar
    Kayıt Tarihi: 30/Kasım/2007
    Erkek

    /**bu kodlari da duzeltebilireseniz yada oda olur**/

     

    #include <stdio.h>
    #include <ctype.h>


    struct book_struct
    { char book_name[25];
    char book_writer[25];
    float price;
    };

    FILE *fp;

    #define MAX 250
    #define FILENAME "book.dat"


    void main(void);
    void menu(void);
    void add_book(void);
    void list_book(void);
    void add_to_file(struct book_struct item);

    /*********************************************************/
    void main(void)
    {
    struct book_struct ;
    char ans;
    do
    { menu();
    scanf(" %d", &ans);
    switch (ans)
    { case (1) : { add_book();
    break; }
    case (2) : { list_book();
    break; }
    }
    while (ans!=3);

    }
    /*********************************************************/
    void disp_menu()
    {

    printf("\t\t Ana Menu\n");
    printf("\t\t --------------------\n\n\n\n");
    printf("ne istiyorsunuz?:\n\n\n");
    printf("\t1. yeni kitap ekle\n\n\n");
    printf("\t2. kitaplari listele\n\
    \n\n");
    printf("\t3. programi kapat\n\n\n");
    printf("seciminiz nedir?");
    }

    /*********************************************************/
    void add_book(void)
    {
    struct book_struct item;
    char ans;
    do
    { fflush(stdin);
    printf("\n\n\n\n\nkitap adi ? ");
    gets(item.book_name);
    printf("yazar adi? ");
    gets(item.book_writer);
    printf("fiyati? ");
    gets(item.price);


    add_to_file(item);
    printf("\n\nyeni bir kitap eklemek istermisiniz?");
    printf(" secim ? (Y/N) ");
    ans=getchar();
    getchar();
    } while (toupper(ans)=='Y');


    }

    /*********************************************************/
    void print_na(void)
    {
    struct book_struct item;
    int s, linectr=0;

    s = sizeof(struct book_struct);
    if((fp=fopen(FILENAME, "r"))==NULL)

    do
    { if(fread(&item, sizeof(struct book_struct), 1,
    fp)!=s)
    { if(feof(fp))
    { break; }
    }
    if (linectr>20)
    {
    linectr=0; }
    pr_data(item);
    linectr+=4;
    } while (!feof(fp));
    fclose(fp);
    printf("\n- End of list -");
    pause_sc();
    return 0;
    }

    /*********************************************************/
    void err_msg(char err_msg[])
    {
    printf("\n\n%s\n", err_msg);
    printf("%c", BELL);
    return 0;
    }

    /*********************************************************/
    void add_to_file(struct book_struct item)
    {
    if((fp = fopen(FILENAME, "a"))==NULL) /* Open file in
    append mode */
    { err_msg("*** Disk error--please check \
    disk drive ***");
    return 0; }
    fwrite(&item, sizeof(item), 1, fp);

    fclose(fp);
    return 0;
    }

  5. KısayolKısayol reportŞikayet pmÖzel Mesaj
    JPriest
    JPriest's avatar
    Kayıt Tarihi: 09/Mart/2007
    Erkek

    Fonksiyonların hepsi void tanımlanmış ama sonlarında return 0; var. Bildiğim kadarıyla void tanımlanan metodların içinde return olmaz. O kısımları düzeltmekle başlayabilirsin. Bir de Windows'ta çalışıyorsan main fonksiyonu şöyle başlasın

    int main (){

    //yapılacak işler

    ..

    şöyle de bitsin :

    system ("pause");

    return 0;

    }

  6. KısayolKısayol reportŞikayet pmÖzel Mesaj
    yafa13
    yafa13's avatar
    Kayıt Tarihi: 01/Kasım/2007
    Erkek

    Bizde bunun geniş hali vardı şu kodlar yardımcı olur sanki kardeş sana

     

     

    #include <stdio.h>
    #include <stdlib.h>  /* calloc(), free() */
    #include <time.h>    /* time(), localtime(), strftime() */
    #include <string.h>  /* strcpy(), strncpy(), strtok(), strstr(), strcmp() */

    typedef enum {FALSE, TRUE} bool;
    enum {KITAP_EKLE=1, KITAP_CIKAR, ODUNC_VER, GERI_AL, ARAMA1, ARAMA2, LISTELE1,
          LISTELE2, KAPAT=0};

    typedef struct kitap_s{
        char ad[256];
        char yazar[256];
        char yayin_yili[256];
        char odunc_verilen[256];
        char odunc_verilme_tarihi[256];
        char raf_no[256];

        struct kitap_s *next1;  /* Bağlantılı liste */
        struct kitap_s *next2;  /* Bağlantılı liste */
    }kitap_t;

    typedef struct liste_s{
        struct kitap_s *son1;  /* Listenin son elemanı */
        struct kitap_s *son2;  /* Listenin son elemanı */
    }liste_t;

    /* program arabirimi fonksiyonları */
    void dosyadan_oku(char *dosya_adi, liste_t *liste);
    int dosyaya_yaz(char *dosya_adi, liste_t *liste);
    void ekran_temizle(void);
    int menu(char *kriter1, char *kriter2);
    char *arguman(char *bilgi);
    char *u2l(const char *st);
    void menuye_don(void);

    /* Menü fonksiyonları */
    void kitap_ekle(liste_t *liste);
    void kitap_cikar(char *kriter, liste_t *liste);
    void odunc_ver(char *kriter, liste_t *liste);
    void geri_al(char *kriter, liste_t *liste);
    int arama(char* kriter, liste_t *liste);
    void listele(char *kriter, int sira, liste_t *liste);

    /* Çevrel liste fonksiyonları */
    void sonuna_ekle(kitap_t *kitap, liste_t *liste);
    void basina_ekle(kitap_t *kitap, liste_t *liste);
    bool bos_liste(liste_t *liste);
    void dugum_sil(int dugumNO, liste_t *liste);
    void liste_yaz(FILE *file, int numarala, int sira, liste_t *liste);
    int dugum_bul(kitap_t *dugum, int next, liste_t *liste);
    kitap_t *BubbleSort(char *kriter, int sira, liste_t *liste);
    void swap(kitap_t *prev, kitap_t *cur, kitap_t *next, int sira, liste_t *liste);

    int main(int argc, char *argv[])
    {
        liste_t liste;
       
        liste.son1 = NULL;
        liste.son2 = NULL;
       
        if( (argc < 4) || !arguman(argv[2]) || !arguman(argv[3]) )
        { /* Eksik veya geçersiz parametre */
            printf("Kullanim: odev3 dosya_adi kriter_1 kriter_2\n");
            return -1;
        }
       
        dosyadan_oku(argv[1], &liste);
        while(1)
        {
            switch(menu(argv[2], argv[3]))
            {
                case KITAP_EKLE:
                    kitap_ekle(&liste);
                    break;

                case KITAP_CIKAR:
                    kitap_cikar(argv[2], &liste);
                    break;

                case ODUNC_VER:
                    odunc_ver(argv[2], &liste);
                    break;

                case GERI_AL:
                    geri_al(argv[2], &liste);
                    break;

                case ARAMA1:
                    arama(argv[2], &liste);
                    break;

                case ARAMA2:
                    arama(argv[3], &liste);
                    break;
               
                case LISTELE1:
                    listele(argv[2], 1, &liste);
                    break;

                case LISTELE2:
                    listele(argv[3], 2, &liste);
                    break;

                case KAPAT:
                    if(dosyaya_yaz(argv[1], &liste))
                        return 0;
                    break;

                default:
                    printf("Gecersiz secim yaptiniz!\n");
            } // switch sonu
        } // while sonu
        return 0;
    }

    /****************************************************************
     * fonksiyon: sonuna_ekle                                       *
     * Verilen kitabı listenin sonuna ekler                         *
     ****************************************************************/
    void sonuna_ekle(kitap_t *kitap, liste_t *liste)
    {
        if(liste->son1 == NULL) /* Liste boşsa */
        {
            kitap->next1 = kitap->next2 = kitap;
            liste->son1 = liste->son2 = kitap;
        }
        else
        {
            kitap->next1 = liste->son1->next1;
            liste->son1->next1 = kitap;
            liste->son1 = kitap;

            kitap->next2 = liste->son2->next2;
            liste->son2->next2 = kitap;
            liste->son2 = kitap;
        }
    }

    /****************************************************************
     * fonksiyon: bos_liste                                         *
     * Listenin boş olup olmadığı bilgisini döndürür                *
     ****************************************************************/
    bool bos_liste(liste_t *liste)
    {
        return (liste->son1 == NULL);
    }

    /*******************************************************************
     * fonksiyon: liste_yaz                                            *
     * Verilen listeyi, numaralı ya da numarasız verilen dosyaya yazar *
     *******************************************************************/
    void liste_yaz(FILE *file, int numarala, int sira, liste_t *liste)
    {
        kitap_t *tmp;
        int i = 1;
        char *ch;

        ch = (numarala) ? ", " : " |";

        if(liste->son1 == NULL)
        {
            if(numarala)
                fprintf(file, "Liste bos!");
            fprintf(file, "\n");
        }
        else
        {
            tmp = (sira == 1) ? liste->son1 : liste->son2;
            do
            {
                tmp = (sira == 1) ? tmp->next1 : tmp->next2;
                if(numarala)
                    fprintf(file, "%d: ", i++);
                fprintf(file, "%s%s%s%s%s%s%s%s%s%s%s \n",
                    tmp->ad, ch,
                    tmp->yazar, ch,
                    tmp->yayin_yili, ch,
                    tmp->odunc_verilen, ch,
                    tmp->odunc_verilme_tarihi, ch,
                    tmp->raf_no);
            }while(tmp != ( (sira == 1) ? liste->son1 : liste->son2));
        }
    }

    /****************************************************************
     * fonksiyon: eleman_bul                                        *
     * Verilen sıra numarasındaki elemanı döndürür                  *
     ****************************************************************/
    kitap_t * eleman_bul(int sira, int next, liste_t *liste)
    {
        kitap_t *tmp;
        int i=0;
       
        if(liste->son1 == NULL)
            return NULL; // Liste boş
        tmp = (next == 1) ? liste->son1 : liste->son2;
        do
        {
            tmp = (next == 1) ? tmp->next1 : tmp->next2;
            i++;
        }while((tmp != ( (next == 1) ? liste->son1 : liste->son2))&&(i < sira) );
        if(i == sira)
            return tmp;
        else
            return NULL;  //Listede o kadar eleman yok
    }

    /****************************************************************
     * fonksiyon: dugum_bul                                         *
     * Verilen adresteki elemanın numarasını döndürür               *
     ****************************************************************/
    int dugum_bul(kitap_t *dugum, int next, liste_t *liste)
    {
        kitap_t *tmp;
        int i=0;
       
        if(liste->son1 == NULL)
            return 0; // Liste boş

        tmp = (next == 1) ? liste->son1 : liste->son2;
        do
        {
            tmp = (next == 1) ? tmp->next1 : tmp->next2;
            i++;
            if(tmp == dugum)
                return i;
        }while(tmp != ((next == 1) ? liste->son1 : liste->son2));
        return 0;  //Listede o kadar eleman yok
    }

    /****************************************************************
     * fonksiyon: dugum_sil                                         *
     * Belirtilen sıradaki düğümü siler, listeden çıkarır           *
     * Eleman iki listeden de çıkarılmalıdır                        *
     ****************************************************************/
    void dugum_sil(int dugumNO, liste_t *liste)
    {
        kitap_t *tmp1, *tmp2, *tmp3;
        int tmp_no_2;

        tmp1 = eleman_bul(dugumNO, 1, liste);
        tmp_no_2 = dugum_bul(tmp1, 2, liste);
        tmp2 = eleman_bul(dugumNO-1, 1, liste);
        tmp3 = eleman_bul(dugumNO+1, 1, liste);

        if(tmp1)
        {
            if(tmp2 && tmp3) /* ortada bir eleman */
                tmp2->next1 = tmp3;
            else if(tmp2)  /* Liste sonu */
            {
                tmp2->next1 = tmp1->next1;
                liste->son1 = tmp2;
            }
            else if (tmp3)  /* Liste başı */
            {
                liste->son1->next1 = tmp3;
            }
            else  /* Tek elemanlı */
                liste->son1 = NULL;

            tmp2 = eleman_bul(tmp_no_2 - 1, 2, liste);
            tmp3 = eleman_bul(tmp_no_2 + 1, 2, liste);

            if(tmp2 && tmp3) /* ortada bir eleman */
                tmp2->next2 = tmp3;
            else if(tmp2)  /* Liste sonu */
            {
                tmp2->next2 = tmp1->next2;
                liste->son2 = tmp2;
            }
            else if (tmp3)  /* Liste başı */
            {
                liste->son2->next2 = tmp3;
            }
            else  /* Tek elemanlı */
                liste->son2 = NULL;

            free(tmp1);
        }
        else
        {
            printf("dugum_sil: Olmayan bir kitap seçtiniz!\n");
            menuye_don();
        }
    }

    /*************************************************************************
     * Fonksiyon: dosyadan_oku                                               *
     * Belirtilen dosyadan kitap bilgilerini alıp, listeye kopyalar          *
     * dosya adı için bir karakter dizisi ve liste için bir işaretçi gerekir *
     *************************************************************************/
    void dosyadan_oku(char *dosya_adi, liste_t *liste)
    {
        FILE *file;
        char *temp, line[1024]={0};
        int offset=0;  /* Kitabın hangi özelliğinde olduğunu tutan indeks*/
        kitap_t *kitap_tmp;
       
        if((file = fopen(dosya_adi, "r")) == NULL)
        {
            printf("dosyadan_oku: Belirttiginiz dosya acilamadi.\n");
            printf("Kapatmak icin ENTER tusuna basin.\n");
            getchar();
            exit(-1); /* Hata ver, çık */
        }

        while(!feof(file))
        {
            if((kitap_tmp = (kitap_t *) calloc(1, sizeof(kitap_t))) == NULL)
            {
                printf("dosyadan_oku: Bellek yetersiz!\n");
                printf("Kapatmak icin ENTER tusuna basin.\n");
                getchar();
                exit(-1);
            }
            fgets(line, 1024, file);  // Dosyadan bir satır oku
            if(strlen(line) < 9)  // Çok kısa, hatalı olabilir; sonraki satıra geç
                continue;
            offset = 0;
            temp = strtok(line, "|\n"); // | veya \n karakterine gelene kadar oku
            while(temp != NULL)  //satır sonuna kadar
            {
                switch(offset)
                {
                    case 0:
                        strncpy(kitap_tmp->ad, temp, strlen(temp)-1);
                        break;
                    case 1:
                        strncpy(kitap_tmp->yazar, temp, strlen(temp)-1);
                        break;
                    case 2:
                        strncpy(kitap_tmp->yayin_yili, temp, strlen(temp)-1);
                        break;
                    case 3:
                        strncpy(kitap_tmp->odunc_verilen, temp, strlen(temp)-1);
                        break;
                    case 4:
                        strncpy(kitap_tmp->odunc_verilme_tarihi, temp,
                                strlen(temp)-1);
                        break;
                    case 5:
                        strncpy(kitap_tmp->raf_no, temp, strlen(temp)-1);
                        sonuna_ekle(kitap_tmp, liste);
                } /* switch sonu */
                temp = strtok(NULL, "|\n");  // aynı satırdan, bir sonraki bölümü al
                offset++;
            } /* while(temp != NULL) sonu */
        } /*while(!feof(file)) sonu */
        fclose(file);
    }
    /****************************************************************
     * fonksiyon: menu                                              *
     * Komut satırında belirtilen kriterlere göre bir menü gösterir *
     * kriterler için iki tane karakter dizisi alır                 *
     * Yapılan seçimi geri döndür                                   *
     ****************************************************************/
    int menu(char *kriter1, char *kriter2)
    {
        int i=0;
        char c[10];
       
        ekran_temizle();
       
        printf("\tMENU\n");
        printf("\t----\n\n");
        printf("1. Kitap Ekle\n");
        printf("2. Kitap Cikar\n");
        printf("3. Odunc Ver\n");
        printf("4. Geri Al\n");
        printf("5. %s ile ara\n", arguman(kriter1));
        printf("6. %s ile ara\n\n", arguman(kriter2));
        printf("7. %s ile listele\n", arguman(kriter1));
        printf("8. %s ile listele\n\n", arguman(kriter2));
        printf("0. Kapat\n\n");
       
        printf("Seciminizi girin: ");
        gets(c);
        if(strlen(c) > 1) /* Menüdekiler tek basamaklı */
            return -1;
        if(*c >= '0' && *c <= '9') /* Rakam değilse */
            return *c - '0';
        return -1;  /* Rakam girilmemiş */
    }

    /****************************************************************
     * fonksiyon: kitap_ekle                                        *
     * Kitap bilgilerini alır ve listeye ekler                      *
     ****************************************************************/
    void kitap_ekle(liste_t *liste)
    {
        kitap_t *kitap=NULL;
       
        if( (kitap = (kitap_t *) calloc(1, sizeof(kitap_t)) ) != NULL)
        {
            printf("\n");
            printf("Kitabin Adi: ");
            gets(kitap->ad);
           
            printf("Kitabin Yazari: ");
            gets(kitap->yazar);
           
            printf("Kitabin Yayin Yili: ");
            gets(kitap->yayin_yili);
           
            printf("Kitabin Raf Numarasi: ");
            gets(kitap->raf_no);
           
            sonuna_ekle(kitap, liste);  /* listenin sonuna kaydet */
        }
        else
        {
            printf("*** kitap_ekle: Bellek yetersiz!\n");
            menuye_don();
        }
    }

    /****************************************************************
     * fonksiyon: kitap_cikar                                       *
     * Seçilen kitabı listeden siler                                *
     ****************************************************************/
    void kitap_cikar(char *kriter, liste_t *liste)
    {
        int kitapNO = 0;

        if( bos_liste(liste) )
        {
            printf("\nkitap_cikar: Liste bos!\n");
            menuye_don();
        }
        else
        {
            ekran_temizle();
            printf("Kitap listesi:\n\n");
            BubbleSort(kriter, 1, liste);
            liste_yaz(stdout, TRUE, 1, liste);  /* ekrana numaralı listeyi yazdırır */

            printf("Cikarilacak kitabin numarasini girin: ");
            scanf("%d", &kitapNO);
            if(kitapNO > 0)
                dugum_sil(kitapNO, liste);
            menuye_don();
        }
    }

    /****************************************************************
     * fonksiyon: odunc_ver                                         *
     * Hangi kitabın kime ödünc verileceği bilgisini alır, kaydeder *
     ****************************************************************/
    void odunc_ver(char *kriter, liste_t *liste)
    {
        int kitapNO;
        char kime[256];
        kitap_t *tmp = NULL;
        time_t tm = time(NULL);
        struct tm *ptr = localtime(&tm);

        ekran_temizle();
        BubbleSort(kriter, 1, liste);
        liste_yaz(stdout, TRUE, 1, liste);
        printf("\nOdunc verilecek kitabı seçin: ");
        scanf("%d", &kitapNO);  // \n'i halletmek gerekli
        getchar();
        printf("Kime odunc verilecek: ");
        gets(kime);

        if((tmp = eleman_bul(kitapNO, 1, liste)) != NULL)
        {
            strcpy(tmp->odunc_verilen, kime);
            strftime(tmp->odunc_verilme_tarihi, 255, "%d.%m.%Y", ptr);
            printf("Odunc verildi.\n\n");
        }
        else
        {
            printf("\nodunc_ver: Eleman bulunamadi!\n");
            menuye_don();
        }
    }

    /****************************************************************
     * fonksiyon: geri_al                                           *
     * Seçilen kitabın odunc verilen ve verilme tarihi kısmını siler*
     ****************************************************************/
    void geri_al(char *kriter, liste_t *liste)
    {
        int kitapNO;
        kitap_t *tmp;

        ekran_temizle();
        BubbleSort(kriter, 1, liste);
        liste_yaz(stdout, TRUE, 1, liste);
        printf("Geri alinacak kitabi secin: ");
        scanf("%d", &kitapNO);
        getchar();

        if((tmp = eleman_bul(kitapNO, 1, liste)) != NULL)
        {
            strcpy(tmp->odunc_verilen, "\0\0");
            strcpy(tmp->odunc_verilme_tarihi, "\0\0");
            printf("Geri alindi.\n\n");
            menuye_don();
        }
        else
            printf("\ngeri_al: Eleman bulunamadi!\n");
    }

    /****************************************************************
     * fonksiyon: dosyaya_yaz                                       *
     * listenin son halini dosyaya kaydeder                         *
     ****************************************************************/
    int dosyaya_yaz(char *dosya_adi, liste_t *liste)
    {
        FILE *file;

        file = fopen(dosya_adi, "w");
        if(file)  /* dosya açıldıysa, listeyi yaz */
        {
            liste_yaz(file, FALSE, 1, liste);
            return 1;
        }

        printf("\ndosyaya_yaz: %s kaydetmek için açılamadı!\n", dosya_adi);
        return 0;
    }

    /****************************************************************
     * fonksiyon: ekran_temizle                                     *
     * Ekrana ardarda satırsonu karakteri girerek ekranı temizler   *
     ****************************************************************/
    void ekran_temizle(void)
    {
        int i;
       
        for(i = 0; i < 5; i++, printf("\n"));
    }

    /****************************************************************
     * fonksiyon: listele                                           *
     * Menüdeki listele fonksiyonu yapar, ekrana listeyi basar      *
     ****************************************************************/
    void listele(char *kriter, int sira, liste_t *liste)
    {
        ekran_temizle();
        BubbleSort(kriter, sira, liste);
        liste_yaz(stdout, TRUE, sira, liste);
        menuye_don();
    }

    /****************************************************************
     * fonksiyon: arguman                                           *
     * komut satırından verilen kriterleri menü için hazırlar       *
     ****************************************************************/
    char *arguman(char *bilgi)
    {
        char *sonuc = NULL;

        if(!strcmp(bilgi, "kadi"))
            sonuc = "Kitap adi";
           
        if(!strcmp(bilgi, "kyazar"))
            sonuc = "Yazar adi";
           
        if(!strcmp(bilgi, "yayinyil"))
            sonuc = "Yayin yili";
           
        if(!strcmp(bilgi, "oduncver"))
            sonuc = "Odunc verilen";
           
        if(!strcmp(bilgi, "odunctar"))
            sonuc = "Odunc verilme tarihi";
           
        if(!strcmp(bilgi, "rafno"))
            sonuc = "Raf numarasi";
       
        return sonuc;
    }

    /****************************************************************
     * fonksiyon: arama                                             *
     * Verilen kritere göre, büyük-küçük harf duyarsız bir arama    *
     *    yapılabilmesini sağlar                                    *
     ****************************************************************/
    int arama(char *kriter, liste_t *liste)
    {
        kitap_t *tmp;
        int i=1, ok=0, bitti=0;
        char arama_metini[256]={0};
       
        ekran_temizle();
        if(liste->son1 == NULL)
        { /* Boş listede arama yapmaya gerek yok */
            printf("Liste Bos!\n");
            menuye_don();
            return 0;
        }
       
        printf(">%s: ", arguman(kriter));
        gets(arama_metini);  /* aranılacak kelimeyi al */

        if(*arama_metini != '\0')  /* arama kelimesi girildiyse */
        {
            i=1;
            tmp = eleman_bul(i, 1, liste);
            while(tmp)
            {
                if(!strcmp(kriter, "kadi") && strstr(u2l(tmp->ad), u2l(arama_metini)))
                    ok = 1;
                if(!strcmp(kriter, "kyazar") && strstr(u2l(tmp->yazar), u2l(arama_metini)))
                    ok = 1;
                if(!strcmp(kriter, "yayinyil") && strstr(u2l(tmp->yayin_yili), u2l(arama_metini)))
                    ok = 1;
                if(!strcmp(kriter, "oduncver") && strstr(u2l(tmp->odunc_verilen), u2l(arama_metini)))
                    ok = 1;
                if(!strcmp(kriter, "odunctar") && strstr(u2l(tmp->odunc_verilme_tarihi), u2l(arama_metini)))
                    ok = 1;
                if(!strcmp(kriter, "rafno") && strstr(u2l(tmp->raf_no), u2l(arama_metini)))
                    ok = 1;

                if(ok)
                {
                    printf("%d: %s, %s, %s, %s, %s, %s\n",
                        i,
                        tmp->ad,
                        tmp->yazar,
                        tmp->yayin_yili,
                        tmp->odunc_verilen,
                        tmp->odunc_verilme_tarihi,
                        tmp->raf_no);
                       
                    ok = 0;
                }
                i++;
                tmp = eleman_bul(i, 1, liste);
            } // while(tmp) sonu
           
        } //if(*arama_metini != '\0') sonu
        else
            printf("Arama kriteri girmediniz!\n");
        menuye_don();
    }

    /*****************************************************************
     * fonksiyon: u2l                                                *
     * Büyük harfleri, küçük harfe dönüştürür ve yeni katarı döndürür*
     *****************************************************************/
    char *u2l(const char *st)
    {
        char *lowercase, *t;
       
        t = lowercase = (char *) calloc(strlen(st)+1, sizeof(char));
       
        strcpy(lowercase, st);
        while(*lowercase)  /* Katar sonuna kadar devam edilecek */
        {
            if( (*lowercase >= 'A') && (*lowercase <= 'Z') )
                *lowercase += 'a' - 'A';  /* Küçük harfe dönüştür */
            lowercase++;
        }
        return t; /* Yeni oluşturulan katarı geri döndür*/
    }

    /******************************************************************
     * fonksiyon: menuye_don                                          *
     * menü işlemleri bitince tekrar menüye dönmeden önceki yazıyı    *
     * hazırlar                                                       *
     ******************************************************************/
    void menuye_don(void)
    {
        printf("\nMenuye donmek icin ENTER tusuna basin.\n");
        getchar();
    }

    /*******************************************************************
     * fonksiyon: BubbleSort                                           *
     * Çift işaretçili çevrel listeyi belirtilen kritere göre sıralar  *
     * Algoritması: BubbleSort sırala algoritmasının bağlantılı liste  *
     *     uygulaması                                                  *
     * Sıralama karakter katarları ile olduğundan kıyas fonksiyonu     *
     *     olarak strcmp() kullanıldı. Büyük/küçük harf ayrımı olmaması*
     *     için diziler, küçük harf olarak gönderiliyor.               *
     ******************************************************************/
    kitap_t *BubbleSort(char *kriter, int sira, liste_t *liste)
    {
        kitap_t *prev, *cur, *next;
        int change, ok = 0;

        /* Dizi boşsa geri dönüyoruz */
        if (liste->son1 == NULL)
            return NULL;

        do
        {
            change = 0; /* değişiklik yapılmayan turda sıralama biter */

            /* işaretçileri ayarlıyoruz */
            prev = NULL;
            cur = ((sira == 1) ? liste->son1->next1 : liste->son2->next2);
            next = ((sira == 1) ? cur->next1 : cur->next2);

            while (next != ((sira == 1) ? liste->son1->next1 : liste->son2->next2) )
            {
                if(!strcmp(kriter, "kadi") && (strcmp( u2l(cur->ad), u2l(next->ad) ) > 0) )
                    ok = 1;
                if(!strcmp(kriter, "kyazar") && (strcmp( u2l(cur->yazar), u2l(next->yazar) ) > 0) )
                    ok = 1;
                if(!strcmp(kriter, "yayinyil") && (strcmp( u2l(cur->yayin_yili), u2l(next->yayin_yili) ) > 0) )
                    ok = 1;
                if(!strcmp(kriter, "oduncver") && (strcmp( u2l(cur->odunc_verilen), u2l(next->odunc_verilen) ) > 0) )
                    ok = 1;
                if(!strcmp(kriter, "odunctar") && (strcmp( u2l(cur->odunc_verilme_tarihi), u2l(next->odunc_verilme_tarihi) ) > 0) )
                    ok = 1;
                if(!strcmp(kriter, "rafno") && (strcmp( u2l(cur->raf_no), u2l(next->raf_no) ) > 0) )
                    ok = 1;

                if (ok)
                {
                    ok = 0;
                    swap(prev, cur, next, sira, liste);
                    change = 1; /* Değişiklik yaptık */
                    prev = next;
                    next = (sira == 1) ? cur->next1 : cur->next2;
                } else {
                    /* işaretçileri ilerlet */
                    prev = cur;
                    cur = next;
                    next = (sira == 1) ? next->next1 : next->next2;
                }
            }
        }while (change);
       
        return (sira == 1) ? liste->son1 : liste->son2;
    }

    /******************************************************************
     * fonksiyon: swap                                                *
     * Listenin elemanlarını yer değiştirmeye yarar                   *
     ******************************************************************/
    void swap(kitap_t *prev, kitap_t *cur, kitap_t *next, int sira, liste_t *liste)
    {
        if(next == ( (sira == 1) ? liste->son1 : liste->son2) )
        { /* Liste sonunda */
            if(prev) /* 2 elemandan fazla */
            {
                ((sira == 1) ? prev->next1 : prev->next2) = next;
                ((sira == 1) ? cur->next1 : cur->next2) = ((sira == 1) ? next->next1 : next->next2);
                ((sira == 1) ? next->next1 : next->next2) = cur;
            }
                ((sira == 1) ? liste->son1 : liste->son2) = cur;
        }else if(cur == ((sira == 1) ? liste->son1->next1 : liste->son2->next2) )
        { /* Liste başında */
            ((sira == 1) ? cur->next1 : cur->next2) = ((sira == 1) ? next->next1 : next->next2);
            ((sira == 1) ? next->next1 : next->next2) = cur;
            ((sira == 1) ? liste->son1->next1 : liste->son2->next2) = next;
        }
        else{ /* Listede ortada */
            ((sira == 1) ? prev->next1 : prev->next2) = next;
            ((sira == 1) ? cur->next1 : cur->next2) = ((sira == 1) ? next->next1 : next->next2);
            ((sira == 1) ? next->next1 : next->next2) = cur;
        }
    }

  7. KısayolKısayol reportŞikayet pmÖzel Mesaj
    aLsanCaK
    aLsanCaK's avatar
    Kayıt Tarihi: 30/Kasım/2007
    Erkek

    Hocalar bunu yazabilecek kimse yokmu yaa biliyom kolay bisey, bu arada benim odevim felan degil yani endise etmeyin .. kuzene lazim hadi gozunuzu seveyim

  8. KısayolKısayol reportŞikayet pmÖzel Mesaj
  9. KısayolKısayol reportŞikayet pmÖzel Mesaj
    JPriest
    JPriest's avatar
    Kayıt Tarihi: 09/Mart/2007
    Erkek

    Balık vermek yerine balık tutmayı öğrenmesini sağlamak daha yararlı olur bence. Kodu verdin adam aldı hocaya verdi dersi geçti. Ee sonra? Benim gibi olur. Bir şey öğrenmeden geçer gider..

  10. KısayolKısayol reportŞikayet pmÖzel Mesaj
    aLsanCaK
    aLsanCaK's avatar
    Kayıt Tarihi: 30/Kasım/2007
    Erkek

    cok tesekur ederim hocam, tek bi yer kalmis, listelerken fiyatlara gore listelemiyor :)

     

     

    Edit : tmmdir hocam artik ihtiyacim yok cok tesekurler..

  11. KısayolKısayol reportŞikayet pmÖzel Mesaj
    alp
    alp's avatar
    Kayıt Tarihi: 28/Ekim/2003
    Erkek

    hoca koskoca adam, ben mi öğretecem kodu direk hocaya teslim etmekle, kodu inceleyip anlayıp öyle teslim etmek arasındaki farkı?

    hem o capon atasözü değil mi? capon musun sen?

Toplam Hit: 1785 Toplam Mesaj: 12