Question

我有一个非常具体的问题，我试图解决。我有一系列包含产品信息的结构。每个结构都有以下信息。

供应类型产品名称批发价批发数量零售价零售产品数量

我的结构数组是完整的，这很好，花花公子。现在，让我们说有几种供应类型，例如：

肉乳业水果等...

如何迭代结构数组并根据供应类型打印出值信息。我需要一个通用的解决方案。因为当然可能有很多产品类型。

此时任何事情都会有所帮助。我很困惑如何做到这一点，如果有人能帮助我，我会非常感激。我只是没有看到如何做到这一点，或者我错过了一些东西。

EDITED 好吧，我改变了我的策略，我差不多完成了所有事情工作，只有一个小故障，我找不到。它的可能是我很容易忽视的东西。这是我的更新的代码。如果文件中的供应类型已经在ptr中，只需更新数值，如果没有记录并添加到 PTR。在我的文件中，我有这个：

肉沙朗3.55 15 7.30 8 肉鸡2.51 9 5.44 5 肉培根3.30 23 4.38 10 Fruit Apple .50 40 1.11 20 Fruit Bananna .39 25 .85 16 乳制品1.00 25 2.25 15 乳制品1.00 25 2.25 15

对于肉类而言它总计正确，但之后的任何事情都没有！我一直认为这必须以某种方式处理循环，我检查supType是否已经存在。

这是我的完整代码。

void calculateDisplay(pointerDynam, sizeA);
void cleanUp();

typedef struct
{
    char supType[15];
    char prodName[15];
    double wholePrice;
    int quantWhole;
    double retPrice;
    int retProdQuantity;
} PRODUCT;

FILE *fr;
int main()
{
    char supplyName[15];
    char productName[15];
    double wholeP = 0;
    int  quantityWhole = 0;
    double retailPrice = 0;
    int retailProductQuant = 0;

    //keep track of supply types.

    PRODUCT *ptr;

    ptr = malloc(sizeof(PRODUCT));

    PRODUCT *temp;

    //int num =0;
    int i = 1;
    int num = 0;
    int a;
    int countTrack = 0;
    bool alreadySupply = true;
    int needsChanged = 0;

    fr = fopen("ttt.txt", "r");

    while(fscanf(fr, "%s %s %lf %d %lf %d", supplyName, productName, &wholeP, &quantityWhole, &retailPrice, &retailProductQuant)==6)
    {
        if(num != 0)
        {
            for(a=0; a < num; a++)
            {
                if(strcmp(ptr[a].supType, supplyName) == 0)
                {
                    needsChanged = a;
                }
                else
                {
                    alreadySupply = false;
                }
            }
        }

        if(num == 0 || alreadySupply == false)
        {
            PRODUCT record;
            strcpy(record.supType, supplyName);
            strcpy(record.prodName, productName);
            record.wholePrice = wholeP;
            record.quantWhole = quantityWhole;
            record.retPrice = retailPrice;
            record.retProdQuantity = retailProductQuant;

            ptr[num] = record;
            countTrack++;
            num++;
            i++;
            temp = realloc(ptr, i*sizeof(PRODUCT));
            ptr = temp;
        }
        else
        {
            ptr[needsChanged].quantWhole += quantityWhole;
            ptr[needsChanged].retPrice += retailPrice;
            ptr[needsChanged].retProdQuantity += retailProductQuant;
            ptr[needsChanged].wholePrice += wholeP;
        }
    }

    calculateDisplay(ptr, num);
    cleanUp();

    return 0;
}



