用于构造和复制内容的指针的函数，无需memcpy

Question

I'm trying to make a function that points to a single inventory structure(one record) and copies its content to an element in the gobal array defined in inventory.c. I would like to copy them member by member and return an integer -1 if the copies fails. In my main fuctionm, I would like to iterate through my sample data and call the invSetRecord function for each element in the sampleData Array. I'm lost on what to do and need some help on this. I updated my inventory.c file. Im confused on my function. I was compiling it by itself. I dont understand how to get the productName to copy. Any suggestions? Also I'm having a hard time set up the counter for the inventory records.

Here's my instructions from my teacher,

Use the petstore files created for Lab 9 (Part 2) to complete this assignment.

Copy the following sample data into the petstore_main.c file:

# define SAMPLE_SZ 5

struct inventory_s sampleData[SAMPLE_SZ] = {
    { 1000, 1.49, 3.79, 10, 0, "Fish Food" },
    { 2000, 0.29, 1.59, 100, 1, "Angelfish" },
    { 2001, 0.09, 0.79, 200, 1, "Guppy" },
    { 5000, 2.40, 5.95, 10, 0, "Dog Collar, Large" },
    { 6000, 49.99, 129.99, 3, 1, "Dalmation Puppy" }
};

Define a function in the inventory.c file which has the following prototype (put the prototype in the inventory.h file)

int invSetRecord(struct inventory_s *ipx);

This function will take a pointer to a single inventory structure (a record) and copy its contents to an element in the global array defined in inventory.c . The target location (global array element) will be determined by the current size of the array, if the array is empty then the record is copied into element 0, if the current size is 1 it will be copied into element 1, etc. This means you need to define a global counter in inventory.c which tracks the number of elements in the array. In the invSetRecord function you will need to copy the structure member by member using a method appropriate to the type, eg simple assignment for the primitive data types, and strcpy() for the string data type. The function returns an integer value: if the copy operation fails (eg the global inventory array is full), the function returns -1, otherwise it returns 0.

In your main function in petstore_main.c , you will need to create a loop which iterates through the sample data and calls invSetRecord for each element in the sampleData array. For each call to invSetRecord you need to check the return value of the function and print an error if the operation failed or succeeded, and the corresponding record number. For instance, if the operation succeeds for all 5 sample data records, this is the output printed from your main function:

record #1 set successfully
record #2 set successfully
record #3 set successfully
record #4 set successfully
record #5 set successfully

If a call to invSetRecord fails (the function returns -1), the following message is printed:

error: could not set record 1

If an error occurs, you must break out of the loop at that point.

here's what i got so far I need some help. I been pulling my hair out all week trying to figure this one out. Thanks in advance for any help.

//inventory.c    
#include <stdio.h>

#include "inventory.h"
int i;
#define invSetRecord main

struct inventory_s inventory[MAX_INVENTORY];
int i;

int invSetRecord(struct inventory_s *ipx)
{

    int result;
    i = sizeof(MAX_INVENTORY)/sizeof(inventory[0]);

    if (i > MAX_INVENTORY)
    {
    result = -1;
    printf("%i", i);
    }
    if (i < MAX_INVENTORY)
    {
        result = 0;
        printf("%i", i);
        inventory[i].productNumber = ipx->productNumber;
        inventory[i].mfrPrice = ipx->mfrPrice;
        inventory[i].retailPrice = ipx->retailPrice;
        inventory[i].numInStock = ipx->numInStock;
        inventory[i].liveInv = ipx->liveInv;
        //inventory[i].productName= (ipx->productName);


        i++;
    }
    return result;



}

heres my inventory.h file...

#ifndef _INVENTORY_H_ //ensures that inventory.h does not run more than once
#define _INVENTORY_H_

#define  PRODUCTNAME_SZ 20
#define MAX_INVENTORY 50


struct inventory_s
{
    int productNumber;
    float mfrPrice;
    float retailPrice;
    int numInStock;
    char liveInv;
    char productName[PRODUCTNAME_SZ];
};

int invSetRecord(struct inventory_s *ipx);

#endif //_INVENTORY_H_

heres my main() file...

//main.c
#include <stdio.h>
#include <stdlib.h>

