Data structure pointer handling in C - c

Question

I have a struct like this;
struct abc
{
char bbb[10];
char ccc[4];
char ddd[6];
int i1;
int i2;
struct abc *prior, *next;
};
struct abb *start, *last, *this, *temp;
I have a lot of code using these pointers start,last, etc. so I would like to use them but I would like to add pointers to the struct and pointers within the struct to accomplish the following:
load the struct up with data then depending on the value of i1 for example, display and change data when the value of i1 = 0 or when the value of i1 = 1 or the contents of the struct regardless of the value of i1. And, at the end of the day save the whole struct to file with changes made in any of the three conditions.
I thought to have added pointers such as these:
struct abc *prior1, *next1;
struct abc *prior2, *next2;
};
struct abb *start1, *last1...etc.
struct abb *start2, *last2...etc.
I can have:
start = start1;
last = last1;
But how then do I reference
prior1
next1
Or tell me a better way of doing this.

Answer 1

It sounds like you're asking for advice on a serialization strategy. I'd suggest writing free operator<< and operator>> methods for handling I/O on your struct, where the pointers are referenced in a map that assigns an ascending numeric ID value to each. When writing, upon visiting each struct pointer, you check the map, and if the ID is found, you simply write out the ID and nothing else. Otherwise, you add the next available ID to the map, assign the ID to the pointer, and then write out the entire struct. When reading, you reverse the process, reading in each ID and looking in the map for that pointer. If it's not found, you have the first instance, so you proceed to read in the entire struct and store it in the map. Otherwise, you retrieve the previously read struct from the map and assign the pointer. This general strategy is used by CArchive serialization (Microsoft Foundation Classes). There may be some open source libraries to do the same.

Answer 2

Your question is not very clear.
You might just need to check out C pointers, and such syntax as start->prior which references the value of prior contained within start.
E.g.
// Set the i1 value of start to 42
start->i1 = 42;
printf("The answer is: %d\n", start->i2);
Or you might want to have the equivalent of methods to interact with one of your structures.
For example:
struct abc
{
char bbb[10];
char ccc[4];
char ddd[6];
int i1;
int i2;
struct abc *prior, *next;
};
struct abb *start, *last, *this, *temp;
/**
* Set the BBB of struct target to a given value.
* #param value the value to set
* #return pointer to the target
*/
struct abc *setBBB(struct abc *target, char *value)
{
strncpy(target->bbb, value, sizeof(target->bbb));
return target;
}
char *getBBB(struct abc *target)
{
return target->bbb;
}
struct abc *next(struct abc *target)
{
return target->next;
}
int getI1(struct abc *target)
{
return target->i1;
}
to accomplish the following: load the struct up with data then
depending on the value of i1 for example, display and change data when
the value of i1 = 0 or when the value of i1 = 1 or the contents of the
struct regardless of the value of i1.
This you would do with:
switch(getI1(start))
{
case 0:
setBBB(start, "Hello"); // NOTE: to treat this as a string,
// at most 9 characters are allowed,
// else the terminating zero will be lost.
break;
case 1:
setBBB(start, "World"); // ditto.
break;
...
}
And, at the end of the day save the whole struct to file with changes made in any of the three conditions.
You want to save the structure to a file, you need something like
int saveStruct(char *filename, int position, struct abc *target)
{
int ret;
FILE *fp;
if (NULL == (fp = fopen(filename, "r+")))
{
if (NULL == (fp = fopen(filename, "w")))
{
return -1; // Error.
}
}
fseek(fp, position * sizeof(struct abc), SEEK_SET);
ret = fwrite(target, sizeof(struct abc), 1, fp);
fclose(fp);
return ret;
}
The above has some problems, though. The values of pointers (*prior and *next) will become meaningless once saved to disk, and will remain so when loaded from disk. So the loadStruct() function will require as additional parameters the values of *prior and *next to be restored.
Also, you can't (but it depends on the platform) save a structure at position #1 if you haven't saved one at position #0 before. And each save performs an expensive open-and-close.
int loadStruct(char *filename, int position, struct abc *target)
{
int ret;
FILE *fp;
if (NULL == (fp = fopen(filename, "r")))
{
return -1; // Error.
}
fseek(fp, position * sizeof(struct abc), SEEK_SET);
ret = fread(target, sizeof(struct abc), 1, fp);
target->prior = NULL;
target->next = NULL;
fclose(fp);
return ret;
}
// The above, tested with the test case below, returns 'Hello!' as expected.
int main()
{
struct abc *start, *another;
start = malloc(sizeof(struct abc));
setBBB(start, "Hello!");
saveStruct("file.bin", 0, start);
another = malloc(sizeof(struct abc));
loadStruct("file.bin", 0, another);
printf("Re-read: %s.\n", getBBB(another));
}