Thread: Array of strings

I saw a couple of postings about his and that got me thinking and I got a little confused. How do you create an array of strings? Would it be:

Code:

char *string[5];  /* This??? */
char **string;  /* This??? */
char string[][5];  /* This ??? */

Thanks...

--Garfield

More world renowned Salem© examples....

Code:

#include <stdio.h>

int main ( ) {
    // you have 5 pointers, but you can point to strings of any length
    char *string1[5] = {
        "a", "string", "array",
        "of", "variable-length-strings"
    };

    // this is a pointer to anything which looks like *string1[n]
    // you could also use string2 as the starting point for
    // creating dynamically allocated strings using malloc
    char **string2 = string1;

    // you can have as many strings as you like []
    // but each one must be <= 4 chars to allow the \0 to fit in [5] chars
    char string3[][5] = {
        "this","aray","can","only",
        "hold","smal","word","type",
        "str-","ings"
    };
    int i;

    for ( i = 0 ; i < 5 ; i++ ) {
        printf( "s1[%d]=%s\n", i, string1[i] );
        printf( "s2[%d]=%s\n", i, string2[i] );
    }
    for ( i = 0 ; i < 10 ; i++ ) {
        printf( "s3[%d]=%s\n", i, string3[i] );
    }
    return 0;
}

So, it is just like any array with the brackets to signify more than one?

Code:

int newInt[5];  /* An array of 5 integers */
char *newString[5];  /* An array of 5 strings */

Okay, that's easy enough.

One more question (going off the subject a little bit). It you have this:

Code:

int *intPtr;  /* Then I have to allocate memory for it with malloc */
intPtr = malloc(sizeof(int));
intPtr = 4;  /* initialize intPtr */

/* But if I have a char pointer (or as we know, as string) */
char *string;  /* How come I don't have to allocate memory for
--this char pointer? */

So, my question is, why do you have to dynamically allocate memory for, let's say, an int pointer and NOT a char pointer? Thanks...

--Garfield

Well you DON'T have to allocate for an int pointer! That is simply the choice YOU the programmer choose to do if you want to be nice to system resourses, because you can "free" the memory you allocate for, but not for memory you don't. While allocating( and later de-allocating) is definately a good habit to get into, it is hardly necessary unless 1) You are working with a large program that will need many variables and thus threatens to crash the system at runtime , or 2) You are working with a system that runs many programs at once, etc, 3) etc.

If you are developing a program that will need say 100 int variables declared and used, for instance, should you decide to not allocate for them, you will effectively be tying up around one tenth of a kilobyte! Pocket-change system resourses really!

Of course now if you are needing 100 structs, the story can be quite different. Depending on their sizes, this could mean one tenth of a megabyte(or perhaps much higher!).

Also remember that if you declare a non- malloced variable from within a function, once the routine passes out of this function, the system has probably "de-allocated" the variable anyway!

So the choice is yours.

I would recommend mallocing most strings, most or all structs and buffers(looooong strings), etc.

By the way, as far as I know, you DO have to malloc a string pointer if you intend to de-allocate it later.

Oh and the syntax for the all important aspect of de-allocation(for why malloc if you are not going to de-allocate it???) is
" free(this_int); " ...assuming you malloced an int called "this_int".

> So, my question is, why do you have to dynamically allocate memory for, let's say, an int pointer and NOT a char pointer?
But you do have to allocate.

You're mistaking allocation for initialisation. All my previous examples were initialisation. Any pointer (of any type) has to be either initialised or allocated before you can use it.

Using ints

Code:

int fred;
int *ptr;

ptr = &fred;   // initialise
ptr = malloc( sizeof(int) );  // allocate

// with either init or allocate done, this is now valid
*ptr = 42;  // use

Using strings.

Code:

char message[20];
char *ptr;

ptr = message;  // initialise
ptr = malloc( 20*sizeof(char) );  // allocate

// with either init or allocate done, this is now valid
strcpy( ptr, "hello world" );

Could I ask for one thing here?

Why do I have to allocate '20 * sizeof(char)' bytes in Salem's example? I mean, char is one byte large, isn't it? (ASCII - 255 chars.) So (20 * sizeof(char)) == 20 and then I think I can write malloc(20), is that ok?

> So (20 * sizeof(char)) == 20 and then I think I can write malloc(20), is that ok?
It is, but if you always write "n*sizeof(type)", then you're less likely to miss the "*sizeof(type)" when it really matters.

int *ptr = malloc( 20 );
will cause you just as much grief (perhaps even more) than if you hadn't allocated anything at all.

> int *ptr = malloc( 20 );
> will cause you just as much grief (perhaps even more) than if you hadn't allocated anything at all.

Sure. That's not what I meant. I meant "char *ptr = malloc(20)" which allocates 20 bytes so I can store 19 characters plus terminator in it (as far as I took from you explanation).

I know I have to put (char*) type-cast there, I only forgot it now. That's not my point. I just wanted to ensure char is 1 byte long...

thanx anyway

btw, is it good practice to put

char *str;

str = ( char *) malloc(n *sizeof(char));

instead of
str = malloc(n *sizeof(char)); ???

You don't need the typecast in C.

So, I understand, Salem. I either have to initialize or allocate the pointer. But, wouldn't initializing an int ptr to 4 being initializing?:

Code:

int *ptr_to_int;
*ptr_to_int = 4; /* Wouldn't this be initializing? */

I believe that this code flagged an error that ptr_to_int was not initialized or something. But I can do this?:

Code:

int num = 4;
int *ptr_to_int;
ptr_to_int = #  /* This is legal??? */

But if I wanted to do the first set of code, would I have to do this?:

Code:

int *ptr_to_int;
ptr_to_int = malloc (sizeof(int));
ptr_to_int = 4;  /* This is legal??? */

Thanks.

--Garfield

> *ptr_to_int = 4; /* Wouldn't this be initializing? */
It initialises what the pointer points to, not the pointer itself.

> I believe that this code flagged an error that ptr_to_int was not initialized or something.
Correct.

> But I can do this?
Yes.

> But if I wanted to do the first set of code, would I have to do this?
> ptr_to_int = 4; /* This is legal??? */
No, but this is
  *ptr_to_int = 4; /* This is legal */