Dynamic array (or something like that) in C

Hello,

I have a structure like this:

Code:

---

typedef struct
{
        char *name;
        char keys[20][6];
} row;

---

However, I don't want to specify how many keys I can have in the array.
Can I replace it with something like **keys and then reallocate memory when I add data ? Any suggestions how to do it ?

Best wishes,
D5

You can have either a pointer to a fixed array:

Code:

---

char (*keys)[6]

---

or a pointer to pointer and allocate two arrays.

Code:

---

char **keys;

---

In a 32-bit machine, if your key is always 6 chars, you loose 4 bytes per key if you go with the second approach.

--
Mats

You can do it like this.

Code:

---

#include <stdio.h>
#include <string.h>

typedef struct
{
        char *name;
        char **keys;
} row;

int main()
{
    row temp;
    int i;

    temp.name = malloc(50 * sizeof(char));
    strcpy(temp.name, "Banana Man");

    temp.keys = malloc(5 * sizeof(char*));

    for ( i = 0; i < 5; ++i )
    {
        temp.keys[i] = malloc(3 * sizeof(char));
        memcpy(temp.keys[i], "1234567890" + i, 3);
    }

    puts(temp.name);

    for ( i = 0; i < 5; ++i )
    {
        int j;

        for ( j = 0; j < 3; ++j )
        {
            putchar(temp.keys[i][j]);
        }

        putchar('\n');
    }

    return 0;
}

---

The program never frees the memory. Bad.

Quote:

---

Originally Posted by matsp

In a 32-bit machine, if your key is always 6 chars, you loose 4 bytes per key if you go with the second approach.

---

Forgive my ignorance, but how are you losing 4 bytes?

Quote:

---

Originally Posted by cs32

Forgive my ignorance, but how are you losing 4 bytes?

---

Because you'll have an extra pointer for every array element, that you won't need in this particular case since you have fixed-width keys.

Quote:

---

The program never frees the memory. Bad.

---

I'm sure you have my best interests at heart and weren't just trying to be a know it all, so thanks for the nitpick. Anyway, my OS will free memory when the program ends and there's no point being anal about that kind of thing when it's just a little example for this thread. You might as well blast me for using // comments in C, or using magic numbers, or mixing tabs and spaces for indentation while you're at it. ;)

I could blame for all of it, but not freeing memory is not a good example for others, sooo... :)
I know the OS frees up resources at the end of a program, but I find it very bad practice to rely on that. There was a discussion about it before, and most agreed that it might be an "optimization," but certainly not a good idea just to be sloppy.
It's going to burn you someday, especially in C++.

Quote:

---

Anyway, my OS will free memory when the program ends and there's no point being anal about that kind of thing when it's just a little example for this thread.

---

I raised this point before, and while the opinion was divided, a general consensus is that we should teach best practices here. A simple solution is to show a code snippet instead, with the expectation that the reader should either know the rest, or better find out for himself.

Quote:

---

You might as well blast me for using // comments in C

---

Those are standard in C99.

Quote:

---

or mixing tabs and spaces for indentation while you're at it.

---

Elysia is well known for doing that, I do it myself when I find the indentation unacceptable for reading.

Quote:

---

most agreed that it might be an "optimization," but certainly not a good idea just to be sloppy.

---

Because I relied on an "optimization" it means I was being sloppy? :rolleyes:

Quote:

---

It's going to burn you someday, especially in C++.

---

I doubt it, but you can believe whatever you want to.

Quote:

---

Originally Posted by Banana Man

Because I relied on an "optimization" it means I was being sloppy? :rolleyes:

---

Yes. It's sloppy not to free memory. There was no need for such an optimization here.

Quote:

---

I doubt it, but you can believe whatever you want to.

---

Really? How well do you actually know C++?

Quote:

---

a general consensus is that we should teach best practices here

---

Yeah, but who dictates what best practices are?

Quote:

---

Those are standard in C99.

---

I thought "best practice" was not to use C99. :rolleyes:

Quote:

---

Originally Posted by Banana Man

Yeah, but who dictates what best practices are?

---

Describe to me how not freeing memory is good practice.

Quote:

---

Yeah, but who dictates what best practices are?

---

Common sense: if you do not free what you allocate, you end up with a memory leak. That the OS may act like a garbage collector is irrelevant.

I do not entirely agree with this stand myself (it sounds a little too harsh), but I have to agree that since we are concentrating on standard C, and standard C is not concerned with whether the OS does such a reclamation of memory, we should teach as if this is not the case, and indeed it might not be the case.

You can read the discussion for yourself: Concerning delete/delete[] at program exit

Note that it is in the C++ programming forum, not here.

Quote:

---

I thought "best practice" was not to use C99.

---

That's Prelude's opinion, but since that version of the C standard exists, to say that // is not part of C would be factually incorrect.

Quote:

---

Describe to me how not freeing memory is good practice.

---

