我如何在同一个.dat文件中保存并读取整数然后读取结构数组？

时间：2018-03-31 15:27:28

标签： c

基本上，我有一个计数器，我需要保存并作为整数读取，作为数据文件中的第一件事，而在同一数据文件中保存结构数组。我不想发布我的整个代码，因为它有点太长了，但下面是我迄今为止编写的函数。 

void write(InventoryItemType *writefile[], int count)
{
    int i;
    FILE *ptr;
    ptr=fopen("inventory.dat","wb");
    if(ptr==NULL)
    {
        printf("Unable to Open File\n");
        system("pause");
        return;
    }
    putw(count, ptr);
    for(i=0;i < count; i++)
    {
        fwrite(&writefile[i], sizeof writefile, 1, ptr);
    }
    fclose(ptr);
}
InventoryItemType *read(InventoryItemType *readfile[])
{
    int i, count;
    FILE *ptr;
    ptr=fopen("inventory.dat","wb");
    if(!ptr)
    {
        printf("Unable to Open File\n");
        system("pause");
        return;
    }
    count=getcount();
    for(i=0;i < count; i++)
    {
        fread(&readfile[i], sizeof readfile, 1, ptr);
    }
    fclose(ptr);
    return *readfile;
}
int getcount(void)
{
    int i;
    FILE *ptr;
    ptr=fopen("inventory.dat","wb");
    if(ptr<=0)
    {
        i=0;
        return i;
    }
    i=getw(ptr);
    fclose(ptr);
    return i;
}

我像这样调用主块中的函数：

在文件阅读代码的顶部：

int i=0, item_count=getcount();
char selection, code[4];
InventoryItemType *inventoryItems[MAX_INVENTORY_SIZE];
*inventoryItems=read(inventoryItems);

在退出声明中如此：

write(inventoryItems, item_count);
break;

我对这个概念比较陌生，所以任何帮助都会受到赞赏。

memmory allocation edit：

InventoryItemType *addItem(void)
{
    InventoryItemType *current = (InventoryItemType*) malloc (sizeof *current);
    system("cls");
    if(current == NULL)
        return NULL;
    ....
    system("cls");
    return current;
}
编辑＃2：我尽力实施你的建议。目前，我的计数值为-1。这是更新的代码：

调用阅读函数：

int i=0, item_count=getcount();
char selection, code[4];
InventoryItemType *inventoryItems[MAX_INVENTORY_SIZE];
reader(inventoryItems);

Calling Function for writing:

case 'A' :
    writer(inventoryItems, item_count);
    break;

阅读功能：

void reader(InventoryItemType *readfile[])
{
    int i, count;
    FILE *ptr;
    ptr=fopen("inventory.dat","rb");
    if(!ptr)
    {
        printf("Unable to Open File\n");
        system("pause");
        return;
    }
    count=getcount();
    for(i=0;i < count; i++)
    {
        fread(&readfile[i], sizeof (InventoryItemType), 1, ptr);
    }
    fclose(ptr);
    return; 
}
int getcount(void)
{
    int i;
    FILE *ptr;
    ptr=fopen("inventory.dat","rb");
    if(ptr==NULL)
    {
        i=0;
        return i;
    }
    i=getw(ptr);
    return i;
}

写作函数：

void writer(InventoryItemType *writefile[], int count)
{
    int i;
    FILE *ptr;
    ptr=fopen("inventory.dat","wb");
    if(ptr==NULL)
    {
        printf("Unable to Open File\n");
        system("pause");
        return;
    }
    putw(count, ptr);
    for(i=0;i < count; i++)
    {
        fwrite(&writefile[i], sizeof (InventoryItemType), 1, ptr);
    }
}

编辑＃3：整个代码只是...... Q_Q中的沮丧设置

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_INVENTORY_SIZE 100

typedef struct {
    char item_Number[4];
    char item_Name[20];
    float item_Profit;
    float latest_Price;
    float selling_Price;
    unsigned int stock;
    unsigned int total_Sold;
}InventoryItemType;

void MainMenu();
void displayInventory(InventoryItemType *[], int);
void displaySales(InventoryItemType *[], int);
InventoryItemType *addItem(void);
InventoryItemType *deleteItem(InventoryItemType *[], int);
InventoryItemType *newShipment(InventoryItemType *[], int);
InventoryItemType *updateSales(InventoryItemType *[], int);
InventoryItemType *bubbleSort(InventoryItemType *[], int, char);
void swap(InventoryItemType *[], InventoryItemType *[]);
void writer(const char *,InventoryItemType *[], size_t );
void reader(const char *,InventoryItemType *[], size_t );

