size_t vs long

[divine fallacy]

I understand that size_t is used to:

(1) optimize performance; and
(2) improve portability

when storing integer values that represent bytes, but the following code
from cplusplus.com appears to be inconsistent:

 long lSize;
  size_t result;

result = fread (buffer,1,lSize,pFile);
  if (result != lSize) {fputs ("Reading error",stderr); exit (3);}

If result is going to be compared to lSize, why not make them both size_t
variables? Why is lSize long and result size_t?

CONTEXT

/* fread example: read an entire file */
#include <stdio.h>
#include <stdlib.h>

int main () {
  FILE * pFile;
  long lSize;
  char * buffer;
  size_t result;

  pFile = fopen ( "myfile.bin" , "rb" );
  if (pFile==NULL) {fputs ("File error",stderr); exit (1);}

  // obtain file size:
  fseek (pFile , 0 , SEEK_END);
  lSize = ftell (pFile);
  rewind (pFile);

  // allocate memory to contain the whole file:
  buffer = (char*) malloc (sizeof(char)*lSize);
  if (buffer == NULL) {fputs ("Memory error",stderr); exit (2);}

  // copy the file into the buffer:
  result = fread (buffer,1,lSize,pFile);
  if (result != lSize) {fputs ("Reading error",stderr); exit (3);}

  /* the whole file is now loaded in the memory buffer. */

  // terminate
  fclose (pFile);
  free (buffer);
  return 0;
}

[Peter87]

I think lSize is of type long because the return value of ftell is long, and result is size_t because fread returns size_t.

[vlad from moscow]

This code is written provided that sizeof( size_t ) is equal to sizeof( long ). But this assumption is valid only for 32-bit systems. So this code is depended on the system where it is used. Of course it is a bad code but it is not easy to write system-independent code where functions fread and ftell are used simultaneously. I can point another drawback in the statement

buffer = (char*) malloc (sizeof(char)*lSize);

Again if sizeof( size_t ) is less than long then there is a truncation of the expression sizeof(char)*lSize.

[divine fallacy]

How would size_t be less than long? Isn't size_t used precisely because it
is guaranteed to be big enough to contain the size of the biggest object
the system can handle -- i.e., larger than long, by definition.

[Peter87]

size_t is big enough to store the size of any object

size_t sizeOfLong = sizeof(long);

but that doesn't mean size_t has the same size as the biggest object. That would be a waste of memory.