Sorry, but I don't want to take over this thread until desmond5 says the original question is answered. I also think that you're not going to take any of my opinions seriously, so explaining them to you is pointless.

Quote:

---

Originally Posted by matsp

In a 32-bit machine, if your key is always 6 chars, you loose 4 bytes per key if you go with the second approach.

---

And on 64bit machine ?

Quote:

---

Originally Posted by Banana Man

Sorry, but I don't want to take over this thread until desmond5 says the original question is answered.

---

My question was answered :) Thankyou :) If anything comes up, I'll just add to the thread.

Then each pointer would have 8 bytes overhead.

Quote:

---

Originally Posted by Banana Man

Sorry, but I don't want to take over this thread until desmond5 says the original question is answered. I also think that you're not going to take any of my opinions seriously, so explaining them to you is pointless.

---

I don't think you're going to take anyone else's opinions seriously either, since you seem to sneeze at freeing memory, yet as laserlight has already explained it is bad practice.

Quote:

---

I don't think you're going to take anyone else's opinions seriously either

---

I take everyone's opinion seriously. I can't learn if I don't.

Quote:

---

since you seem to sneeze at freeing memory

---

I guess it does seem like that with the straw man you've built up. I'm saying that in my program there was no need to free the memory when the program is 1) a simple example, 2) prints something and ends right away, and 3) my OS frees the memory automatically. The reason I said I don't think you're taking me seriously is you keep acting like I'm pushing a practice of never freeing memory, period.

Anyway, I don't like confrontation, so I'll always free memory in my examples from now on to avoid being attacked. I'll try to conform to the "best practices" you've decided on as I learn what's expected on this board. My deepest apologies for having an independent thought.

Independent thoughts are good. But your attitude seemed like it was unnecessary.
I would say it's a requirement, but I can't force anyone to do anything, so what you code for your own is for you to decide, but when posting examples on the board, it's usually better to avoid bad practices.
Now let's be friends again :D:D:D:D

Whoa it seems like today there were swords drawn. I'd really like to apologize myself for the silly mistake on that other thread with the floating point thing. I was really doing something else at that point and missed a spot.

Quote:

---

Now let's be friends again

---

I'll drink to that! As far as i am concerned with memory management, when i learned Java straight after C, i felt like i was flying on the clouds. No free? NO FREE? I AM FREE? But then again, after sometime i started feeling that Java was taking away from me something very precious. So i said: Give me back my MEMORY! It's mine, my own my PRRRREEECCIOUS!!!
Cheers all! Have a nice day/night whatever.

Quote:

---

Originally Posted by Banana Man

You can do it like this.

Code:

---

#include <stdio.h>
#include <string.h>

typedef struct
{
        char *name;
        char **keys;
} row;

int main()
{
    row temp;
    int i;

    temp.name = malloc(50 * sizeof(char));
    strcpy(temp.name, "Banana Man");

    temp.keys = malloc(5 * sizeof(char*));

    for ( i = 0; i < 5; ++i )
    {
        temp.keys[i] = malloc(3 * sizeof(char));
        memcpy(temp.keys[i], "1234567890" + i, 3);
    }

    puts(temp.name);

    for ( i = 0; i < 5; ++i )
    {
        int j;

        for ( j = 0; j < 3; ++j )
        {
            putchar(temp.keys[i][j]);
        }

        putchar('\n');
    }

    return 0;
}

---

---

But what if I wish to add a key after I have already allocated the memory ? Like if I have a function add_key(row *_row, char *key); ? I tried to reallocate but I failed. How would you accomplish that ?

Best wishes, Desmond5

Quote:

---

Originally Posted by desmond5

But what if I wish to add a key after I have already allocated the memory ? Like if I have a function add_key(row *_row, char *key); ? I tried to reallocate but I failed. How would you accomplish that ?

Best wishes, Desmond5

---

The function would need to know the current number of keys stored in the array.

Code:

---

