Forget about ASCII code checks, use isdigit or isnumber (see man isnumber). The first function checks whether the character is 0–9, the second one also accepts various other number characters depending on the current locale.

There may even be better functions to do the check – the important lesson is that this is a bit more complex than it looks, because the precise definition of a “number string” depends on the particular locale and the string encoding.

Have a look at strtol(), it can tell you about invalid parts of the string by pointer return.

And beware of enthusiastic example code.. see the man page for comprehensive error-handling.

num will always contain an integer because it's an int. The real problem with your code is that you don't check the scanf return value. scanf returns the number of successfully read items, so in this case it must return 1 for valid values. If not, an invalid integer value was entered and the num variable did probably not get changed (i.e. still has an arbitrary value because you didn't initialize it).

As of your comment, you only want to allow the user to enter an integer followed by the enter key. Unfortunately, this can't be simply achieved by scanf("%d\n"), but here's a trick to do it:

Copyint num;
char term;
if(scanf("%d%c", &num, &term) != 2 || term != '\n')
    printf("failure\n");
else
    printf("valid integer followed by enter key\n");

Parameters passed by command line are always strings, if you want to check if this string can be converted to integer you can use strtol:

char *ptr = argv[1];
long num;

num = strtol(ptr, &ptr, 10);
if (*ptr == '\0')
    /* arg is a number */
else
    /* arg is NOT a number */

The most efficient way would be just to iterate over the string until you find a non-digit character. If there are any non-digit characters, you can consider the string not a number.

bool is_number(const std::string& s)
{
    std::string::const_iterator it = s.begin();
    while (it != s.end() && std::isdigit(*it)) ++it;
    return !s.empty() && it == s.end();
}

Or if you want to do it the C++11 way:

bool is_number(const std::string& s)
{
    return !s.empty() && std::find_if(s.begin(), 
        s.end(), [](unsigned char c) { return !std::isdigit(c); }) == s.end();
}

As pointed out in the comments below, this only works for positive integers. If you need to detect negative integers or fractions, you should go with a more robust library-based solution. Although, adding support for negative integers is pretty trivial.

According with the man page of strtol. You must define your function such as:

bool isNumeric(const std::string& str) {
    char *end;
    long val = std::strtol(str.c_str(), &end, 10);
    if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) || (errno != 0 && val == 0)) {
        //  if the converted value would fall out of the range of the result type.
        return false;   
    }
    if (end == str) {
       // No digits were found.
       return false;
    }
    // check if the string was fully processed.
    return *end == '\0';
}

In C++11, I prefer to use std::stol instead of std::strtol, such as:

bool isNumeric(const std::string& str) {
    try {
        size_t sz;
        std::stol(str, &sz);
        return sz == str.size();
    } catch (const std::invalid_argument&) {
        // if no conversion could be performed.
        return false;   
    } catch (const std::out_of_range&) {
        //  if the converted value would fall out of the range of the result type.
        return false;
    }
}

std::stol calls std::strtol, but you works directly with std::string and the code is simplified.