int main()
{
    int i=0, item_count=0;
    char selection, code[4];
    const char file[]={"inventory.dat"};
    InventoryItemType *inventoryItems[MAX_INVENTORY_SIZE];
    reader(file,inventoryItems,item_count);
    while(1)
    {
        MainMenu();

        scanf(" %c", &selection);
        switch(selection) 
        {
        case 'A' :
            displayInventory(inventoryItems, item_count);
            system("pause");
            system("cls");
            continue;
        case 'B' :
            displaySales(inventoryItems, item_count);
            system("pause");
            system("cls");
            continue;
        case 'C' :
            if(item_count == MAX_INVENTORY_SIZE - 1)
            {
                printf("Array is full\n");
                system("pause");
                continue;
            }
            inventoryItems[item_count] = addItem();
            item_count++;
            continue;
        case 'D' :
            *inventoryItems=deleteItem(inventoryItems, item_count);
            item_count--;
            continue;
        case 'E' :
            *inventoryItems=newShipment(inventoryItems, item_count);
            continue;
        case 'F' :
            *inventoryItems=updateSales(inventoryItems, item_count);
            continue;
        case 'G' :
            while(1)
            {
                system("cls");
                printf("A. Sort by Name\n");
                printf("B. Sort by Item Number\n");
                scanf(" %c", &selection);
                switch(selection)
                {
                case 'A' :
                    *inventoryItems=bubbleSort(inventoryItems, item_count, selection);
                    break;
                case 'B' :
                    *inventoryItems=bubbleSort(inventoryItems, item_count, selection);
                    break;
                default:
                    {
                        printf("Invalid Input!\n");
                        system("pause");
                        continue;
                    }
                }
                break;
            }
            continue;
        case 'H' :
            while(1)
            {
                printf("Would you like to save your changed?\n");
                printf("A. Yes\n");
                printf("B. No\n");
                scanf(" %C", &selection);
                switch(selection)
                {
                case 'A' :
                    writer(file,inventoryItems,item_count);
                    break;
                case 'B' :

                    break;
                default:
                    {
                        printf("Invalid Input!\n");
                        system("pause");
                        continue;
                    }
                }
                break;
            }
            continue;
        default :
            printf("Invalid Entry\n" );
            system("pause");
        }
    }
}
void MainMenu()
{
    system("cls");
    printf("A. Display Inventory\n");
    printf("B. Display Sales\n");
    printf("C. Add Item\n");
    printf("D. Remove Item\n");
    printf("E. Enter Shipment\n");
    printf("F. Update Sales\n");
    printf("G. Sort\n");
    printf("H. Exit\n");
    printf("Make a selection\n");
}
void displayInventory(InventoryItemType *display[], int key)
{
    system("cls");
    {
        int i;
        for(i=0; i<key; i++)
        {
            printf("Item No.:%s\n", display[i]->item_Number);
            printf("Item Name:%s\n", display[i]->item_Name);
            printf("Item Stock:%d\n",display[i]->stock);
            printf("Item Purchased Price:%.2f\n", display[i]->latest_Price);
            printf("Total Value of Items:%.2f\n", (display[i]->stock)*(display[i]->latest_Price));
            printf("\n");
        }
    }
}
void displaySales(InventoryItemType *display[], int key)
{
    int i;
    float total_profit=0;
    system("cls");
    for(i=0; i<key; i++)
    {
        printf("Item No.:%s\n", display[i]->item_Number);
        printf("Item Name:%s\n", display[i]->item_Name);
        printf("Number of Item Sold:%d\n", display[i]->total_Sold);
        printf("Item Selling Price:%.2f\n", display[i]->selling_Price);
        printf("Total Profit from Item:%.2f\n", (display[i]->selling_Price-display[i]->latest_Price)*display[i]->total_Sold);
        total_profit=total_profit+((display[i]->selling_Price-display[i]->latest_Price)*display[i]->total_Sold);
        if(i==key-1)
            printf("\nTotal Over-all Profit:%.2f", total_profit);
        printf("\n\n");
    }
}
InventoryItemType *addItem(void)
{
    InventoryItemType *current = (InventoryItemType*) malloc (sizeof *current);
    system("cls");
    if(current == NULL)
        return NULL;
    printf("\nEnter details of item \n\n");
    printf("Enter Item no: \n");
    scanf("%s", current->item_Number);
    printf("Enter Item Name: \n");
    scanf("%s", current->item_Name);
    printf("Enter Stock: \n");
    scanf("%d", &current->stock);
    printf("Enter Purchase Price: \n");
    scanf("%f", &current->latest_Price);
    current->selling_Price=(current->latest_Price)*1.5;
    current->total_Sold=0;
    system("cls");
    return current;
}
InventoryItemType *deleteItem (InventoryItemType *deleted[], int item_count)
{
    char code[4];
    int i;
    system("cls");
    displayInventory(deleted,item_count);
    printf("Enter Item Number to be Deleted\n");
    scanf("%3s", code);
    for(i=0;i<item_count;i++)
    {
        if(strcmp(code,deleted[i]->item_Number)==0)
            break;
    }
    free(deleted[i]);
    for(;i<item_count; i++)
        deleted[i]=deleted[i+1];
    return *deleted;
}
InventoryItemType *newShipment (InventoryItemType *shipment[], int item_count)
{
    char code[4];
    int i, add;
    float newprice;
    while(1)
    {
        system("cls");
        displayInventory(shipment, item_count);
        printf("\nEnter Item Number to Update Stock\n");
        scanf("%3s", code);
        for(i=0;i<item_count;i++)
        {
            if(strcmp(code,shipment[i]->item_Number)==0)
            {
                printf("Enter the Quantity of Item being added\n");
                scanf("%d", &add);
                printf("Enter the Purchase Price of the Item\n");
                scanf("%f", &newprice);
                shipment[i]->stock=shipment[i]->stock+add;
                shipment[i]->latest_Price=newprice;
                shipment[i]->selling_Price=shipment[i]->latest_Price*1.5;
                displayInventory(shipment, item_count);
                return *shipment;   
            }
        }
        printf("Invalid Item Number, Please Try Again\n");
        system("Pause");
        continue;
    }
}
InventoryItemType *updateSales (InventoryItemType *sale[], int item_count)
{
    char code[4], choice;
    int i, sold;
    while(1)
    {
        system("cls");
        displayInventory(sale, item_count);
        printf("\nEnter Item Number to Update Stock and Profits\n");
        scanf("%3s", code);
        for(i=0;i<item_count;i++)
        {
            if(strcmp(code,sale[i]->item_Number)==0)
            {
                printf("Enter the Quantity of Item Sold\n");
                scanf("%d", &sold);
                if(sale[i]->stock>sold)
                {
                    sale[i]->stock=sale[i]->stock-sold;
                    sale[i]->item_Profit=sale[i]->selling_Price*sold;
                    displayInventory(sale, item_count);
                    system("pause");
                    return *sale;
                }
                else
                {
                    printf("Invalid Input!\nThere can not be more sold than in stock!\nWould you like to try again?\n");
                    printf("A. Yes\n");
                    printf("B. No\n");
                    scanf(" %c", &choice);
                    switch(choice)
                    {
                    case 'A' :
                        system("cls");
                        displayInventory(sale, item_count);
                        continue;
                    case 'B' :
                        return *sale;
                    }
                }
            }
            else
            {
                printf("Invalid Item Number, Please Try Again\n");
                system("Pause");
            }
        }
    }
}
void swap(InventoryItemType *a[], InventoryItemType *b[])
{
    InventoryItemType *temp=*a;
    *a=*b;
    *b=temp;
}
InventoryItemType *bubbleSort(InventoryItemType *sorting[], int item_count, char swaptype)
{
    int i, sorted;
    system("cls");
    if(swaptype=='A')
    {
        do{
            sorted=1;
            for (i = 0; i < item_count - 1; i++) 
            {
                if (strcmp(sorting[i]->item_Name,sorting[i + 1]->item_Name)==1) 
                {
                    swap(&sorting[i],&sorting[i + 1]);
                    sorted = 0;
                }
            }
        }while(!sorted);
    }
    else
    {
        do{
            sorted=1;
            for (i = 0; i < item_count - 1; i++) 
            {
                if (strcmp(sorting[i]->item_Number,sorting[i + 1]->item_Number)==1) 
                {
                    swap(&sorting[i],&sorting[i + 1]);
                    sorted = 0;
                }
            }
        }while(!sorted);
    }
    printf("Your Inventory is Sorted!\n\n");
    system("pause");
    return *sorting;
}
void writer(const char *fname,const InventoryItemType *saveinventory , size_t count)
{
    FILE *ptr = fopen(fname, "wb");
    if(ptr == NULL)
    {
        fclose(ptr);
        printf("Unable to Open File\n");
        system("pause");
        return;
    }
    if (fwrite(&count, sizeof(count), 1, ptr)!= 1) 
    {
        fclose(ptr);
        printf("Write count failed\n");
        system("pause");
        return;
    }
    if (fwrite(saveinventory, sizeof (*saveinventory), count, ptr)!= count)
    {
        fclose(ptr);
        printf("Write inventory failed\n");
        system("pause");
    }
}
void reader(const char *fname,InventoryItemType **inventory_ptr, size_t *count_ptr)
{
    InventoryItemType *inventory;
    size_t count;   
    FILE *ptr = fopen(fname, "rb");
    if(ptr == NULL) {
        printf("Unable to Open File\n");
        system("pause");
        return;
    }

    if (fread(&count, sizeof count, 1, ptr)!= 1) {
        fclose(ptr);
        printf("Read count failed\n");
        system("pause");
        return;
    }

    inventory = (InventoryItemType *)malloc(sizeof *inventory * count);
    if (inventory == NULL && count > 0) {
        fclose(ptr);
        printf("Allocation failed\n");
        system("pause");
        return;
    }

    if (fread(inventory, sizeof *inventory, count, ptr)!= count) {
        fclose(ptr);
        free(inventory);
        printf("Read inventory failed\n");
        system("pause");
        return;
    }

    fclose(ptr);
    *inventory_ptr = inventory;
    *count_ptr = count;
    return;
}