void add_key(row *_row, char *key,int n_keys)
{
    _row->keys = realloc( (n_keys+1)*sizeof(*_row->keys) );
    if(key!=NULL)
    {
        _row->keys[n_keys] = malloc(3 * sizeof(char));
        memcpy(_row->keys[n_keys], key, 3);
    } else {
        _row->keys[n_keys] = NULL; 
}

---

Quote:

---

Originally Posted by xuftugulus

The function would need to know the current number of keys stored in the array.

Code:

---

void add_key(row *_row, char *key,int n_keys)
{
    _row->keys = realloc( (n_keys+1)*sizeof(*_row->keys) );
    if(key!=NULL)
    {
        _row->keys[n_keys] = malloc(3 * sizeof(char));
        memcpy(_row->keys[n_keys], key, 3);
    } else {
        _row->keys[n_keys] = NULL; 
}

---

---

Yeah..but it gives a warning "[Warning] assignment makes pointer from integer without a cast" on this line: _row->keys = realloc( (n_keys+1)*sizeof(*_row->keys) );

You are missing proper #include

Really ? I don't know what else I need to include..

Code:

---

#include <stdio.h>
#include <string.h>

typedef struct
{
        char *name;
        char **keys;
} row;

void add_key(row *_row, char *key, int n_keys, int columns)
{
    _row->keys = realloc( (n_keys+1)*sizeof(*_row->keys) );
    if(key!=NULL)
    {
        _row->keys[n_keys] = malloc(columns * sizeof(char));
        memcpy(_row->keys[n_keys], key, columns);
    }
        else
        {
        _row->keys[n_keys] = NULL;
        }
}

int main()
{
    row temp;
    int i = 0;

    int n_keys = 0;

    int rows = 10;
    int columns = 5;

    temp.keys = malloc(rows * sizeof(char*));

        add_key(&temp, "somekey", n_keys, columns);


    for ( i = 0; i < rows; ++i )
    {
        int j;

        for ( j = 0; j < columns; ++j )
        {
            putchar(temp.keys[i][j]);
        }

        putchar('\n');
    }

        getchar();
    return 0;
}

---

You should use the <stdlib.h> include for the malloc/realloc calls.

--
Mats

Quote:

---

Originally Posted by matsp

You should use the <stdlib.h> include for the malloc/realloc calls.

--
Mats

---

And to pick up on those errors, you just include some warning flags.

If you're using gcc or mingw, -Wall and -ansi is enough I believe.

Note that the errors won't say "You forgot header file x", but rather something like "Implicit declaration of function x" when you try and call a function that hasn't been explicitly declared anywhere, but is still being implicitly declared to exist when you call it.

Quote:

---

Originally Posted by IceDane

And to pick up on those errors, you just include some warning flags.

If you're using gcc or mingw, -Wall and -ansi is enough I believe.

Note that the errors won't say "You forgot header file x", but rather something like "Implicit declaration of function x" when you try and call a function that hasn't been explicitly declared anywhere, but is still being implicitly declared to exist when you call it.

---

Indeed.

Also note that it's good practice to include header files that you KNOW you need, even if the compiler doesn't complain about them - for example you may find that stdio.h or string.h included stdlib.h IN YOUR case, but using a different set of header files (belonging to a different compiler or C library) the includes done by those header files DO NOT include stdlib.h - thus making it fail on a different system.

--
Mats

Sorry for the type damn it!
...

Code:

---

    _row->keys = realloc(_row->keys, (n_keys+1)*sizeof(*_row->keys) );

---

Add the blue thing to the function.

void *realloc(void *p, size_t new_size):
where p must be either a pointer, previously initialized with malloc, or calloc or NULL.
It is necessary to store the return of realloc to the previously allocated pointer as it might return a different address, not enough continual memory to satisfy the request will force a clone of the previously allocated area to a new memory section.

When including the <stdlib.h> header, it shouldn't compile without correcting it.

Many thanks :)

One more thing..I add three elements to the array. How is it that it has 4 ? I even cannot access the fourth element..

Code:

---

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

typedef struct
{
        char *name;
        char **keys;
} row;

void add_key(row *_row, char *key, int n_keys, int columns)
{
        if (n_keys == 0) _row->keys = malloc(sizeof(char*));
        else _row->keys = realloc(_row->keys, (n_keys+1)*sizeof(*_row->keys) );

    if(key!=NULL)
    {
        _row->keys[n_keys] = malloc(columns * sizeof(char));
        memcpy(_row->keys[n_keys], key, columns);
    }
        else
        {
        _row->keys[n_keys] = NULL;
        }
}

int main()
{
    row temp;
    int i = 0;

    int n_keys = 0;

    int rows = 10;
    int columns = 5;

        add_key(&temp, "key0", 0, columns);
        add_key(&temp, "key1", 1, columns);
        add_key(&temp, "key2", 2, columns);

        double si = sizeof(temp.keys);

    printf("%s\n", temp.keys[0]);
    printf("%s\n", temp.keys[1]);
    printf("%s\n", temp.keys[2]);

      //printf("%s\n", temp.keys[3]); doesnt excist ?


    printf("Size: %lf", si); // PRINTS 4 not 3 as expected

        getchar();
    return 0;
}

---

You keep track of the number of elements.
Code you wrote:

Code:

---

        double si = sizeof(temp.keys);

---

This gives you 4 because you probably have 32-bit addresing in your computer. It is the size of a pointer variable, as you declare in your struct.
You actually have added only 3 keys in your code.
You could add the variable n_keys in your struct and drop it from the function.
Also if you set the field keys to NULL before starting doing anything, it will not be necessary to test whether n_keys is zero.
In fact it is a good idea to write a function to initialize yor struct to empty 0 elements, although it can be done more easily like:

Code:

---

    row temp = {0};

---

I prefer to use a function to initialize structs as it simulates constructor functionality from C++,
and reminds me that my object is fresh and ready ;)