void calculateDisplay(PRODUCT *pointerDynam, int sizeA)
{
    int j;
    double totownerCost = 0;
    double totcustCost = 0;
    double totprofit = 0;

    double supownerCost = 0;
    double supcustCost = 0;
    double suprofit = 0;

    for(j=0; j<sizeA; j++)
    {
        supownerCost = pointerDynam[j].wholePrice;
        supcustCost = pointerDynam[j].retPrice;
        suprofit = pointerDynam[j].retPrice - pointerDynam[j].wholePrice;

        printf("Supply Type: %s\n Wholesale Price: %.2f\n Retail Price: %.2f\n Profit: %.2f\n\n\n",
                 pointerDynam[j].supType, supownerCost, supcustCost, suprofit);
        totownerCost += pointerDynam[j].wholePrice;
        totcustCost += pointerDynam[j].retPrice;
        totprofit += pointerDynam[j].retPrice - pointerDynam[j].wholePrice;
    }

    printf("Wholesale Cost is: %.2f\n Retail is: %.2f\n Profit made was: %.2f\n\n", totownerCost, totcustCost, totprofit);
}

void cleanUp()
{
    fclose(fr);
}

Answer 1

创建一个接受产品类型的函数，在数组上循环，只有在当前项目产品类型与传递给它的产品类型相匹配时才会打印。

  void printProductInfo(char* productType, PRODUCT* products)
  {
        for (int i = 0; i < productsLength; i++)
        {
              if (strcmp(productType, products[i]->supType)
                  // call print method
        }
  }

Answer 2

您可以将供应类型作为第三个参数传递给calculateDisplay函数：

 void calculateDisplay(PRODUCT *pointerDynam, int sizeA, const char *supplyType)
 {
    ...
    double typeCost = 0;
    double typeCust = 0;
    double typeProfit = 0;
    ...
    if(strcmp(pointerDynam[j].supType, supplyType)==0)
        {
            typeCost += pointerDynam[j].wholePrice;
            typeCust +=  pointerDynam[j].retPrice;
            typeProfit += pointerDynam[j].retPrice - pointerDynam[j].wholePrice;
        }
        ...

   printf("%s wholesale: %.2f\n %s retail %.2f\n %s profit: %.2f\n\n\n", 
      supplyType, typeCost, supplyType, meatCust, supplyType, typeProfit);

显然，如果你想一次分解多种类型，你必须重新考虑这个，但对于个别类型，它应该可以很好地工作。

注意：虽然对于家庭作业来说这不是什么大不了的事，但真的不希望在真实的生产软件中使用浮点类型进行货币计算;舍入错误最终会加起来。您将需要使用整数类型，并且只需缩放您需要跟踪的最小单位（例如，存储125美分而不是1.25美元，或1259十分之一美分而不是125.9美分等）。这确实限制了您可以表示的值的范围（对于带符号的32位整数类型，如果以美分存储则大约为+/- 2140万美元，如果以十分之一美分存储则为214万美元等），但它具有所有算术都精确的优点。如果需要存储更大的值，则需要查看一些任意精度的库。

Answer 3

如果供应类型的数量有限，您可以执行以下操作。假设您有三种供应类型。

const int NUM_SUPPLY_TYPES = 3;

定义一个包含供应类型信息的结构

struct SupplyTypeInfo
{
    double ownerCost;
    double custCost;
    double profitMargin;
};

现在您可以定义从整数到信息和字符串表示的映射：

SupplyTypeInfo supplyTypeInfo[NUM_SUPPLY_TYPES];
char *supplyTypeName[] = { "Meat", "Fruit", "Dairy" }

然后在你的循环中你可以做

for (int stNum = 0; stNum < NUM_SUPPLY_TYPES; ++stNum)
{
    if(strcmp(pointerDynam[j].supType, supplyTypeName[stNum])==0)
    {
        supplyTypeInfo[stNum].ownerCost += pointerDynam[j].wholePrice;
        supplyTypeInfo[stNum].custCost +=  pointerDynam[j].retPrice;
        supplyTypeInfo[stNum].profitMargin += pointerDynam[j].retPrice - pointerDynam[j].wholePrice;
    }
}

如果事先不知道供应类型的数量，则需要动态数据结构，如散列表。

迭代一系列结构

3 个答案: