Trying to read a positive value in c - c

Question

i just want to make sure that i read a positive value for x not sure whats wrong here
#include <stdio.h>
void main() {
unsigned x;
int i;
do {
printf("donner un nombre\n");
scanf("%u", &x);
} while (x <= 1);
/*
for (i = 0; i++; i < x) {
int prime = 0;
int x = 2;
do {
if (i % x == 0 ) {
prime = 1;
}
x++;
} while (prime == 0 && x < i);
if (prime == 0) {
printf("%i",i);
}
}
*/
}

Answer 1

Unsigned is bad choice
First at all you change unsigned type to integer int, that alloved you to scan negative numbers such as -1, -5,...
Wrong condition in loop
Also there is bug in do while loop, where you scan until the x <= 1 but number 1 is positive number, so you have to change it to x < 1
Final code will looks like this:
#include <stdio.h>
int main() {
int x;
do {
printf("donner un nombre\n");
scanf("%u", &x);
} while (x < 1);
// your code working with positive x
return 0;
}

Answer 2

Reading input, especially when it involves a numeric conversion is something done time and time again. It's worth taking the time to understand how to do it properly.
For starters, using scanf() for user-input can be done, but it is so full of pitfalls for the new C programmer that it is highly discouraged. This is due to the state that scanf() leaves your input buffer in both after good input (with potential additional characters and the '\n' left unread), and after invalid input (where all characters from the point of matching-failure forward are left unread). To avoid all of these pitfalls, simply read all input into a sufficiently sized buffer (character array) with fgets() and then convert the contents of the array as needed.
Why fgets() and a sufficiently sized buffer? fgets() reads an entire line of input (including the trialing '\n' produced by the user pressing Enter ensuring the input buffer (stdin in your case) is left in a proper state for your next read.
To convert the contents of the array to an integer value, strtol() provides the most robust diagnostics and error reporting in the event the user failed to enter a valid integer, but using sscanf() for the conversion at least provides a valid success/failed indication through its return.
(you couldn't have used scanf() correctly to begin with without checking the return)
How To Read User Input?
The approach is simple, and it virtually the same for any input needed. You simply:
loop continually prompting for input until a valid input is provided by the user (your read-loop),
read the user input into a sufficiently sized buffer (don't skimp on buffer size),
check if the user canceled input by generating a manual EOF by pressing Ctrl + d (or Ctrl + z on windows),
attempt conversion of the contents of your buffer as needed (to int in your case) checking the return of the conversion function used,
if the input is valid, check against any other constraints you have (positive int in your case)
if all conditions for good input met -- break out of the read-loop, otherwise,
handle the invalid input, and loop again.
No matter what you need to get from the user, you can use this approach. It's something you use so often, it makes sense to put it in a function you can call any time you need that type of input. For an int value, where you can provide an optional prompt to the user to be displayed, you can do something similar to:
...
#define MAXC 256 /* if you need a constant, #define one (or more) */
/* read integer value from 'fp', update value at 'val' address.
* returns 1 on success, 0 if user cancels input with ctrl+d (or
* ctrl+z on windows)
*/
int read_int (int *val, FILE *fp, const char *prompt)
{
char buf[MAXC]; /* buffer (char array) to hold line of input */
for (;;) { /* loop continually until valid input or user cancels */
if (prompt) { /* if prompt not NULL, display */
fputs (prompt, stdout);
}
if (!fgets (buf, MAXC, fp)) { /* read/validate line of input */
puts ("(user canceled input)");
return 0;
}
/* attempt conversion to int validating return/handle error */
if (sscanf (buf, "%d", val) != 1) {
fputs (" error: invalid integer input.\n", stderr);
}
else { /* otherwise, valid int received */
break; /* break input loop */
}
}
return 1; /* return success */
}
The function above will require the user to enter a valid integer, looping displaying the prompt and handling any input errors until the user does while still allowing the user to cancel input with a manual EOF. What it doesn't do is apply your constraint of requiring a positive value. This you add as an additional requirement where you call read_int() in your code.
For example, in main()1 since you need a positive value, you simply call the read_int() function in another continual loop until a positive value is returned (handling the manual EOF case as well). That can look like the following:
int main (void) { /* proper invocation of main unless on freestanding sys */
int x = 0;
for (;;) { /* loop continually prompting for input until x positive */
/* validate return of read_int() checking if user canceled */
if (read_int (&x, stdin, "donner un nombre: ") == 0) {
return 0; /* graceful exit on cancel -- not an error */
}
if (x > 0) { /* test x in acceptable range (positive) */
break; /* break read loop */
}
/* handle x outside of range */
fputs (" error: invalid input, must be postive integer.\n", stderr);
}
printf ("\npostivie x: %d\n", x);
}
(note: above you simply apply a continual loop again, looping until the int value is in the range of positive integers -- handle the 0 case however you want to consider it)
If you need to cover the entire range of unsigned, then change the function to be read_long() (and change the types appropriately). Then in main() you can #include <limits.h> and test if (0 < x && x <= UINT_MAX) for input in range.
Putting it altogether simply requires adding #include <stdio.h> at the top, e.g.
#include <stdio.h>
#define MAXC 256 /* if you need a constant, #define one (or more) */
/* read integer value from 'fp', update value at 'val' address.
* returns 1 on success, 0 if user cancels input with ctrl+d (or
* ctrl+z on windows)
*/
int read_int (int *val, FILE *fp, const char *prompt)
{
char buf[MAXC]; /* buffer (char array) to hold line of input */
for (;;) { /* loop continually until valid input or user cancels */
if (prompt) { /* if prompt not NULL, display */
fputs (prompt, stdout);
}
if (!fgets (buf, MAXC, fp)) { /* read/validate line of input */
puts ("(user canceled input)");
return 0;
}
/* attempt conversion to int validating return/handle error */
if (sscanf (buf, "%d", val) != 1) {
fputs (" error: invalid integer input.\n", stderr);
}
else { /* otherwise, valid int received */
break; /* break input loop */
}
}
return 1; /* return success */
}
int main (void) { /* proper invocation of main unless on freestanding sys */
int x = 0;
for (;;) { /* loop continually prompting for input until x positive */
/* validate return of read_int() checking if user canceled */
if (read_int (&x, stdin, "donner un nombre: ") == 0) {
return 0; /* graceful exit on cancel -- not an error */
}
if (x > 0) { /* test x in acceptable range (positive) */
break; /* break read loop */
}
/* handle x outside of range */
fputs (" error: invalid input, must be postive integer.\n", stderr);
}
printf ("\npostivie x: %d\n", x);
}
Example Use/Output
Now that you have written your input routine -- go try and break it, every way you can think of -- and make sure it handles all cases correctly. Then there will always be one or two corner-cases you didn't think about you will have to fix later.
Does the input routine work, requiring a positive value?
$ ./bin/read_int_function
donner un nombre: 0
error: invalid input, must be postive integer.
donner un nombre: banannas and pickles
error: invalid integer input.
donner un nombre: ten
error: invalid integer input.
donner un nombre: 10
postivie x: 10
What about handling the user canceling input?
$ ./bin/read_int_function
donner un nombre: foo
error: invalid integer input.
donner un nombre: (user canceled input)
Handling user-input is one area that gives new C programmers no end of grief. Best to take the time and think through it now, learning how to correctly approach it. Doing so will save you a great deal of time and frustration.
Let me know if you have further questions.
Footnotes:
1.) Unless you are programming in a freestanding environment (without the benefit of any OS), in a conforming implementation, the allowable declarations for main for are int main (void) and int main (int argc, char *argv[]) (which you will see written with the equivalent char **argv). See: C11 Standard - §5.1.2.2.1 Program startup(p1). See also: What should main() return in C and C++? In a freestanding environment, the name and type of the function called at program startup are implementation-defined. See: 5.1.2.1 Freestanding environment

Answer 3

If you are using Linux as a development environment, you can take a look at man 3 scanf. This will give you the function's documentation.
That being said, the function returns a number which indicates how many valid inputs were read.
Knowing that, you can read a positive integer with the following code to check for read status:
int rc;
unsigned int x;
rc = scanf("%u", &x);
if (rc == 1) {
// valid input data
}