CS50 Week 1, Credit - If comparison issue? Int size limit? - c

Question

I'm new to CS50 and C and I'm currently working on the Week 1 assignment 'Credit'. I've got most of it working, but I'm running into an issue where no matter how true I feel a statement should be, my if comparison is flagging it false. Is my logic off, or am I missing something? Is there a limit on the size of a number I can use in If comparisons?
Here's my code so far:
#include <cs50.h>
#include <stdio.h>
unsigned char cardArray[20];
unsigned long creditCard;
string cardType; //String used for checking what type of credit card has been submitted.
//int remainder;
int n = 0;//Increment array position
int x = 0;
int main(void)
{
creditCard = get_long("Input: "); //Prompt user for CC
printf("%lu", creditCard);
while(creditCard > 0 && creditCard != 0) //Take CC Int and convert to Char Array for math functions
{
cardArray[n] = (creditCard % 10); //Modulus creditCard remainder
//printf("%i\n", n); //Array indices check
creditCard = (creditCard / 10); //Reduce creditCard by factor of 10
printf("%d\n", cardArray[n]);
n += 1; //increment Array indices
}
printf("Pos 15: %d\n", cardArray[15]);
//Use if >= to check size of creditCard
if(creditCard > 1000000000000 && creditCard <= 9999999999999){printf("X3: %s\n", cardType); //Check for creditCard length of 13
if(cardArray[12] == 4){
cardType = "VISA\n";
}
}else printf("X: %s\n", cardType);
if(creditCard >= 100000000000000 && creditCard <= 999999999999999){ printf("X1: %s\n", cardType);//Check for creditCard length of 15
if(cardArray[14] == 3 && (cardArray[13] == 4 || cardArray[13] == 7)){//If 15 AND starts with 34 OR 37 then set card value to American Express
cardType = "AMEX\n";
}
}else printf("X: %s\n", cardType);
if(creditCard >= 1000000000000000 && creditCard <= 9999999999999999){printf("X2: %s\n", cardType); //Check for creditCard length of 16
if(cardArray[15] == cardArray[15]){//Does it start with 4? set card value to Visa
cardType = "VISA\n";
printf("%s", cardType);
}
else printf("X: %s\n", cardType);
if(cardArray[15] == 5 && (cardArray[14] == 1 || cardArray[14] == 2 || cardArray[14] == 3 || cardArray[14] == 4 || cardArray[14] == 5)){//Does it begin with 51, 52, 53, 54, or 55? set card value to Master Card
cardType = "MASTERCARD\n";
}
}
else cardType = "INVALID\n";
printf("%s", cardType);
}
I've tested with several printf lines to see where my code is going. If I change comparisons to something like 1 == 1 I can flag the comparison as true, but using comparisons like creditCard >= 1000000000000 will always fail, even if I'm passing along 10000000000000.

Answer 1

An unsigned long on your target is likely a 32 bit value. 232 = 4294967296, so clearly the comparison with 10000000000000 for example will always evaluate to false.
If your compiler did not issue any warnings, you should look at your compiler settings.
Change the type of creditCard to unsigned long long or better uint64_t (declared in <stdint.h>). Then you should also specify the the literal integer with the ULL suffix, eg:
creditCard >= 100000000000000ULL
However, the implementation is seriously flawed. You get the card number as an integer then convert it to a string. Since your data type will not hold a credit card number, both the string and the integer will be incorrect. Credit card numbers are not arithmetic objects, and storing as an integer is a bad idea for more reasons that just range - even a uint64_t is only good for 19 digits - which may be enough for now, but possibly not in future. The number should be received and processed as a string. The advantages are that you can perform more sophisticated validation, allow digit grouping spaces, and will not loose leading zero digits.
String comparisons on normalised digit strings (i.e. with spaces removed) will work as well as an arithmetic comparison. For example:
if( strcmp( cardNumberString, "10000000000" ) >= 0 )
achieves the same result as:
if( cardNumberUnsLongLong >= 10000000000ULL )