How do i check argv[1] doesn't have any alphabetical characters?

Question

This has been driving my entire C++ class nuts, none of us has been able to find a solid solution to this problem. We are passing information to our program through the Terminal, via argv* [1]. We would call our program ./main 3 and the program will run 3 times.

The problem comes when we are validating the input, we are trying to cover all of our bases and for most of them we are good, like an alphabetical character entered, a negative number, 0, etc. But what keeps passing through is an int followed by a str for example ./main 3e or ./main 1.3. I've tried this ( Ashwin's answer caught my eye ) but it doesn't seem to work or at least I can't implement it in my code.

This is my code now:

int main(int argc, char * argv[]){
    if (!argv[1]) exit(0);

    int x = atoi(argv[1]);

    if (!x or x <= 0) exit(0); 

    // I would like to add another exit(0); for when the input mixes numbers and letters or doubles.

    for (int i = 0; i < x; i++){
        // rest of the main func.
    }

Answer 1

Despite the title, it sounds like you really want to do is check whether every single character in the input argument is a digit. You can achieve this by iterating over it, checking that every element is a digit using std::isdigit.

Here's a sketch using the std::all_of algorithm:

size_t len = strlen(argv[1]);
bool ok = std::all_of(argv[1], argv[1] + len,
                      [](unsigned char c) { return std::isdigit(c); } );

You can add an extra check for the first element being '0' if needed.

Answer 2

If you want to convert a string to a number and verify that the entire string was numeric, you can use strtol instead of atoi. As an additional bonus, strtol correctly checks for overflow and gives you the option of specifying whether or not you want hexadecimal/octal conversions.

Here's a simple implementation, with all the errors noted (printing error messages from a function like this is not a good idea; I just did it for compactness). A better option might be to return an error enum instead of the bool, but this function returns a std::pair<bool, int>: either (false, <undefined>) or (true, value):

std::pair<bool, int> safe_get_int(const char* s) {
  char* endptr;
  bool ok = false;
  errno = 0; /* So we can check ERANGE later */
  long val = strtol(s, &endptr, 10); /* Don't allow hex or octal. */
  if (endptr == s) /* Includes the case where s is just whitespace */
     std::cout << "You must specify some value." << '\n';
  if (*endptr != '\0')
     std::cout << "Argument must be an integer: " << s << '\n';
  else if (val < 0)
     std::cout << "Argument must not be negative: " << s << '\n';
  else if (errno == ERANGE || val > std::numeric_limits<int>:max())
     std::cout << "Argument is too large: " << s << '\n';
  else
     ok = true;
  return std::make_pair(ok, ok ? int(val) : 0);
}

In general, philosophical terms, when you have an API like strtol (or, for that matter, fopen) which will check for errors and deny the request if an error occurs, it is better programming style to "try and then check the error return", than "attempt to predict an error and only try if it looks ok". The second strategy, "check before use", is plagued with bugs, including security vulnerabilities (not in this case, of course, but see TOCTOU for a discussion). It also doesn't really help you, because you will have to check for error returns anyway, in case your predictor was insufficiently precise.

Of course, you need to be confident that the API in question does not have undefined behaviour on bad input, so read the official documentation. In this case, atoi does have UB on bad input, but strtol does not. (atoi: "If the value cannot be represented, the behavior is undefined."; contrast with strtol)