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

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 :)

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.

/**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;
}

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;

}

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;
    }
}

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

www.alpworks.net/kitap.exe

www.alpworks.net/kitap.c

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..

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

Edit : tmmdir hocam artik ihtiyacim yok cok tesekurler..

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?