2 个答案:

答案 0 :(得分：0)

您的代码中存在许多问题：

InventoryItemType *inventoryItems[MAX_INVENTORY_SIZE];
*inventoryItems=read(inventoryItems);

您声明一个指向项目的指针数组，然后您阅读这些项目。但是在阅读项目的代码中，我没有看到你为这些项目分配内存。然后，当函数返回时，将返回的结果分配给*inventoryItems，即取消引用数组，从而得到它的第一个元素。这似乎是无稽之谈，你编译器应该抱怨。除了成功/失败之外，不要从函数中返回任何东西。

请注意read是标准库中函数的名称。使用其他名称。也适用于write。

当你打开文件时，指定"wb"但这意味着你打开写的文件。那应该是"rb"（读二进制）。

在read函数中，您读取sizeof readfile个字节。但readfile是指针数组的指针。所以sizeof readfile将是指针的大小。您应该使用sizeof *readfile[i]或sizeof(InventoryItemType)。

但在你读readfile[i]之前，你应该为它分配内存！请注意readfile[i]已经是指针，因此您不需要&和fread中的fwrite运算符。

作为它应该是什么的一个例子，我提供了read函数：

int myread(InventoryItemType *readfile)
{
    int i, count;
    FILE *ptr;
    ptr=fopen("inventory.dat","rb");   // "rb" = Read Binary
    if(!ptr)
    {
        printf("Unable to Open File\n");
        system("pause");
        return 0;
    }
    count=getcount();
    for(i=0;i < count; i++)
    {
        readfile[i]= malloc(sizeof(InventoryItemType));
        fread(readfile[i], sizeof(InventoryItemType), 1, ptr);
    }
    fclose(ptr);
    return 1;
}

