迭代动态分配的char数组

Question

I am new to pointers in C, please bear with me. I am trying to write a function which returns the index of the array if the string is found else stores the string and then returns the index. I want to create a structure like this {"1234", "3241", "2234", "2222"} for which I have dynamically allocated a char array like this (I need to take the size from command line)

char** userToRdrMap = {NULL};
userToRdrMap = malloc(numOfReducers * sizeof(char*));

Now, I have an array of userId's

char *userId[numOfReducers];
    userId[0] = "2234";
    userId[1] = "2222";
    userId[2] = "3223";
    userId[3] = "2222";

For each userId, I will call a function findRdrNum(userId[i]) which will check the earlier dynamically allocated char array userToRdrMap , if userId is present it should return the index, else store it and then return the index. I am not able to proceed with this problems since I am getting confused and lost with pointers. Can anyone please help ? This is my program, which tried returning the index and then storing it.

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

int numOfReducers;
char** userToRdrMap = {NULL};
char* temp1;

int findRdrNum(char *userId){
    if(!userToRdrMap[0]){
        return 0;
    } else{
        int i;
        printf("%s", userToRdrMap[1]);
        for(i=0; i<numOfReducers; i++){
            if(strcmp(userToRdrMap[i], userId))
                return i;
        }
    }
    return NULL;
}

int main (int argc, char *argv[])
{
    numOfReducers = atoi(argv[1]);
    int i;
    char *userId[numOfReducers];
    userId[0] = "2234";
    userId[1] = "2222";
    userId[2] = "3223";
    userId[3] = "2222";
    int rdrNum;

    userToRdrMap = malloc(numOfReducers * sizeof(char*));
/*  temp1 = malloc(numOfReducers * 4 * sizeof(char));
    for (i = 0; i < numOfReducers; i++) {
      userToRdrMap[i] = temp1 + (i * 4);
    }
*/
    printf("%s\n", userId[0]);
    for(i=0; i<numOfReducers; i++){
        rdrNum = findRdrNum(userId[i]);
        strcpy(userToRdrMap[rdrNum], userId[i]);
        printf("%d", rdrNum);
    }
    return 0;
}

Thanks, Harrish

Answer 1

So basically what your looking for is something like this?

Edit: Fixed minor error in example code

int findRdrNum(char *userId) {
    for (int pos = 0; pos < numOfReducers; pos++) 
    // check whether position hasn't been allocated yet
    if (userToRdrMap[pos] != NULL) 
        //compare string and return pos if equal
        if (strcmp(userId, userToRdrMap[pos]) == 0)
            return pos;
}

Also, you could allocate your vector in a function like this:

int allocateUserToRdrMap(){
    userToRdrMap = malloc(numOfReducers * sizeof(char));
    if (userToRdrMap == NULL)
        return 0;
    return 1;
}

Answer 2

