0

I have a very specific problem I am trying to solve. I have an array of structs containing product information. Each struct has the following information.

Supply type product name wholesale price quantity of wholesale retail price retail product quantity

My array of structs is complete and that is fine and dandy. Now, let's say there are a couple of supply types such as:

Meat Dairy Fruit etc...

How would I iterate through the array of structs and print out the value information according to supply type. And I am in need of a general solution. Because of course, there may be many product types.

Anything would help at this point. I am confused on how to do this and would greatly appreciate it if someone could help me out. I'm just not seeing how to do this or I am missing something.

EDITED Well, I changed my strategy a bit I am almost done and have everything working, there is just one minor glitch that I cannnot find. It's probably something fairly easy that I'm overlooking. Here is my updated code. If the supply type from the file is already in the ptr, just update the numerical values, if not make a record and add it to ptr. In my file I have this:

Meat Sirloin 3.55 15 7.30 8 Meat Chicken 2.51 9 5.44 5 Meat Bacon 3.30 23 4.38 10 Fruit Apple .50 40 1.11 20 Fruit Bananna .39 25 .85 16 Dairy Milk 1.00 25 2.25 15 Dairy Milk 1.00 25 2.25 15

It totals correctly for the meat category but anything after that it does not! I keep thinking this has to somehow do with the loop where I check if the supType is already there.

Here is my complete code.

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);
}
Improve this question

3 Answers 3

Reset to default
2

You could pass the supply type as a third parameter to your calculateDisplay function:

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

Obviously, if you want to break down multiple types at once, you'll have to rethink this, but for individual types it should work pretty well.

Note: while it's not a big deal for a homework assignment, you really don't want to use floating point types for currency calculations in real, production software; rounding errors will eventually add up. You'll want to use integral types, and just scale for the smallest unit you need to track (e.g., store 125 cents instead of 1.25 dollars, or 1259 tenths of cents instead of 125.9 cents, etc.). This does limit the range of values you can represent (for a signed 32-bit integer type, roughly +/- $21.4 million if you store in cents, $2.14 million if you store in tenths of cents, etc.), but it has the advantage that all arithmetic will be exact. If you need to store larger values, you'll want to look into some arbitrary-precision library.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Hey John, I edited my code above and thought about my strategy. The idea is to only add a new record if it is not already in the ptr. If it is then just update its numerical values. I am almost there but I can't figure out this one last thing. I would be really appreciate if a fresh pair of eyes could look at this. I've been at it for hours and can't find this last bug.
I think I may have gotten it. I changed the variable alreadySupply = false for initialization, put alreadySupply = true in the check for loop and erased the else. So if it matched a supply type already in the list, once it gets the position it breaks the loop. They KEY fix may have been re-initializing the alreadySupply back to false at the bottom of the while loop!!!
2

Make a function which accepts a product type, loops over the array and only prints if the current items product type matches that passed to it.

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

Comments

1

If the number of supply types is finite, you could do the following. Let's say you have three supply types.

const int NUM_SUPPLY_TYPES = 3;

Define a struct holding the information for a supply type

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

Now you can define mappings from integers to the info and to the string representation:

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

Then in your loop you can do

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

If the number of supply types is not known beforehand, you need a dynamic data structure like a hash table.

Improve this answer

3 Comments

Thank you very much for your answer. I keep wondering if there is a way to do it where you have a separate array called supp types, when the things are read from the file you check the supp type. If it is already in the array don't add it, if not add it. Of course this would probably require realloc....
@Tastybrownies If the possible supp types are not known beforehand, I would simply add a suppType field to the info struct instead of having the separate suppTypeName array. Then for every product you would check if there is already an info with the same supp type. If yes add to that, otherwise allocate a new one. Of course the info array would need to be reallocated every time. As long as the number of supp types is small (let's say < 100) that won't be a performance problem. For bigger numbers you could use a map/hash table/dictionary from supp types to infos.
Yeah, I definitely get what you're saying. If this were a real grocery store, you might know all the supply types. But perhaps not, who knows.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.