1

For home-work, I need to define a function that allocate memory to an array of strings (which is into a struct).

The length of each string is given: MAX_WORD_LEN+1 (=10+1) I have to allocate memory for len number of strings, len is recieved in the input.

Struct with the array of strings definition (given):

struct dict{
    int len;
    char (*dict0)[MAX_WORD_LEN+1];
    char (*dict1)[MAX_WORD_LEN+1];
};

I don't understand the declaration char (*dict0)[MAX_WORD_LEN+1];

  • The function declaration is also given:
    void createDict(struct dict* myDict);

This is what I wrote, but I'm not sure it works, and I have a difficult time checking it in the compiler. I also wrote it based on post from this and other websites and do not really understand it:

OPTION 1:

void createDict(struct dict* myDict)
{

    myDict->(*dict0) =  malloc( (myDict->len)*sizeof(char*));
    myDict->(*dict1) = (char**) malloc( (myDict->len)*sizeof(char*));

    for(int i=0;i<(myDict->len);i++)
    {
        (myDict->(*dict0)[i]) = (char*)malloc((MAX_WORD_LEN+1)*sizeof(char));
        (myDict->(*dict0)[i]) = (char*)malloc((MAX_WORD_LEN+1)*sizeof(char));
    }
}

OPTION 2:

(myDict->(*dict0)[MAX_WORD_LEN+1]) = malloc((myDict->len) * sizeof(char*));
(myDict->(*dict1)[MAX_WORD_LEN+1]) = malloc((myDict->len) * sizeof(char*));

Please explain to me...

Improve this question
3
  • Neither are correct for that declaration. The compiler alone should tell you that. Commented Mar 20, 2013 at 14:43
  • 1
    char (*dict0)[MAX_WORD_LEN+1]; means an array of character pointers. But it seems you are trying to store a an array of characters (AKA string) Commented Mar 20, 2013 at 14:55
  • 1
    @Ifthikhan That is not an array of MAX_WORD_LEN+1 character pointers. It is a typed-pointer to an array of MAX_WORD_LEN+1 chars. Without the parens surrounding *dict, you would be correct. As presented, you are not. Commented Mar 20, 2013 at 15:15

3 Answers 3

Reset to default
7

First you need to understand the difference between the following three declarations. For the sake of brevity, assume N is MAX_WORD_LEN+1 to match your sizing:

char data[N];      // array of N chars
char *data[N];     // array of N char *pointers* (i.e. char *)
char (*data)[N];   // pointer to array of N chars

Remember above all else, pointers are variables that hold an "address" and are implementation-defined. Just like an int variable holds the value of an implementation integer, a pointer variable holds an implementation address.

In almost all cases, you can properly malloc() memory for a pointer type using the sizeof() operator with the underlying target dereferenced. There are some cases where this is not intuitive or easily presentable, but the following should help:

// allocates sizeof(Type) block
Type *p = malloc(sizeof(*p));

// allocates N*sizeof(Type) contiguous blocks
//  note: we'll use this style later to answer your question
Type *pa = malloc(N * sizeof(*pa));

This will work no matter what Type is. This is important, because in your case you have a pointer declared as :

char (*dict)[N];

As we already discussed above, this declares a pointer of type (pointer-to-N-chars). Note that no actual memory has been allocated yet. This is just a pointer; nothing more. Therefore, you can safely allocate a single element using the above syntax as:

// allocate single block
char (*dict)[N] = malloc(sizeof(*dict));

But this only accounts for a single entry. You need len entries, so :

// allocate 'len' contiguous blocks each N chars in size
char (*dict)[N] = malloc(len * sizeof(*dict));

Now dict is safely addressable as an array from 0..(len-1). You can copy in your data such as:

strcpy(data[0], "test");
strcpy(data[1], "another test");

So long as the source string does not exceed N-chars (including the zero-terminator), this will work correctly.

Finally, don't forget to free your allocation when finished:

free(dict);

Spoiler

myDict->dict0 =  malloc( myDict->len * sizeof(*(myDict->dict0)));
myDict->dict1 =  malloc( myDict->len * sizeof(*(myDict->dict1)));
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

@user2191288 I sure hope it helped.
0

In the declaration of the structure, 

char (*dict0)[MAX_WORD_LEN+1];

means that dict0 is a pointer to a character array of MAX_WORD_LEN + 1 elements i.e. char [11].

To initialize the field of your object, you can consider an example as shown below

void createDict(struct dict* myDict)
{
    myDict->dict0 = &glbarr;
    myDict->dict1 = &glbarr;
}

where glbarr is a global array defined as 

char glbarr[MAX_WORD_LEN+1];
Improve this answer

1 Comment

[MAX_WORD_LEN+1] - is meant to be the lenght of every string in the array, I have to allocate memory for the arrays acording to the int "len" that i get from the input. For example, if len is 5 i need to allocate memory for 5 strings of 11 lenght... I am not sure that waht you wrote do it.
0

char (*dict)[MAX_WORD_LEN+1] is a pointer to an array of char[MAX_WORD_LEN+1]. Or you can interpret it as an array of such arrays (a two-dimensional array).

Let's say typedef char MyString[MAX_WORD_LEN+1];.

Then your declaration will look as MyString *dict0; In other words, the dict0 can be a pointer to the first element of an array of MyString. And this is what you should do.

I will not post the detailed solution (your teacher would not be happy with that).

I suggest also that you feel the difference between char (*dict)[10]; and char *dict[10];.

Improve this answer

8 Comments

I didn't understand the difference, also is not really my homework.. I start my studies next year, I am doing a little practicing till then.
so i need to allocate memory for the pointer dict0 ? so is this write ? (myDict->(*dict0)[MAX_WORD_LEN+1]) = malloc((myDict->len) * sizeof(char)); \n what i wrote in OPTION 2
char *dict[10] is an array of pointers, not a pointer to an array. You should malloc len*(MAX_WORD_LEN+1)*sizeof(char) bytes. This will look as myDict->dict0 = malloc(...)
I asked about char(*dict)[11], I think it is a pointer to an array of chars - a string ,as said in a previous answer,... or not?
@EL11 it is used in describing the type a pointer is bound to. Example, char *p;, the underlying type is char. For char (*p)[N]; the underlying type is char[N]. I hope that makes it a bit clearer. It is important, especially when doing pointer arithmetic because the size of the underlying type determines the number of bytes a pointer is actually adjusted when adding/subtracting scalers.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.