#include "inventory.h"

#define SAMPLE_SZ 5

extern struct inventory_s inventory[MAX_INVENTORY]; 

struct inventory_s sampleData[SAMPLE_SZ]={

    { 1000, 1.49, 3.79, 10, 0, "Fish Food" },
    { 2000, 0.29, 1.59, 100, 1, "Angelfish" },
    { 2001, 0.09, 0.79, 200, 1, "Guppy" },
    { 5000, 2.40, 5.95, 10, 0, "Dog Collar, Large" },
    { 6000, 49.99, 129.99, 3, 1, "Dalmation Puppy"}
};

int main()
{
    int i;

    for(i = 0; i < SAMPLE_SZ; i++);
    invSetRecord(sampleData);

    printf("The product number is %i for sampleData element[]", sampleData[0].productNumber);
    return 0;
}

Answer 1

Let's start with the simple issues where your compiler is throwing errors and warnings:

#include "inventory.h"
int i;
#define invSetRecord main

struct inventory_s inventory[MAX_INVENTORY];
int i;

How many times do you need to declare i ? There is no reason for #define invSetRecord main . As a note, when declaring a global, a more distinctive name than the very common i is advisable.

In invSetRecord , (using idx (index) for your i ), why not simply do:

/* inventory.c */
#include <stdio.h>
#include <string.h>

#include "inventory.h"

int idx;

struct inventory_s inventory[MAX_INVENTORY];

int invSetRecord (struct inventory_s *ipx)
{
    if (idx == MAX_INVENTORY) return -1;

    inventory[idx].productNumber = ipx->productNumber;
    inventory[idx].mfrPrice      = ipx->mfrPrice;
    inventory[idx].retailPrice   = ipx->retailPrice;
    inventory[idx].numInStock    = ipx->numInStock;
    inventory[idx].liveInv       = ipx->liveInv;
    strcpy (inventory[idx].productName, ipx->productName);
    idx++;

    return 0;
}

Note, your compiler will be telling you you cannot simply assign ipx->productName to inventory[idx].productName since it is a character array (well char * after conversion). You must use strcpy (or strncpy ) or simply iterate over (ipx->productName)[] until the nul-terminating character is reached copying char-by-char to inventory[idx].productName[] .

The following makes no sense at all:

    i = sizeof(MAX_INVENTORY)/sizeof(inventory[0]);

(you can only get the number of elements in an array ( not pointer ) in the scope where the array is declared by using sizeof array/sizeof array[0] . What you have above has no resemblance to the proper use.)

The remainder of your inventory.h seems fine. However the first line does NOT //ensures that inventory.h does not run more than once it insures that the header file inventory.h is not included more than once.

Your main() is -- creative... to say the least. What you are trying to accomplish is passing the address of sampleData[i] (eg &sampleData[i] ) to invSetRecord (eg a pointer to the struct, not the struct itself).

Further, what happens with this code?

    for(i = 0; i < SAMPLE_SZ; i++);

answer : nothing. i simply changes value from 0 - SAMPLE_SZ without effecting any other code. Why? The ; following the loop is the same as:

    for(i = 0; i < SAMPLE_SZ; i++) {}

eg -- an empty block. Remove the ; for the loop to operate on the following line.

It is unclear what you are trying to print at the end. Presuming you want the productNumber for every element, you could do something like the following:

#include <stdio.h>
#include <stdlib.h>

#include "inventory.h"

#define SAMPLE_SZ 5

extern struct inventory_s inventory[MAX_INVENTORY]; 

struct inventory_s sampleData[] = {
    { 1000, 1.49, 3.79, 10, 0, "Fish Food" },
    { 2000, 0.29, 1.59, 100, 1, "Angelfish" },
    { 2001, 0.09, 0.79, 200, 1, "Guppy" },
    { 5000, 2.40, 5.95, 10, 0, "Dog Collar, Large" },
    { 6000, 49.99, 129.99, 3, 1, "Dalmation Puppy" }
};

