CODEWITHSUNDEEP
c++carrayspointersstruct
Spencer D
Spencer D

Reputation: 3486

Storing a Dynamic Array of Structures

I have been working on a project which utilizes a dynamic array of structures. To avoid storing the number of structures in its own variables (the count of structures), I have been using an array of pointers to the structure variables with a NULL terminator.

For example, let's say my structure type is defined as:

typedef struct structure_item{
    /* ... Structure Variables Here ... */
} item_t;

Now let's say my code has item_t **allItems = { item_1, item_2, item_3, ..., item_n, NULL }; and all item_#s are of the type item_t *.

Using this setup, I then do not have to keep track of another variable which tells me the total number of items. Instead, I can determine the total number of items as needed by saying:

int numberOfStructures;
for( numberOfStructures = 0;
     *(allItems + numberOfStructures) != NULL;
     numberOfStructures++
  );

When this code executes, it counts the total number of pointers before NULL.

As a comparison, this system is similar to C-style strings; whereas tracking the total number of structures would be similar to a Pascal-style string. (Because C uses a NULL terminated array of characters vs. Pascal which tracks the length of its array of characters.)

My question is rather simple, is an array of pointers (pointer to pointer to struct) really necessary or could this be done with an array of structs (pointer to struct)? Can anybody provide better ways to handle this?

Note: it is important that the solution is compatible with both C and C++. This is being used in a wrapper library which is wrapping a C++ library for use in standard C.

Thank you all in advance!

Upvotes: 0

Views: 258

Answers (2)

Rob
Rob

Reputation: 1974

Yes, it is possible to have an array of structs, and (at least) one of those a defined sentinel (which is that the '\0' used at the end of strings, and the NULL pointer in your case).

What you need to do, for your struct type, is reserve one or more possible values of that struct (composed of the set of values of its members) to indicate a sentinel.

For example, let's say we have a struct type

struct X {int a; char *p};

then define a function 

int is_sentinel(struct X x)
{
    return x.p == NULL;
}

This will mean any struct X for which the member p is NULL can be used as a sentinel (and the member a would not matter in this case).

Then just loop looking for a sentinel.

Note: to be compatible in both C and C++, the struct type needs to be compatible (e.g. POD).

Upvotes: 1

Quentin
Quentin

Reputation: 63124

What you need is a sentinel value, a recognizable valid value that means "nothing". For pointers, the standard sentinel value is NULL.

If you want to use your structs directly, you will need to decide on a sentinel value of type item_t, and check for that. Your call.

Upvotes: 2

Related Questions