Thread: array of strings + more

> how do you declare the opposite, ie fixed (staticaly allocated) mem for the individual strings
Well you can't allocate them statically, but you can tell the compiler that all the strings will be the same length.

Code:

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

#define STR_LEN     9
#define NUM_STR     4

int main ( ) {
    char    *str1[NUM_STR];   // an array of pointers to chars
    char    (*str2)[STR_LEN]; // a pointer to an array of chars
    int     i;

    // allocate space for 4 pointers
    for ( i = 0 ; i < NUM_STR ; i++ ) {
        str1[i] = malloc( STR_LEN * sizeof(char) );
    }

    // allocate space for 1 pointer
    str2 = malloc( NUM_STR * sizeof(char[STR_LEN]) );

    // both are now equivalent to strings[NUM_STR][STR_LEN]
    for ( i = 0 ; i < NUM_STR ; i++ ) {
        sprintf( str1[i], "string %d", i );
        strcpy( str2[i], str1[i] );
        printf( "%s\n", str2[i] );
    }

    return 0;
}

> suppose that you wanna make console menu and you got say submenu1 and submenu2
If the menus are linked by forward and reverse pointers, then the routine you use for navigating/drawing menus could automatically insert the appropriate links for you, rather than you having to do it all manually.

> (*str2)[STR_LEN];
Read the comment again - this is a pointer to an array of chars. You need the extra () to get the precedence right, otherwise its just an array of pointers.

Try and see past the array part, and just think about it in terms of a pointer to any multi-byte object like an int or a structure. The pointer still points to the first byte, but in terms of indexing, pointer arithmetic etc, C treats the whole lot as a single indivisible entity.
str1++ would point to the next char in the current string
str2++ would point to the next string (as you would normally expect if it was a pointer to an int or a struct).

Here's a clearer example without the malloc...

Code:

int main ( ) {
    char    *str1;          // pointer to a char array (of any size)
    char    (*str2)[10];    // pointer to a char[10] array
    char    string[10] = "hello";

//  char    bogus[20] = "world";
//  str1 = bogus;           // this is legal
//  str2 = &bogus;          // this isn't legal - the array sizes differ

    // point to first element
    // there is no information in the pointer to tell us how big the
    // thing being pointed at is.
    str1 = string;          // array names are pointers to the first element
    str1 = &string[0];      // ie, equivalent to this

    // point to the whole array
    str2 = &string;         // note - no [0]

    printf( "str1 points to %s\n", str1 );
    printf( "str1 points to %s\n", &str1[0] );
    printf( "str2 points to %s\n", *str2 );
    printf( "str2 points to %s\n", str2[0] );

    return 0;
}

> are you talking about pointers to functions?
Pointers to functions have () instead of [] in the declaration

There is nothing wrong with calling one function from within the other and and from that one to the first, etc. You can even call a function from within itself, very useful for menus.

Not only are these Legal, they are the foundations of routine writing!

A few things to watch out for though when doing this. Sometimes you "work yourself into a corner" where you cannot proceed because you are being redirected to the next which redirects you to the last and so on, but you will be able to iron out these fairly easily.

> is there any difference between calling func2() by name and calling func2() through a pointer to it?
Functionally no.
There's probably a couple of clock ticks difference in performance, but its hard to say which would be quicker in any given implementation. You'd be hard pushed to ever see a visible difference between the two.

> is memory allocated by the compiler in the same way?
Yes
You can call the same function directly, and via a pointer in the same program, and the same thing will happen in both cases.

> do you gain anything in using function pointers instead of calling by name?
Nope - stack space usage is the same