Using getchar() to store address of string literal in char*pointer - c

Question

The goal is storing the adress of a string litteral in a char*, which is a member of struct
id. I thought about using an array.
The problem with array is that, if I set the maximum number of character to 7, the user
might enter less than 7, so it will be a waste of memory.
The advantage using getchar() is that I can set max of char to 7, but if user enter less, that's ok too.
typedef struct id
{
int age;
char* name;
}id;
id Mary;
char L;
int c =0;
printf("Enter your age: ");
scanf("%d",&Mary.age);
printf(" Enter your name: );
if( (L=getchar() != '\n' )
{
// stroring string litteral in char*
}
printf("%s", Mary.name);

Answer 1

This is a common problem: "How do I read an input string of unknown length?" Daniel Kleinstein has mentioned several general solutions in his answer. I'll give a more implementation-based answer here
Firstly, your program does not try to store a string literal, but a string read from an input stream (e.g. stdin).
Secondly, it is not possible to store a string "in a char*". The string is stored in memory pointed to by a char*. This memory needs to be allocated first.
The following code comes closest to what you want to do. It reads one character at a time and increases the size of the memory copied to by 1 byte every time.
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int age;
char *name;
} Id;
int main(void)
{
Id mary;
printf(" Enter your name: ");
size_t nameSize = 0U;
mary.name = NULL;
while (true)
{
mary.name = (char*) realloc(mary.name, ++nameSize); // cast is optional
if (mary.name == NULL)
{
printf("Memory allocation error\n");
exit(EXIT_FAILURE);
}
int ch = getchar(); // Note the `int` type, necessary to detect EOF
if (ch == '\n' || ch == EOF)
{
mary.name[nameSize - 1] = '\0';
break;
}
mary.name[nameSize - 1] = (char) ch;
}
printf("%s\n", mary.name);
free(mary.name);
}
This does not waste a single byte of memory, however, the frequent memory reallocations will make this code slow. A good compromise is to read one fixed length string at a time, instead of one character at a time.
To do this in practice: create a buffer on the stack of fixed length (e.g. 64 characters), read into that buffer using fgets, and copy that contents to mary.name. If the string didn't fit the buffer, repeatedly call fgets again, realloc mary.name and append the contents of the buffer to mary.name until you find a newline character.
Another, simpler solution is to set a maximum length for the string, allocate memory for that length, read a string of maximally that length, and finally reallocate the memory to the (possibly smaller) actual size of the string.

Answer 2

There isn't a magic bullet solution for this sort of problem.
Your options are:
Use an array with a maximum length - but as you mentioned this can be wasteful if the user inputs a shorter length. Nevertheless this is usually the solution you'll find in real code - in practice, if memory isn't a huge concern, this is faster and simpler than trying to deal with other dynamic solutions that involve memory allocations.
Ask the user for the length of their name before they input it - then you can dynamically allocate an appropriately sized buffer using either char* name = malloc(input_length);, or char name[input_length]; in C99+. You could also do something like a flexible array member:
struct name {
size_t length;
char buffer[];
};
struct name* username = malloc(sizeof(*username) + username_length);
If you don't want to ask the user for the length of the username, you can do a chain of realloc calls after each new getchar, which will resize a dynamically allocated array - but this a terrible idea which you shouldn't even consider unless you're stressed over every byte of memory consumed in your program.