Add a new record using pointer and realloc - c

Question

Hey Guys so basically I'm writing a program where you prompt the user how many first names he wants to store. You then create the pointer based on his response. After, you prompt him how many first names he wants to add to the pointer. So basically I'm trying to expand the same array by using realloc but I'm not sure if I'm using it correctly or not(Apparently not since it's not working)
Basically I want the first names that the user already inputted to stay as is, and for the program to start off asking the user for the next first name he wants to input. For example if the first time the user enters the number 2. Then he writes two names and then asks to add 2 more names, the program should keep the first 2 names and be ready to store at firstNames[2]. Thanks!
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(void)
{
int amount;
//Asking user for number of records to input
printf("Please indicate the number of records you want to enter:");
scanf("%d", &amount);
printf("\n");
//Declaring dynamic array for first names
char **firstNames = (char**)malloc(amount * sizeof(char));
for (int i = 0; i < amount; i++)
{
firstNames[i] = (char*)malloc(1 * sizeof(char));
}
//Prompting user for first name, last name, and scores
for (int count = 0; count < amount; count++)
{
printf("Enter first name for user %d:", count + 1);
scanf("%s", firstNames[count]);
}
int add;
printf("How many users do you want to add now:");
scanf("%d", &add);
int sum = amount + add;
firstNames = (char**)realloc(firstNames, sum * sizeof(char));
for (int count = amount; count < sum; count++)
{
printf("Enter first name for user %d:", count + 1);
scanf("%s", firstNames[count]);
}
return 0;
}

Answer 1

There are a number of areas where you are having trouble. As mentioned in my original comment, you must first allocate the memory correctly, before worrying about reallocating. Rather than calling realloc and assigning the return to firstNames, it is far better to create a temporary pointer to assign the return from realloc to. In the event realloc fails, it returns NULL. That means all existing data is lost because you just assigned firstNames = NULL. Using the temporary pointer allows your to test if the realloc succeeded before assigning the reallocated space to firstNames.
Going thought your code, there are several additional areas that can be improved. Always initialize your variables (to zero is fine). Why? Attempting to read from an uninitialized variable is Undefined Behavior (bad). Your input routines are critical. Especially using scanf and reading int/char data. You must insure you empty the input buffer before calling scanf again or it will use the newline (that results from pressing [enter]) as your next value causing your program to skip over the scanf statements that follow. You can use scanf to consume the newline to properly flush the input buffer (stdin) with careful choice of the format string.
When you get input validate it! Knucklehead users will enter anything.
When initializing pointer to pointers it is often better to use calloc for the initial allocation instead of malloc. calloc initializes all values to (zero) again preventing a read from an uninitialized variable.
Regarding program flow, you will want to minimize the number of loops and eliminate unnecessary blocks of code. If for no other reason, to lessen that chance of mistake. Think through your loops. You used multiple loops to count to the same number when all your operations could take place in one. This isn't a knock, this is just a suggestion to help you simplify your code.
When you ask for how many more users to enter before reallocating, what happens if 0 is entered? How should you handle it? Better to check and respond the way you want to, than leave it up to what the computer considers potentially undefined.
Those are the main points. I put together an example with those thoughts incorporated. It can always be improved, but I think this will help you handle the input issue and give you an example of simplifying the flow. While not necessary, I created a couple of functions to handle the printing and freeing of memory. Remember, if you allocate memory, you are responsible for keeping track of it and freeing it when your are done. Enough! Here is the example. Let me know if you have questions.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void print_users (char **array, int sz); /* funciton to print users */
void free_memory (char **array, int sz); /* function to free memory */
int main (void)
{
int amount = 0; /* always intialize all variables */
int i = 0;
//Asking user for number of records to input
printf("\nEnter the number of records to enter: ");
scanf("%d%*c", &amount); /* read int, discard newline */
printf("\n");
if (!amount) /* validate records to enter */
{
fprintf (stderr, "\nerror: invalid input.\n\n"); /* if realloc fails, error and exit */
return 1;
}
//Declaring dynamic array for first names
char **firstNames = calloc (amount, sizeof (*firstNames)); /* using your variable for sizeof (x) */
for (i = 0; i < amount; i++) /* prevents mistaken sizeof (wrong) */
{ /* calloc initializes to NULL (zero) */
firstNames[i] = malloc (sizeof (**firstNames)); /* same for malloc */
//Prompting user for first name, last name, and scores
printf (" first name for user %d : ", i + 1);
scanf ("%m[^\n]%*c", &firstNames[i]); /* read string and newline (discarded) */
}
int add = 0;
printf ("\nAny *additional* users to add: ");
scanf ("%d%*c", &add); /* read int, discard newline */
printf ("\n");
if (!add)
{
print_users (firstNames, amount);
free_memory (firstNames, amount);
return 0;
}
int sum = amount + add;
char **tmp = NULL;
tmp = realloc (firstNames, sum * sizeof (*firstNames)); /* never realloc actual pointer to data */
/* if realloc fails pointer set to NULL */
if (!tmp) /* validate realloc succeeded */
{
fprintf (stderr, "\nerror: reallocation failed.\n\n"); /* if realloc fails, error and exit */
return 1;
}
firstNames = tmp; /* now assign to pointer */
for (i = amount; i < sum; i++) /* why new var count, use i */
{
firstNames[i] = malloc (sizeof (**firstNames)); /* allocate new Names, prompt & store */
printf (" first name for user %d : ", i + 1);
scanf ("%m[^\n]%*c", &firstNames[i]);
}
print_users (firstNames, sum);
free_memory (firstNames, sum);
return 0;
}
void print_users (char **array, int sz)
{
printf ("\nUsers firstNames:\n\n"); /* output users collecte in firstNames */
int i = 0;
for (i = 0; i < sz; i++)
printf (" user[%d] %s\n", i, array[i]);
}
void free_memory (char **array, int sz)
{
int i = 0;
for (i = 0; i < sz; i++) /* free allocated memory */
if (array[i])
free (array[i]);
if (array)
free (array);
}
Example Usage:
$ ./bin/reallocptr
Enter the number of records to enter: 2
first name for user 1 : Jack
first name for user 2 : Jill
Any *additional* users to add: 2
first name for user 3 : Mike
first name for user 4 : Moe
Users firstNames:
user[0] Jack
user[1] Jill
user[2] Mike
user[3] Moe
Note: See Addendum below, otherwise 4-bytes of memory will remain un-freed at exit.
Addendum
As was pointed out, only a single char was allocated to each of the firstName[i] pointers which was insufficient for the full strings assigned. Generally, in practice firstName[i] string allocation can be handled automatically with functions such as strdup or scanf with an appropriate format string. To fully handle the strings with scanf, the following changes are required:
//Declaring dynamic array for first names
char **firstNames = calloc (amount, sizeof (*firstNames)); /* using your variable for sizeof (x) */
for (i = 0; i < amount; i++) /* prevents mistaken sizeof (wrong) */
{ /* calloc initializes to NULL (zero) */
// firstNames[i] = malloc (sizeof (**firstNames)); /* let scanf auto-allocate */
//Prompting user for first name, last name, and scores
printf (" first name for user %d : ", i + 1);
scanf ("%m[^\n]%*c", &firstNames[i]); /* read string and newline (discarded) */
}
...
for (i = amount; i < sum; i++) /* why new var count, use i */
{
// firstNames[i] = malloc (sizeof (**firstNames)); /* allocate new Names, prompt & store */
printf (" first name for user %d : ", i + 1);
scanf ("%m[^\n]%*c", &firstNames[i]);
}
changes to free_memory()
void free_memory (char **array, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
if (array[i])
free (array[i]);
if (array)
free (array);
}
output/verification:
Enter the number of records to enter: 2
first name for user 1 : Jack
first name for user 2 : Jill
Any *additional* users to add: 2
first name for user 3 : Larry
first name for user 4 : Moe
Users firstNames:
user[0] Jack
user[1] Jill
user[2] Larry
user[3] Moe
==13690==
==13690== HEAP SUMMARY:
==13690== in use at exit: 0 bytes in 0 blocks
==13690== total heap usage: 10 allocs, 10 frees, 468 bytes allocated
==13690==
==13690== All heap blocks were freed -- no leaks are possible

Answer 2

char **firstNames = (char**)malloc(amount * sizeof(char));
This is a double pointer and memory needs to be allocated for pointers which points to your information.
So it should be
char **firstNames = malloc(amount * sizeof(char *));/* No need to cast malloc() */
Later you are doing realloc() for this memory and it is necessary for you to take care of realloc() failures.So use a temporary pointer to store the return value of realloc() and assign the address back to your firstNames.
firstNames[i] = (char*)malloc(1 * sizeof(char));
You are allocating a single byte here in each iteration in order to read strings you need more memory than this.

Answer 3

Some corrections in your memory allocations.
#define SIZE 10
char **firstNames = malloc(amount * sizeof(char *));
for (i = 0; i < amount; i++)
{
firstNames[i] = malloc(SIZE * sizeof(char));
}
First malloc is allocating memory for no of entries you want to store.
Since the entry are pointers to another memory, use malloc(amount * sizeof(char *))
The second malloc is nothing but, allocating memory for the actual strings you wan to store.
Where SIZE is the no of bytes for each entry.
So now you want to add more users, so you use realloc.
int sum = amount + add;
firstNames = realloc(firstNames, sum * sizeof(char *));
/* Add the following to your code */
for (i = amount; i < sum; i++)
firstNames[i] = malloc(SIZE * sizeof(char));
printf("Total Names: \n");
for ( i = 0; i < sum; i++)
printf("%s\n", firstNames[i]);
Here the second malloc is used for allocating memory for the newly added users.
It starts from (i = amount), since till amount memory is already allocated.