Taking it one step beyond your original approach, do not take user input with scanf() and never user scanf() without checking the return. Why? scanf() is full of pitfalls for the new C programmer because characters will remain unread in stdin just waiting to bite you again if a matching failure occurs. Further, using scanf() to read into a string without providing a field-width modifer is just as unsafe and subject to explain as using gets(). See Why gets() is so dangerous it should never be used!
Instead, use a line-oriented input function like fgets() with an adequate sized buffer to read all user-input (don't skimp on buffer size, adjust if you are programming on a micro-controller, otherwise a 1K buffer is fine) This ensures that all characters entered by the user (in all but extreme cases of the cat stepping on the keyboard) are read and nothing will remain in stdin where it can effect your next attempted input. You can also use POSIX getline() which is the second commonly used line-oriented input function.
The only caveat using line-oriented input function is that they read and include the trailing '\n' in the buffer they fill. It isn't a problem, simply use strcspn() to get the number of character before the '\n' character and then overwrite the trailing '\n' with the nul-terminating character '\0', equivalent to plain old 0. See man 3 strspn E.g. if you read into a buffer, say char buf[1024] and you need to trim the trialing newline, simply use:
buf[strcspn (buf, "\n")] = 0;
(you can include the '\r' carriage-return as well if on windows to trim beginning with whichever occurs first, such as if a DOS line-ending mysteriously made its way into the input using "\r\n" as the delimiter)
Don't #include <conio.h> as a header. It is an anachronism from the DOS days and is 100% non-portable to anything other than windows.
Putting It To Use To Read 1-Employee At A Time
In your case, and following your comment below @paddy's answer, you don't want to write your "add" function to "add" a specific number of anything, you want to write your add function to add one employee and to perform error detection and reporting though the return so you know whether the add succeeded or failed and how it failed. To make things easier, you can use a typedef for your struct, so you can refer to employee as a type rather than having to refer to struct manager, e.g.
#define NEMP 3 /* if you need a constant, #define one (or more) */
#define MAXNM 20
#define MAXC 1024
typedef struct { /* typedef makes working with structs convenient */
char name[MAXNM];
unsigned age, salary;
} employee;
Now you can declare your add function to take an array of employee as a parameter and return an int with 1 indicating success, 0 indicating an error in input (such as someone entering "five" instead of 5 as a value) or returning -1 if the user cancels input by generating a manual EOF by pressing Ctrl+d or Ctrl+z on windows. You begin your function definition by declaring an adequately sized buffer for user input and a variable to use to check the length of name before copying to your struct, e.g.
int addemployee (employee *e)
{
char buf[MAXC];
size_t len;
To take the input for name (no need to prompt with printf() there are no conversions, just use fputs() which provides line-end control, compared to puts() and then validate the return by checking whether it is NULL indicating the user canceled input, trim the newline from buf and then copy to your employee name, e.g.
fputs ("\nemployee name : ", stdout); /* no conversion - use fputs */
if (fgets (buf, MAXC, stdin) == NULL) { /* read all input with fgets() */
fputs ("(user canceled input)\n", stderr); /* validate EVERY input */
return -1;
}
len = strcspn (buf, "\r\n"); /* length before either "\r\n" */
if (len >= MAXNM) { /* validate length */
fputs ("error: name too long.\n", stderr);
return 0;
}
buf[len] = 0; /* trim trailing '\n' */
memcpy (e->name, buf, len + 1); /* copy to name */
(you don't need strcpy() because you already know the length of the string, so there is no need to have strcpy() scan for the end-of-string again, just use memcpy())
For age and salaray, the approach is identical. Read with fgets() and then convert and validate the conversion using sscanf(), validating all the way:
fputs ("employee age : ", stdout); /* prompt for age */
if (!fgets (buf, MAXC, stdin)) { /* validate EVERY input */
fputs ("(user canceled input)\n", stderr);
return -1;
}
if (sscanf (buf, "%u", &e->age) != 1) { /* validate conversion */
fputs ("error: invalid unsigned input\n", stderr);
return 0;
}
(note: you do not need to trim the '\n' from buf when converting to a numeric value as the '\n' is whitespace and will be ignored by the conversion)
When you need to output each employee, now write a function that takes the array of employee and the number of employees contained and output each, e.g.
void prnemployees (employee *e, int n)
{
for (int i = 0; i < n; i++)
printf ("\n%s\n age : %u\n salary : %u\n",
e[i].name, e[i].age, e[i].salary);
}
With those two functions, your main() function reduces to simply declaring an array of employee and then looping while the number of valid employees entered is less than the array size, only incrementing your employee count on a successful return from addemployee(). Print the employees when done, e.g.
int main (void) {
int n = 0; /* input counter */
employee emp[NEMP] = {{ .name = "" }}; /* array of employee, initialize all zero */
while (n < NEMP) {
int result = addemployee (&emp[n]); /* add employee VALIDATE return */
if (result == -1) /* if user canceled, stop input */
break;
else if (result == 1) /* if good input, increment count */
n++;
/* for 0 return, do nothing, error message output in funciton */
}
prnemployees (emp, n);
}
Putting it altogether, you would have:
#include <stdio.h>
#include <string.h>
#define NEMP 3 /* if you need a constant, #define one (or more) */
#define MAXNM 20
#define MAXC 1024
typedef struct { /* typedef makes working with structs convenient */
char name[MAXNM];
unsigned age, salary;
} employee;
int addemployee (employee *e)
{
char buf[MAXC];
size_t len;
fputs ("\nemployee name : ", stdout); /* no conversion - use fputs */
if (fgets (buf, MAXC, stdin) == NULL) { /* read all input with fgets() */
fputs ("(user canceled input)\n", stderr); /* validate EVERY input */
return -1;
}
len = strcspn (buf, "\r\n"); /* length before either "\r\n" */
if (len >= MAXNM) { /* validate length */
fputs ("error: name too long.\n", stderr);
return 0;
}
buf[len] = 0; /* trim trailing '\n' */
memcpy (e->name, buf, len + 1); /* copy to name */
fputs ("employee age : ", stdout); /* prompt for age */
if (!fgets (buf, MAXC, stdin)) { /* validate EVERY input */
fputs ("(user canceled input)\n", stderr);
return -1;
}
if (sscanf (buf, "%u", &e->age) != 1) { /* validate conversion */
fputs ("error: invalid unsigned input\n", stderr);
return 0;
}
fputs ("employee salary : ", stdout); /* prompt for salary */
if (!fgets (buf, MAXC, stdin)) { /* validate EVERY input */
fputs ("(user canceled input)\n", stderr);
return -1;
}
if (sscanf (buf, "%u", &e->salary) != 1) { /* validate conversion */
fputs ("error: invalid unsigned input\n", stderr);
return 0;
}
return 1;
}
void prnemployees (employee *e, int n)
{
for (int i = 0; i < n; i++)
printf ("\n%s\n age : %u\n salary : %u\n",
e[i].name, e[i].age, e[i].salary);
}
int main (void) {
int n = 0; /* input counter */
employee emp[NEMP] = {{ .name = "" }}; /* array of employee, initialize all zero */
while (n < NEMP) {
int result = addemployee (&emp[n]); /* add employee VALIDATE return */
if (result == -1) /* if user canceled, stop input */
break;
else if (result == 1) /* if good input, increment count */
n++;
/* for 0 return, do nothing, error message output in funciton */
}
prnemployees (emp, n);
}
Example Use/Output
With intentional errors in input:
$ ./bin/addemployee
employee name : Mickey Mouse
employee age : 92
employee salary : 200000
employee name : Minnie Mouse
employee age : too old
error: invalid unsigned input
employee name : Minnie Mouse
employee age : 92
employee salary : 250000
employee name : Pluto (dog)
employee age : 90
employee salary : bone
error: invalid unsigned input
employee name : Pluto (dog)
employee age : 90
employee salary : 10000
Mickey Mouse
age : 92
salary : 200000
Minnie Mouse
age : 92
salary : 250000
Pluto (dog)
age : 90
salary : 10000
The point being that user-input in C isn't difficult, but new C programmers generally make it difficult by choosing the wrong tool for the job and failing to check the return of the tool they do choose -- usually scanf(). Don't get me wrong, scanf() can be used properly for user-input, but until you have read, word-for-word man 3 scanf and understand every caveat and which conversion specifiers discard whitespace and which don't -- don't use it. Use a line-oriented approach with an appropriately size buffer and trim the '\n' if you are using the buffer as a character string.
Let me know if you have any further questions.
