Resizing a char[x] to char[y] at runtime

Question

OK, I hope I explain this one correctly. I have a struct:

typedef struct _MyData
{
   char Data[256];
   int  Index;
} MyData;

Now, I run into a problem. Most of the time MyData.Data is OK with 256, but in some cases I need to expand the amount of chars it can hold to different sizes. I can't use a pointer. Is there any way to resize Data at run time? How? Code is appreciated.

Thanks

EDIT:

While I am very thankful for all the comments, the "maybe try this..." or "do that", or "what you are dong is wrong..." comments are not helping. code is the help here. PLease if you know the answer post the code.

and:

1- cannot use pointers. please don't try to figure out why, i just can't 2- the struct is being injected into another program's memory. that's why. no pointers.

sorry for being a bit rough here but i asked the question here because I already tried all the different approaches that thought might work. Again, i am looking for code. At this point I am not interested in "might work..." or " have you considered this..."

thank you and my apologies again

EDIT 2

Why was this set as answered?

Answer 1

The problem here is your statement "I can't use a pointer". You will have to, and it will make everything much easier. Hey, realloc even copies your existing data, what do you want more?

So why do you think you can't use a pointer? Better try to fix that.

Answer 2

You would re-arrange the structure like that

typedef struct _MyData
{
   int  Index;
   char Data[256];
} MyData;

And allocate instances with malloc/realloc like that:

my_data = (MyData*) malloc ( sizeof(MyData) + extra_space_needed );

This is an ugly approach and I would not recommend it (I would use pointers), but is an answer to your question how to do it without a pointer.

A limitation is that it allows for only one variable size member per struct, and has to be at the end.

Answer 3

You may be able to do this like this, without allocating a pointer for the array:

typedef struct _MyData
{
    int Index;
    char Data[1];
} MyData;

Later, you allocate like this:

int bcount = 256;
MyData *foo;

foo = (MyData *)malloc(sizeof(*foo) + bcount);

realloc:

int newbcount = 512;
MyData *resized_foo;

resized_foo = realloc((void *)foo, sizeof(*foo) + newbcount);

Answer 4

You can use a flexible array member

typedef struct _MyData
{
   int  Index;
   char Data[];
} MyData;

So that you can then allocate the right amount of space

MyData *d = malloc(sizeof *d + sizeof(char[100]));
d->Data[0..99] = ...;

Later, you can free, and allocate another chunk of memory and make a pointer to MyData point to it, at which time you will have more / less elements in the flexible array member (realloc). Note that you will have to save the length somewhere, too.

In Pre-C99 times, there isn't a flexible array member: char Data[] is simply regarded as an array with incomplete type, and the compiler would moan about that. Here i recommend you two possible ways out there

• Using a pointer: char *Data and make it point to the allocated memory. This won't be as convenient as using the embedded array, because you will possibly need to have two allocations: One for the struct, and one for the memory pointed to by the pointer. You can also have the struct allocated on the stack instead, if the situation in your program allows this.
• Using a char Data[1] instead, but treat it as if it were bigger, so that it overlays the whole allocated object. This is formally undefined behavior, but is a common technique, so it's probably safe to use with your compiler.

Answer 5

I find KIV's trick quite usable. Though, I would suggest investigating the pointer issue first.

If you look at the malloc implementations
(check this IBM article, Listing 5: Pseudo-code for the main allocator),
When you allocate, the memory manager allocates a control header and
then free space following it based on your requested size.
This is very much like saying,

typedef struct _MyData
{
   int  size;
   char Data[1]; // we are going to break the array-bound up-to size length
} MyData;

---

Now, your problem is,
How do you pass such a (mis-sized?) structure to this other process?

That brings us the the question,
How does the other process figure out the size of this data?
I would expect a length field as part of the communication.

If you have all that, whats wrong with passing a pointer to the other process?
Will the other process identify the difference between a pointer to a structure and that to a allocated memory?

Answer 6

You cant reacolate manualy.

You can do some tricks wich i was uning when i was working aon simple data holding sistem. (very simple filesystem).

typedef struct
{
    int index ;     
    char x[250];
} data_ztorage_250_char;

typedef struct
{
    int index;      
    char x[1000];
} data_ztorage_1000_char;

int main(void)
{
      char just_raw_data[sizeof(data_ztorage_1000_char)];
      data_ztorage_1000_char* big_struct;
      data_ztorage_250_char* small_struct;
      big_struct = (data_ztorage_1000_char*)big_struct; //now you have bigg struct
      // notice that upper line is same as writing 
      // big_struct = (data_ztorage_1000_char*)(&just_raw_data[0]);

      small_struct = (data_ztorage_250_char*)just_raw_data;//now you have small struct

      //both structs starts at same locations and they share same memory
     //addresing data is 
      small_struct -> index = 250;
}

Answer 7

It looks like from what you're saying that you definitely have to keep MyData as a static block of data. In which case I think the only option open to you is to somehow (optionally) chain these data structures together in a way that can be re-assembled be the other process.

You'd need and additional member in MyData, eg.

typedef struct _MyData
{
   int  Sequence;
   char Data[256];
   int  Index;
} MyData;

Where Sequence identifies the descending sequence in which to re-assemble the data (a sequence number of zero would indicate the final data buffer).

Answer 8

The problem is in the way you're putting the question. Don't think about C semantics: instead, think like a hacker. Explain exactly how you are currently getting your data into the other process at the right time, and also how the other program knows where the data begins and ends. Is the other program expecting a null-terminated string? If you declare your struct with a char[300] does the other program crash?

You see, when you say "passing data" to the other program, you might be [a] tricking the other process into copying what you put in front of it, [b] tricking the other program into letting you overwrite its normally 'private' memory, or [c] some other approach. No matter which is the case, if the other program can take your larger data, there is a way to get it to them.

Answer 9

Let me sum up two important points I see in this thread:

1. The structure is used to interact between two programs through some IPC mechanism
2. The destination program cannot be changed

You cannot therefore change that structure in any way, because the destination program is stuck trying to read it as currently defined. I'm afraid you are stuck.

You can try to find ways to get the equivalent behavior, or find some evil hack to force the destination program to read a new structure (e.g., modifying the binary offsets in the executable). That's all pretty application specific so I can't give much better guidance than that.

You might consider writing a third program to act as an interface between the two. It can take the "long" messages and do something with them, and pass the "short" messages onward to the old program. You can inject that in between the IPC mechanisms fairly easily.

Answer 10

You don't state what the Index value is for.

As I understand it you are passing data to another program using the structure shown. Is there a reason why you can't break your data to send into chunks of 256bytes and then set the index value accordingly? e.g.

Data is 512 bytes so you send one struct with the first 256 bytes and index=0, then another with the next 256 bytes in your array and Index=1.

Answer 11

How about a really, really simple solution? Could you do:

typedef struct _MyData
{
   char Data[1024];
   int  Index;
} MyData;

I have a feeling I know your response will be "No, because the other program I don't have control over expects 256 bytes"... And if that is indeed your answer to my answer, then my answer becomes: this is impossible.