..并打开编译器的警告！

答案 1 :(得分：0)

  

如何在同一个.dat文件中保存并读取整数然后读取结构数组？

我建议改变架构。而不是

// void write(InventoryItemType *writefile[], int count)
// InventoryItemType *read(InventoryItemType *readfile[])

考虑

// return 0 on success
int iwrite(const char *fname, const InventoryItemType *inventory, size_t count)
int iread(const char *fname, InventoryItemType **inventory, size_t *count)

我发现OP的方法太纠结了。

要编写，请打开文件，写入计数和数据。回想一下，库存仍然是分配的，最终需要被释放。

int iwrite(const char *fname, const InventoryItemType *inventory, size_t count) {
  FILE *ptr = fopen(fname, "wb");
  if(ptr == NULL) {
    // printf("Unable to Open File\n");
    return 1;
  }

  if (fwrite(&count, sizeof count, 1, ptr)!= 1) {
    fclose(ptr);
    // printf("Write count failed\n");
    return 2;
  }

  if (fwrite(inventory, sizeof *inventory, count, ptr)!= count) {
    fclose(ptr);
    // printf("Write inventory failed\n");
    return 3;
  }

  fclose(ptr);
  return 0;
}

要编写，打开文件，读取计数，为库存分配内存，然后阅读库存。

int iread(const char *fname, InventoryItemType **inventory_ptr, size_t *count_ptr) {
  FILE *ptr = fopen(fname, "rb"); // read mode
  if(ptr == NULL) {
    // printf("Unable to Open File\n");
    return 1;
  }

  size_t count;
  if (fread(&count, sizeof count, 1, ptr)!= 1) {
    fclose(ptr);
    // printf("Read count failed\n");
    return 2;
  }

  InventoryItemType *inventory = malloc(sizeof *inventory * count);
  if (inventory == NULL && count > 0) {
    fclose(ptr);
    // printf("allocation failed\n");
    return 3;
  }

  if (fread(inventory, sizeof *inventory, count, ptr)!= count) {
    fclose(ptr);
    free(inventory);
    // printf("Read inventory failed\n");
    return 3;
  }

  fclose(ptr);
  *inventory_ptr = inventory;
  *count_ptr = count;
  return 0;
}
相关问题
最新问题