If you are trying to make the function findRdrNum to return the index of the element of userToRdrMap that matches with userId consider that strcmp returns 0 if its arguments are equal; therefore your function will retrun the index of the first element that is NOT equal with userId . It will be usefull to check if strcmp(userToRdrMap[i], userId) == 0 . Also, this function has type int so there is no place for that return NULL . Another thing is that it is recommended to the result returned by malloc to your type (malloc returns *void

Answer 3

The Question:

Your question was a bit confusing, but I could see what you were getting at and it's clear you did put some effort into writing up a decent post. Therefore, I've tried to write a program that accomplishes what you want, and is easy to understand.

---

Program:

The following program installs the same example strings you've provided in your example automatically. It then reads each argument provided in main's argument vector ( char *argc[] ) to check if it is in there. If it isn't, it gets installed. Everything is demonstrated with print statements, as you'll see in the example output.

Output Example:

./a.out 2222 3223 kjd 090 kjd
The User ID "2222" exists at index 1!
The User ID "3223" exists at index 2!
Installed "kjd"!
Installed "090"!
The User ID "kjd" exists at index 4!

---

Here's the program code. I've tried to comment things so you'll understand what I've done. At the bottom I'll include some remarks about your original program and what you can do to try and improve it.

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

// An array of strings: (A pointer to an array of pointers).
// Declaring a variable out in global scope is always initialized to NULL!
char **strings;

// 1: The index of the next free pointer. 2: The total number of pointers available.
int str_idx, str_size;

// Returns index of given string pointer `sp`. If it's not there, -1 is returned.
int indexOf (char *sp) {

    for (int i = 0; i < str_idx; i++) {
        // If string at index i == string we're looking for.
        if (strcmp(sp, strings[i]) == 0) {
            return i;
        }
    }

    return -1;
}

// Copies given string into strings. If necessary, strings is resized.
void installString (char *sp) {
    char *copy = NULL;

    // 1. Ensure we have space. Otherwise resize strings array.
    if (str_idx >= str_size) {
        str_size = str_size * 2;
        strings = realloc(strings, str_size * sizeof(char *));
    }

    // 2. Allocate space for copy of string. Print an error if it failed.
    copy = malloc(strlen(sp) * sizeof(char));
    if (copy == NULL) {
        printf("Error: Allocation failure in \"installString\"!\n");
        exit(EXIT_FAILURE);
    }

    // 3. Copy the contents over.
    copy = strcpy(copy, sp);

    // 4. Place the pointer (copy) at str_idx (next available spot), and post-increment str_idx.
    strings[str_idx++] = copy;
}

int main (int argc, char *argv[]) {

    // 1. Initialize our global strings array. Ensure it succeeded.
    str_size = 10;
    strings = malloc(str_size * sizeof(char *));
    if (strings == NULL) {
        printf("Error: Allocation failure in \"main\"!\n");
        exit(EXIT_FAILURE);
    }

    // 2. Install some example User IDs.
    installString("2234");
    installString("2222");
    installString("3223");
    installString("2222");

    // 3. Check the User IDs provided as program arguments.
    // (I subtract from argc first because argument zero is the name of the program)
    while (--argc) {
        char *id = *(++argv); // Increment argv pointer (to skip program name), dereference at next argument.

        // 4. If the id is installed, print the index. Otherwise install it.
        int index;
        index = indexOf(id);
        if (index > -1) {
            printf("The User ID \"%s\" exists at index %d!\n", id, index);
        } else {
            installString(id);
            printf("Installed \"%s\"!\n", id);
        }
    }

    // 5. Clean up allocated memory.
    for (int i = 0; i < str_idx; i++) {
        free(strings[i]);
    }
    free(strings);

    return EXIT_SUCCESS;
}

---

Tips:

1. The statement: char** userToRdrMap = {NULL}; is better written as just char **userToRdrMap; if you're keeping it in the global scope. The reason being is that it will automatically be NULL initialized there. This isn't true if it's a local or automatic variable though!

2. Don't return zero as a bad index. Zero is a valid index, and -1 makes a lot more sense because nothing can really be at index -1.

3. Your function findRdrNum says it returns an int . Yet at the end you return NULL , which is typically used for pointers. This is inconsistent. Don't do it.

4. You're not freeing any memory you're allocating in your program. You really ought to do this.

5. You allocate an array of string pointers in your program. But you don't actually allocate any space for the strings you're trying to copy to the pointers. This is undefined behavior and unacceptable. If you're going to copy anything to the array of pointers you allocated, you need to actually allocate memory for the string you wish to copy, then set the value of the pointer within the strings array to that of the allocated copy. I do this in my example.

Answer 4

Your question is a little unclear as to what your ultimate goal is, but it looks like you wish to read user IDs from stdin (or a file) and add the user IDs to a dynamically expanding array of pointers. While doing this you appear to want to insure that only new IDs are added and all duplicate IDs are skipped.

While there is nothing wrong with using and array of pointers to char (technically a pointer-to-pointer-to-char ), if all your IDs are of a fixed number of characters, you can greatly simplify your memory allocation by using a pointer-to-array (eg char (*users)[NCHR] ) as the basis for your storage. (where storage can be managed and freed in a single call rather than allocating pointers and storage for IDs separately) However since you look like you want a char ** as the basis for your storage scheme (and it is something you will commonly use anyway), that will be addressed.

When looking to store anything in a dynamic fashion, using a pointer-to-pointer is a normal basis for doing so. The scheme is simple. Allocate some reasonably anticipated number of pointers initially, then allocate storage to hold whatever each of your pointers points to, and when you have used up your initial number of pointers, just realloc the number of pointers and keep going. (you can add whatever number of pointers you like each time you reallocate, through doubling the number is a fairly common scheme)

To put all that together, let's start out with two simple functions. One to find the user index in the collection of users (if it exists) and return the index (or say -1 if the ID does not exist). You could do that as follows:

/* simple function to check if user exists & return index */
int finduserndx (char **users, char *u, int n)
{
    int i;

    for (i = 0; i < n; i++)             /* loop over each index */
        if (strcmp (users[i], u) == 0)  /* compare IDs as strings */
            return i;                   /* return index on match */

    return -1;  /* return -1 indicating no-match */
}

You simply pass a copy of your collection of users, the new user you wish to add, and the number that exist, then loop over each calling strcmp against the new user and return either the index where it already exists or -1 to indicate it doesn't exist in the list. ( note: if your user IDs are all numbers, it is much more efficient to store them a decimal values) The function will be used in your adduser function.

To add a new user, you call finduserndx , and if the user already exists, you are done. If it doesn't exists, you need to first check if you have used up all your allocated pointers, and if so, realloc more (always assigning the return of realloc to a temporary pointer), and then allocate storage for new user and copy the new user to the new block of memory that is assigned to the next available pointer in your list. You could do something like:

/* simple function to add user 'u' to 'users' with '*n' existing users,
 * and '*nptrs' allocated pointers in 'users'. reallocate if
 * '*n + 1 == *nptrs' and allocate for new `users[n]`, increment
 * '*n' and '*nptrs' accordingly. returns beginning address to `users`
 * which must be assigned in caller to prevent becomming a 3-star
 * programmer (not a compliment)
 */
char **adduser (char **users, char *u, int *n, int *nptrs)
{
    if (finduserndx (users, u, *n) != -1) { /* if users exists, return */
        printf ("user: %s ==> duplicate\n", u); /* informational only */
        return users;
    }
    printf ("user: %s --- adding\n", u);    /* informational only */

    if (*n + 1 == *nptrs) { /* check if num pointers exhausted */
        /* realloc using temporary pointer */
        void *tmp = realloc (users, *nptrs * 2 * sizeof *users);
        if (!tmp) { /* validate realloc success/handle failure */
            perror ("realloc - memory exhausted");
            exit (EXIT_FAILURE);
        }
        users = tmp;    /* assign new block to users */
        *nptrs *= 2;    /* update number of allocated pointers */
    }

    users[*n] = malloc (strlen (u) + 1);    /* allocate for new user */
    if (!users[*n]) {   /* vallidate malloc/handle failure */
        perror ("malloc users[n] - memory exhausted");
        exit (EXIT_FAILURE);
    }
    strcpy (users[(*n)++], u);  /* copy new user to users[n] & increment */

    return users;   /* return pointer to start of users */
}

( note: if realloc fails, your existing data is not lost and still exists and is available through the original pointer -- so your handling of a realloc failure does not need to be an immediate exit -- but that will add a bit of complexity better left for later)

( also note: how the number of current user IDs ( 'n' ) and the current number of allocated pointers ( 'nptrs' ) are passed as pointers so that when their value is updated in the function -- the new value is available back in the calling function)

That is the nuts-and-bolts of your storage scheme. Now all you need to do in the caller ( main() here) is to read each user ID, get the length, trim the trailing '\\n' (so strcmp works -- and so you don't have spurious '\\n' s dangling off the end of your strings), and then call adduser passing the string as an argument along with pointers to the current number if user IDs and a pointer to the current number of allocated pointers.

Putting it altogether, you could do something like the following:

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

#define NREDUCR 4   /* if you need constants, define them */
#define MAXC  128   /* (don't use magic numbers in code) */

/* simple function to check if user exists & return index */
int finduserndx (char **users, char *u, int n)
{
    int i;

    for (i = 0; i < n; i++)             /* loop over each index */
        if (strcmp (users[i], u) == 0)  /* compare IDs as strings */
            return i;                   /* return index on match */

    return -1;  /* return -1 indicating no-match */
}

/* simple function to add user 'u' to 'users' with '*n' existing users,
 * and '*nptrs' allocated pointers in 'users'. reallocate if
 * '*n + 1 == *nptrs' and allocate for new `users[n]`, increment
 * '*n' and '*nptrs' accordingly. returns beginning address to `users`
 * which must be assigned in caller to prevent becomming a 3-star
 * programmer (not a compliment)
 */
char **adduser (char **users, char *u, int *n, int *nptrs)
{
    if (finduserndx (users, u, *n) != -1) { /* if users exists, return */
        printf ("user: %s ==> duplicate\n", u); /* informational only */
        return users;
    }
    printf ("user: %s --- adding\n", u);    /* informational only */

    if (*n + 1 == *nptrs) { /* check if num pointers exhausted */
        /* realloc using temporary pointer */
        void *tmp = realloc (users, *nptrs * 2 * sizeof *users);
        if (!tmp) { /* validate realloc success/handle failure */
            perror ("realloc - memory exhausted");
            exit (EXIT_FAILURE);
        }
        users = tmp;    /* assign new block to users */
        *nptrs *= 2;    /* update number of allocated pointers */
    }

    users[*n] = malloc (strlen (u) + 1);    /* allocate for new user */
    if (!users[*n]) {   /* vallidate malloc/handle failure */
        perror ("malloc users[n] - memory exhausted");
        exit (EXIT_FAILURE);
    }
    strcpy (users[(*n)++], u);  /* copy new user to users[n] & increment */

    return users;   /* return pointer to start of users */
}

int main (int argc, char **argv) {

    /* allocate number of pointer given as argument (NREDUCR by default) */
    int nptrs = argc > 1 ? (int)strtol(argv[1], NULL, 0) : NREDUCR,
        ndx = 0, i;
    char user[MAXC] = "";   /* fixed buffer for reading input */
    char **users = NULL;    /* pointer to pointer to char */

    /* allocate/validate initial number of pointers */
    users = malloc (nptrs * sizeof *users);
    if (!users) {
        perror ("malloc - users");
        exit (EXIT_FAILURE);
    }

    while (fgets (user, MAXC, stdin)) {     /* read each ID from stdin */
        size_t len = strlen (user);         /* get length of ID */
        if (len && user[len - 1] == '\n')   /* check last char is '\n' */
        user[--len] = 0;                    /* overwrite w/nul-character */
        else if (len - 1 == MAXC) {         /* test if ID too long */
            fprintf (stderr, "error: ID too long.\n");
            exit (EXIT_FAILURE);
        }
        /* call adduser assigning return to users */
        users = adduser (users, user, &ndx, &nptrs);
    }

    putchar ('\n');         /* output stored user IDs */
    for (i = 0; i < ndx; i++) {
        printf ("user[%2d] : %s\n", i, users[i]);
        free (users[i]);    /* freeing storage as you go */
    }
    free (users);           /* free pointers */

    return 0;
}

Example Input ID's (with duplicates)

$ cat dat/userids.txt
1993
2947
2234
2222
3223
1016
1444
1125
1194
2234
2732
2679
2222
2681
1444
1629

Example Use/Output

$ ./bin/addusers_dyn <dat/userids.txt
user: 1993 --- adding
user: 2947 --- adding
user: 2234 --- adding
user: 2222 --- adding
user: 3223 --- adding
user: 1016 --- adding
user: 1444 --- adding
user: 1125 --- adding
user: 1194 --- adding
user: 2234 ==> duplicate
user: 2732 --- adding
user: 2679 --- adding
user: 2222 ==> duplicate
user: 2681 --- adding
user: 1444 ==> duplicate
user: 1629 --- adding

user[ 0] : 1993
user[ 1] : 2947
user[ 2] : 2234
user[ 3] : 2222
user[ 4] : 3223
user[ 5] : 1016
user[ 6] : 1444
user[ 7] : 1125
user[ 8] : 1194
user[ 9] : 2732
user[10] : 2679
user[11] : 2681
user[12] : 1629

Memory Use/Error Check

In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.

It is imperative that you use a memory error checking program to insure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.

For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.

$ valgrind ./bin/addusers_dyn <dat/userids.txt
==26867== Memcheck, a memory error detector
==26867== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==26867== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==26867== Command: ./bin/addusers_dyn
==26867==
user: 1993 --- adding
user: 2947 --- adding
user: 2234 --- adding
user: 2222 --- adding
user: 3223 --- adding
user: 1016 --- adding
user: 1444 --- adding
user: 1125 --- adding
user: 1194 --- adding
user: 2234 ==> duplicate
user: 2732 --- adding
user: 2679 --- adding
user: 2222 ==> duplicate
user: 2681 --- adding
user: 1444 ==> duplicate
user: 1629 --- adding

user[ 0] : 1993
user[ 1] : 2947
user[ 2] : 2234
user[ 3] : 2222
user[ 4] : 3223
user[ 5] : 1016
user[ 6] : 1444
user[ 7] : 1125
user[ 8] : 1194
user[ 9] : 2732
user[10] : 2679
user[11] : 2681
user[12] : 1629
==26867==
==26867== HEAP SUMMARY:
==26867==     in use at exit: 0 bytes in 0 blocks
==26867==   total heap usage: 16 allocs, 16 frees, 289 bytes allocated
==26867==
==26867== All heap blocks were freed -- no leaks are possible
==26867==
==26867== For counts of detected and suppressed errors, rerun with: -v
==26867== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Always confirm that you have freed all memory you have allocated and that there are no memory errors.

Look things over and let me know if you have further questions or if I missed the intent of your question. I'm happy to help further if you can clarify what additional you need.