Banging head against a wall

[SteveKlett]

I took over some code for someone here and I have a real irritating
situation.

There are 20 or so structs that are initialized ad I need to change
some of the values of these structs based on a user defined option.

So, 20 struct arrays like this:
<code>
typedef struct{
int a;
} MY_STRUCT;

MY_STRUCT stuff_1[]={{1},{2}};
MY_STRUCT stuff_2[]={{1},{2},{3},{4}};
// etc
MY_STRUCT stuff_20[]={{1},{2},{3}};
</code>

In a perfect world, I could initialize these structs with the variable
I want, but I can't. I can't use a pre processor #define as the value
is being read from FLASH (it's an embedded device) at startup.
I can store pointers to each of the struct arrays, but then I can't
tell the sizeof the array. In other words stuff_2 is actually a
MY_STRUCT array with a length of 4.

Given:
<code>
MY_STRUCT* pStuff = (Y_STRUCT*)&my_stuff_2;
</code>

Is there any way to determine the depth of pStuff?

sizeof(*pStuff)/sizeof(MY_STUFF) doesn't work cause sizeof(*pStuff)
returns sizeof(MY_STUFF)
Anyway, hopefully you see my situation and might have a creative idea.

Thanks for any help,
Steve

[Alf P. Steinbach]

* St********@gmail.com:

I took over some code for someone here and I have a real irritating
situation.

There are 20 or so structs that are initialized ad I need to change
some of the values of these structs based on a user defined option.

So, 20 struct arrays like this:
<code>
typedef struct{
int a;
} MY_STRUCT;
In C++ style,

struct MyStruct{ int a; };

You don't need a 'typedef'. And (it's a good idea to) don't use all uppercase
names for anything but macros.

MY_STRUCT stuff_1[]={{1},{2}};
MY_STRUCT stuff_2[]={{1},{2},{3},{4}};
// etc
MY_STRUCT stuff_20[]={{1},{2},{3}};
</code>

In a perfect world, I could initialize these structs with the variable
I want, but I can't. I can't use a pre processor #define as the value
is being read from FLASH (it's an embedded device) at startup.
If you said, the values you want are not static, then it would make sense.

But if you could otherwise use a #define then the values must be static and
then I don't see why you couldn't have them in flash memory.
I can store pointers to each of the struct arrays, but then I can't
tell the sizeof the array.
First, this seems to be unrelated to the above, and second, why on earth not?

In other words stuff_2 is actually a MY_STRUCT array with a length of 4.
Is that supposed to clarify the previous sentence?

Given:
<code>
MY_STRUCT* pStuff = (Y_STRUCT*)&my_stuff_2;
</code>

Is there any way to determine the depth of pStuff?
Supposing you mean the array size, yes:

static std::size_t const stuffSize = sizeof(my_stuff_2)/sizeof(*my_stuff_2);

sizeof(*pStuff)/sizeof(MY_STUFF) doesn't work cause sizeof(*pStuff)
returns sizeof(MY_STUFF)
Anyway, hopefully you see my situation
Nope.

and might have a creative idea.

Yes, try to figure out what 1 (one) problem is, and give an example of that.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Someonekicked]

use vectors (?)
<St********@gmail.com> wrote in message
news:11*********************@z14g2000cwz.googlegro ups.com...

I took over some code for someone here and I have a real irritating
situation.

There are 20 or so structs that are initialized ad I need to change
some of the values of these structs based on a user defined option.

So, 20 struct arrays like this:
<code>
typedef struct{
int a;
} MY_STRUCT;

MY_STRUCT stuff_1[]={{1},{2}};
MY_STRUCT stuff_2[]={{1},{2},{3},{4}};
// etc
MY_STRUCT stuff_20[]={{1},{2},{3}};
</code>

In a perfect world, I could initialize these structs with the variable
I want, but I can't. I can't use a pre processor #define as the value
is being read from FLASH (it's an embedded device) at startup.
I can store pointers to each of the struct arrays, but then I can't
tell the sizeof the array. In other words stuff_2 is actually a
MY_STRUCT array with a length of 4.

Given:
<code>
MY_STRUCT* pStuff = (Y_STRUCT*)&my_stuff_2;
</code>

Is there any way to determine the depth of pStuff?

sizeof(*pStuff)/sizeof(MY_STUFF) doesn't work cause sizeof(*pStuff)
returns sizeof(MY_STUFF)
Anyway, hopefully you see my situation and might have a creative idea.

Thanks for any help,
Steve

[John Harrison]

Someonekicked wrote:

use vectors (?)

Yes absolutely, use vectors is the C++ solution. But since the code
looks like C to me, maybe the OP really wants a C solution.

Maybe this

void change_values(MY_STRUCT* array, size_t array_size)
{
...
}

change_values(stuff_2, sizeof stuff_2 / sizeof stuff_2[0]);

I.e. pass the size of the array that is being changed to the function
that does the work.

As the OP seems to be aware using sizeof like that is a bit dangerous,
which is why using vectors not arrays is the recommended solution.

john

[SteveKlett]

Hello John,

I was hoping to avoid the use of vectors for size reasons, we have a
very small footprint to work with and space is precious ;)

I ended up implementing a solution very similar to what you suggested.
I can easily find the size of an array when I'm working with the array
variable, but a dereferenced pointer to the same variable will only
give me the size of that dereferenced type. I find this odd.

But, solution solved for now, and plans to redesign this whole section
of code are well under way.

Thanks again for the post.
Thank you also to someonekicked.
Alf,
The problem was unclear, I just re-read my post and saw that I jumped
to my proposed solution's problem without explaining that solution.
Due to the fact that I can't initialize my structs with the variable, I
had tried to "set" the value after initialization with a separate
function. My original attempt was to generate an array of ptrs to the
structs, then dereferenced each pointer to further determine it's array
depth and then set the values for each item within (array of arrays)
but that was not working for me as I couldn't get the size of the
nested arrays.
<snip>
sizeof(my_stuff_2)/sizeof(*my_stuff_2)
</snip>

sizeof() passed a dereferenced pointer to an array will not return the
sum of the size of all items in the array, it will return the size of
the first item. Hence my problem.

I'd thank you for your post, but your attitude annoyed me, lighten up.