int main (void)
{
    int i;

    for (i = 0; i < SAMPLE_SZ; i++)
        if (invSetRecord (&sampleData[i]) == 0)
            printf ("record #%d set successfully.\n", i);
        else {
            fprintf (stderr, "error: could not set record %d.\n", i);
            break;
        }
    putchar ('\n');     /* tidy up output formatting */

    for (i = 0; i < SAMPLE_SZ; i++)
        printf ("sampleData[%2d] : %d\n", i, sampleData[i].productNumber);

    return 0;
}

Putting it altogether, compiling and running the code will produce the following:

$ ./bin/main
record #0 set successfully.
record #1 set successfully.
record #2 set successfully.
record #3 set successfully.
record #4 set successfully.

sampleData[ 0] : 1000
sampleData[ 1] : 2000
sampleData[ 2] : 2001
sampleData[ 3] : 5000
sampleData[ 4] : 6000

Look it all over and let me know if you have any questions. Just slow down and think through each line of the code. Also, if you are having difficulty with the code split between three different source files, you may want to simply use a single source file for initial development, then separate into the individual files when it all makes sense. That way, you eliminate all but just the code issues initially.

---

Notes about using the IDE

For sake of completeness, your inventory.h could be left pretty much as you have it. I made few changes (other than personal preference, eg #define _INVENTORY_H_ 1 to actually define a value for _INVENTORY_H_ rather than letting it default). I used the following:

#ifndef _INVENTORY_H_
#define _INVENTORY_H_ 1

#define PRODUCTNAME_SZ 20
#define MAX_INVENTORY 50

struct inventory_s {
    int productNumber;
    float mfrPrice;
    float retailPrice;
    int numInStock;
    char liveInv;
    char productName[PRODUCTNAME_SZ];
};

int invSetRecord (struct inventory_s *ipx);

#endif

As noted in the comments, I simply compiled and built the project with a single call to gcc from the command line. Specifically I used:

$ gcc -Wall -Wextra -pedantic -std=gnu11 -Ofast inventory.c -o main main.c

The basic, minimum compile string required is:

$ gcc inventory.c -o main main.c

Which just says compile main.c , -o main outputting the resulting executable in a file named main (it can be whatever you want, bananas for that matter) and finally inventory.c which is what tells the compiler that in addition to main.c it must compile and link the code in inventory.c in order to produce a working executable. You run the code from the command line with:

$ ./main     (or ./bananas if you went that route)

The remaining options just enable all compiler warnings (so you can fix them before considering your code reliable), -Ofast enable all compiler optimizations (not that critical here), and sets the language standard to C11 with gnu extensions. I'll explain a bit further below.

-Wall -Wextra -pedantic simply enable all compiler warnings . (use at minimum -Wall -Wextra with every project and fix all warnings before you consider your code reliable) For Codeblocks look in Project->Build options...->Compiler Flags (then check the box for Enable all common compiler warnings ... [-Wall] , and the next box for -Wextra ) You can also check the -pedantic option, but that adds another layer of subtle warnings that get a bit down in the weeds for initial learning.

The -std=gnu11 just tells the compiler to build with C11 (and the gnu extensions ). You can omit this flag and build to C89 by default. (which is fine)

The -Ofast just enables all compiler optimizations. The -Ofast optimization is available for gcc 4.6 and above, otherwise they are just -O0 (that's Oh zero ) meaning no optimization. The -O1 or -O2 and -O3 levels just allow the compiler to make increasingly aggressive optimization to speed the code up -- like eliminating dead code, optimizing loops, etc)

For your Debug builds, you will generally not enable -Ofast optimization, but on Linux, include -g instead to generate debugging symbols for use with the gdb debugger. (I think Codeblocks does this for you automatically)

If you want to piecemeal compile to inventory.c to an object file first and then link the object file with main.c to make the invSetRecord function available to main , you could do:

$ gcc -Wall -Wextra -c -o inventory.obj inventory.c

Which does just that, compile inventory.c to the object file inventory.obj . Finally, you would just compile main.c linking inventory.obj to create the final executable:

$ gcc -Wall -Wextra -o main inventory.obj main.c

(the order of the options isn't that important, just remember you must include any needed libraries before the source files that rely on code from the library.)

That should allow you to compile and link your code (either from the command line or in codeblocks). If you get stuck again, let me know.