noob question about long int use

[jimtuv]

I am just starting to learn C. I am learning about loops and thought it would be a good idea to look at some sample source code to see as many examples as I could find on the subject. I found some samples here: C / ANSI-C examples (example source code) Organized by topic

This is the example I don't understand

This code counts backward and sums as it goes.

#include <stdio.h>
void main() {
  
  long sum = 0L;  
  
  int count = 10;  /* The number of integers to be summed */
  
  int i = 0;      /* The loop counter                    */


  /* Sum integers from count to 1 */
  for (i = count ; i >= 1 ; sum += i-- );

  printf("\nTotal of the first %d numbers is %ld\n", count, sum);
}

They use

long sum = 0L;

This seems odd seeing that the total possible sum cant be more then 60. From the reading I have done so far it seems to me long int doubles the storage requirements of the int from 4 to 8 bytes. Maybe I am missing something here but the number 55 should not required the extra bytes. Is this the best way to handle this or would

 int sum = 0;

do just as well. I was wondering if anyone could explain why they used the long int for this purpose.

[Kennedy]

#include <stdio.h>

int main(void)
{
        printf("sizeof char = %i\n", sizeof(char));
        printf("sizeof short = %i\n", sizeof(short));
        printf("sizeof int = %i\n", sizeof(int));
        printf("sizeof long = %i\n", sizeof(long));
        printf("sizeof long int = %i\n", sizeof(long int));
        printf("sizeof long long = %i\n", sizeof(long long));
        printf("sizeof long long int = %i\n", sizeof(long long int));
//      printf("sizeof long long long = %i\n", sizeof(long long long)); //compiler error.
        return 0;
}

sizeof char = 1
sizeof short = 2
sizeof int = 4
sizeof long = 4
sizeof long int = 4
sizeof long long = 8
sizeof long long int = 8

[grumpy]

I was wondering if anyone could explain why they used the long int for this purpose.

Possibly because they wanted to allow for larger initial values of "count" than 10.

You might also wish to ponder whether an int is required to be 4 bytes. Can it be less?

[sbaginov]

They use

long sum = 0L;

This seems odd seeing that the total possible sum cant be more then 60. From the reading I have done so far it seems to me long int doubles the storage requirements of the int from 4 to 8 bytes. Maybe I am missing something here but the number 55 should not required the extra bytes..

When you code, you always have to think about the future use of it. Now you can read just numbers less than or equal to 100, because you type them and you are lazy!, but tomorrow, in real life, your code will have to read something like 32000, 31045, 29087 and then! an overflow might occurr after a few steps: though the values you read might even be stored by a short, their manipulation might easily produce results that exceed the short capacity: this is why one might choose long or even double...

[Elysia]

When you code, you always have to think about the future use of it. Now you can read just numbers less than or equal to 100, because you type them and you are lazy!, but tomorrow, in real life, your code will have to read something like 32000, 31045, 29087 and then! an overflow might occurr after a few steps: though the values you read might even be stored by a short, their manipulation might easily produce results that exceed the short capacity: this is why one might choose long or even double...

Then you can just change the type easily...

#include <stdio.h>

int main(void)
{
        printf("sizeof char = %i\n", sizeof(char));
        printf("sizeof short = %i\n", sizeof(short));
        printf("sizeof int = %i\n", sizeof(int));
        printf("sizeof long = %i\n", sizeof(long));
        printf("sizeof long int = %i\n", sizeof(long int));
        printf("sizeof long long = %i\n", sizeof(long long));
        printf("sizeof long long int = %i\n", sizeof(long long int));
//      printf("sizeof long long long = %i\n", sizeof(long long long)); //compiler error.
        return 0;
}

sizeof char = 1
sizeof short = 2
sizeof int = 4
sizeof long = 4
sizeof long int = 4
sizeof long long = 8
sizeof long long int = 8

Sizes aren't guaranteed by the standard. This is only the output of a specific platform and compiler.

[Kennedy]

Sizes aren't guaranteed by the standard. This is only the output of a specific platform and compiler.

I kinda expected the OP to use the code to see what values that machine/compiler use. MOST computers/compilers these days will have the above lengths -- no, it is not a fully qualified standard, but it does seem to be the de facto.

[jimtuv]

Thank you so much for your help. I see that choosing weather to use long is a good idea if you are not sure of the future use of the code or there are concerns that the result may in some way exceed the capacity of the variable. It seems to me though that adding in some error checking to make sure that any input would not exceed the variables size would also be a good idea.

As for the size of int I would think logically the smallest size would be short int 2 bytes. Though it would stand to reason you could store an unsigned integer between 1 and 255 in one byte. But I wouldn't be surprised to find I am wrong. I am just starting out in all of this.

[brewbuck]

This seems odd seeing that the total possible sum cant be more then 60.

Now that's just crazy talk. If the actual, real world value of count was always fixed at 10, then you already know the answer -- it's 55 -- and this code shouldn't even exist.

[jimtuv]

Now that's just crazy talk. If the actual, real world value of count was always fixed at 10, then you already know the answer -- it's 55 -- and this code shouldn't even exist.

Thats nice one call me lazy and another crazy for asking about some else's code because it seemed odd to me, and I have all of 5 days experience in C. Nice place you all have here. really encouraging. don't worry I will figure it out with out help.

[claudiu]

Thats nice one call me lazy and another crazy for asking about some else's code because it seemed odd to me, and I have all of 5 days experience in C. Nice place you all have here. really encouraging. don't worry I will figure it out with out help.

It's actually a decent place to get answers to questions. You have to realize everyone here is doing this out of their own time completely pro-bono. So don't get so upset all of the sudden. Come back for more questions.

[Elysia]

Thank you so much for your help. I see that choosing weather to use long is a good idea if you are not sure of the future use of the code or there are concerns that the result may in some way exceed the capacity of the variable. It seems to me though that adding in some error checking to make sure that any input would not exceed the variables size would also be a good idea.

For the future is probably a moot point. If you need bigger variables in the future, you can just change the size. You are not at a stage where it's absolutely critical to do it right the first time around.
Also, checking input is always a good idea, but it can be tricky, especially when it comes to stuff like overflow. Although if you get the raw string input and use strtol, you can actually verify if there was overflow and underflow.

As for the size of int I would think logically the smallest size would be short int 2 bytes. Though it would stand to reason you could store an unsigned integer between 1 and 255 in one byte. But I wouldn't be surprised to find I am wrong. I am just starting out in all of this.

I would be careful with the words there. An int is not a short int. A short int can be shortened to short, but not int. Also, an int cannot be 1 byte. The standard guarantees that short int shall be greater than char, which is always 1 one.
char < short int <= int <= long int <= long long int, I believe.

[cyberfish]

I kinda expected the OP to use the code to see what values that machine/compiler use. MOST computers/compilers these days will have the above lengths -- no, it is not a fully qualified standard, but it does seem to be the de facto.

Most compilers for microcontrollers (8 bit and 16 bit) use 16-bit ints and 32-bit longs.