Module 2: Elements of C

#include <stdio.h>


/* This is a block comment. Everything between the begin-comment symbol
   and the end-comment symbol is ignored by the compiler. It is conventional 
   to use a separate line for the end-comment symbol.
*/


// This is an in-line comment.

int main (/* A strange place for a block comment */)
{
  printf ("Hello World!\n");  // Another inline comment.
}

Integer types (ANSI C99 additions shown in bold):

Let's look at an example: (source file)

#include <stdio.h>

int main ()
{
  int numDaysInYear = 365;
  long int numStarsInUniverse = 2000000000L;
  unsigned long long int largestIntegerInC = 18446744073709551615LL;

  printf ("numDaysInYear = %d\n", numDaysInYear);
  printf ("numStarsInUniverse = %ld\n", numStarsInUniverse);
  printf ("largestIntegerInC = %llu\n", largestIntegerInC);
}

• Where to declare variables:
  • Prior to C99, all variables had to be declared either at the top of a function, or globally (outside any function).
  • Since ANSI C99, variables can also be declared inside blocks, as in: (source file)

    int main ()
    {
      int numDaysInYear = 365;
      printf ("numDaysInYear = %d\n", numDaysInYear);
    
      if (numDaysInYear < 366) {
          long int numStarsInUniverse = 2000000000L;
          printf ("Thank your lucky %ld stars\n", numStarsInUniverse);
      }
      else {
          unsigned long long int numStarsInUniverse = 1844674407370955161LL;
          printf ("Thank your lucky %llu stars\n", numStarsInUniverse);
      }
    }
           

  • Two commonly used declarations in other languages (Java, C++) are NOT permitted in C:
    1. Declaration in a for-loop:

       int main ()
       {
           int i;
       
           for (i=0; i<10; i++) {        // Allowed.
               printf ("i=%d\n", i);
           }
       
           for (int j=0; j<10; j++) {    // Not allowed. j needs to be declared at the top.
               printf ("j=%d\n", j);
           }
       
       }
              

    2. Declare as needed:

       int main ()
       {
           int numDaysInYear = 365;                          // Allowed.
           printf ("numDaysInYear = %d\n", numDaysInYear);
       
           long int numStarsInUniverse = 2000000000L;        // Not allowed.
           printf ("Number of stars = %ld stars\n", numStarsInUniverse);
       }
              

  • To make matters confusing, some compilers will allow both types of declarations (for-loop, as-needed) above.
  • To be safe, you can follow ANSI C89 and always declare every needed variable at the top of the method or as a global.

• Variables can be initialized and declared in one statement, or declared and initialized separately:

  #include <stdio.h>
  
  // Declaration and assignment.
  int numDaysInYear = 365;
  
  int main ()
  {
    // Declaration.
    long int numStarsInUniverse;
  
    printf ("numDaysInYear = %d\n", numDaysInYear);
  
    // Assignment.
    numStarsInUniverse = 2000000000L;
  
    printf ("numStarsInUniverse = %ld\n", numStarsInUniverse);
  }
      

  For variety, we have declared numDaysInYear as a global variable.

• ANSI C99 has added the long long type, not available in C89 or earlier.

• The int reserved word may be left out if modifiers are present:

  int main ()
  {
    int numDaysInYear = 365;
    long numStarsInUniverse = 2000000000L;
    unsigned long long largestIntegerInC = 18446744073709551615LL;
  
    printf ("numDaysInYear = %d\n", numDaysInYear);
    printf ("numStarsInUniverse = %ld\n", numStarsInUniverse);
    printf ("largestIntegerInC = %llu\n", largestIntegerInC);
  }
     

• The letter L is appended to the end of a long constant.

• The letter LL is appended to the end of a long long constant.

Screen output:

• The printf library function is used for output to the screen.

• The arguments to printf are:

      printf (format-string [zero or more variables])
    

• The format string needs to specify all variables that follow the format string:
  • The idea is, printf will look at additional arguments only based on what's in the format string.
  • In the first printf above, the %d symbol specifies an integer.
  • Similarly, %ld specifies a long and %llu specifies an unsigned long long int.

• The format string can specify any number of variables, separated by arbitrary text, for example:

  int main ()
  {
    int numDaysInYear = 365;
    long int numStarsInUniverse = 2000000000L;
    unsigned long long int largestIntegerInC = 18446744073709551615LL;
  
    printf ("numDaysInYear = %d  numStarsInUniverse = %ld  largestIntegerInC = %llu\n", 
            numDaysInYear, numStarsInUniverse, largestIntegerInC);
  }
    

• The format string can also specify the number of significant digits to be printed out:

  int main ()
  {
    int numDaysInYear = 365;
    long int numStarsInUniverse = 2000000000L;
    unsigned long long int largestIntegerInC = 18446744073709551615LL;
  
    // Up to 5 digits:
    printf ("numDaysInYear = %5d\n", numDaysInYear);
  
    // Up to 10 digits:
    printf ("numStarsInUniverse = %10ld\n", numStarsInUniverse);
  
    // Up to 20 digits:
    printf ("largestIntegerInC = %20llu\n", largestIntegerInC);
  }
    

#include <stdio.h>

int main ()
{
  int numDaysInYear = 365;
  long int numStarsInUniverse = 2000000000L;
  unsigned long long int largestIntegerInC = 18446744073709551615LL;

  printf ("numDaysInYear = %d  numStarsInUniverse = %ld  largestIntegerInC = %llu\n",   
          numDaysInYear, numStarsInUniverse, largestIntegerInC);
}

Floating-point types:

Consider this example: (source file)

int main ()
{
  // Constant with "F" appended:
  float PI = 3.141F;

  // Constant in exponent format:
  double doublePI = 314.159265E-2;

  // Long double constant:
  long double ldoublePI = 3.14159265358979L;

  // Output in exponent format:
  printf ("float PI = %7.5e\n", PI);

  // Output in decimal format with field width and number of significant digits:
  printf ("double PI = %16.10lf\n", doublePI);

  // Long double's need to be printed as double's
  printf ("long double PI = %15.12lf\n", (double) ldoublePI);
}

• The letter F is appended to the end of a "decimal" type constant:

    float PI = 3.141F;
      

• Floating point constants can also be specified in exponent format:

    double doublePI = 314.159265E-2;
      

• The letter L is used for a long double constant.

• The print format string specifies both the total width of the field and the number of digits that follow the decimal point.

• Use %e in the format string for exponent format.

Character types:

Consider this example: (source file)

int main ()
{
  char letter = 'a';
  unsigned char letter2 = 'b';
  signed char letter3 = 'c';

  printf ("letter = %c\n", letter);
  printf ("letter2 = %c\n", letter2);
  printf ("letter3 = %c\n", letter3);
}

• For practical purposes, we almost always use char.

• There is no special print-format specifier for signed and unsigned char.

• char variables are also used to access memory on a byte-by-byte basis, as we will see shortly.

Casting

Consider this example: (source file)

int main ()
{
  int i = 5;
  long j = 6;
  double d = 3.141;

  j = i;         // Works fine. Implicit cast from int to long.
  d = i;         // Works fine. Implicit cast from int to double

  i = j;         // May not compile.
  i = d;         // May not compile.

  d = 3.141;
  i = (int) j;   // Compiles. Explicit cast from long to int.
  i = (int) d;   // Compiles. Explicit cast from double to int.

  // Cast's can be used in any expression:
  printf ("The int part of d=%lf is %d\n", d, (int) d);
}

// Declare some global integers:
int i = 5;
int j = 6;
int sum;

int main ()
{
  // Int pointer declarations:
  int *intPtr;
  int *intPtr2;
  int *intPtr3;

  // First, let's print the address of variable i:
  printf ("Variable i is located at address %lu\n", &i);

  // Now extract the address of variable i into the pointer:
  intPtr = & i;

  // Print.
  printf ("The int at memory location %lu is %d\n", intPtr, *intPtr);

  // Let's do some arithmetic.
  intPtr2 = & j;
  sum = (*intPtr) + (*intPtr2);
  printf ("The sum of %d and %d is %d\n", *intPtr, *intPtr2, sum);

  // Now for something stranger:
  printf ("The integer at location %lu is %d\n", (intPtr+1), *(intPtr+1)); 
  printf ("The integer j=%d is at location %lu\n", j, &j);

  // Let's see what the default initial value of intPtr3 is:
  if (intPtr3 == NULL) {
    printf ("intPtr3 has been initialized to NULL\n");
  }
  else {
    printf ("intPtr3 has been initialized to %lu\n", intPtr3);
  }

}

int main ()
{
  int i = 5;
  char *charPtr;  // Pointer declaration
  int j;

  // Make the char pointer point to the start of the integer:
  charPtr = (char*) (& i);

  // Extract the byte, store it in the integer j and print j.
  j = (int) *charPtr;
  printf ("First byte: %d\n", j);

  // Get the next byte and print:
  j = (int) *(charPtr+1);
  printf ("Second byte: %d\n", j);

  // Get the third byte and print:
  j = (int) *(charPtr+2);
  printf ("Third byte: %d\n", j);

  // Get the fourth byte and print:
  j = (int) *(charPtr+3);
  printf ("Fourth byte: %d\n", j);
}

int main ()
{
  int i = 0;
  int *p = NULL;
  int **p2 = NULL;

  // Fill in the assignments here to make the program work:


  // Should print "5";
  printf ("i = %d\n", **p2);
}

int main ()
{
  double x = 6, y = 5;
  int i = 8, j = 5;

  // Standard: plus, minus, multiple, divide
  printf ("x+y=%lf\n", x+y);     // Prints 11.0
  printf ("x-y=%lf\n", x-y);     // Prints 1.0
  printf ("x*y=%lf\n", x*y);     // Prints 30.0
  printf ("x/y=%lf\n", x/y);     // Prints 1.2

  // Integer divide and remainder:
  printf ("i/j=%d\n", i/j);      // Prints 1
  printf ("i mod j=%d\n", i%j);  // Prints 3

  // Post and pre-increment:
  printf ("i++ = %d\n", i++);    // Prints 8
  printf ("++j = %d\n", ++j);    // Prints 6

  // Assignment shortcut example.
  i += j;
  printf ("i=%d\n", i);          // Prints 15

}

int main ()
{
  int a = 9;
  int b = 4;

  printf ("a&b = %d\n", a&b);          // Bitwise AND: Prints 0
  printf ("a|b = %d\n", a|b);          // Bitwise OR: Prints 13 
  printf ("a^b = %d\n", a^b);          // Bitwise EOR: Prints 13

  printf ("~a = %d\n", ~a);            // Complement: Prints -10
  printf ("b << 1 = %d\n", (b << 1));  // Left shift by 1: Prints 8
  printf ("b >> 2 = %d\n", (b >> 2));  // Right shift by 2: Prints 1
}

int main ()
{
  double x = 5, y = 6, z = 6;
  int result;

  printf ("x < y = %d\n", (x < y));     // Prints 1 (true)
  printf ("x <= y = %d\n", (x <= y));   // Prints 1
  printf ("y > z = %d\n", (y > z));     // Prints 0 (false)
  printf ("y >= z = %d\n", (y >= z));   // Prints 1
  printf ("x == y = %d\n", (x == y));   // Prints 0
  printf ("y == z = %d\n", (y == z));   // Prints 1
  printf ("x != y = %d\n", (x != y));   // Prints 1

  result = (x < y);
  printf ("result=%d\n", result);       // Prints 1

  if (result == 1) {      // Equality comparison.
    printf ("x < y\n");
  }
  else {
    printf ("x >= y\n");
  }
  // Prints "x < y"
}

int main ()
{
  char *hStr = "hello";     // String initialization.
  char *wStr = "world";
  char ch;

  // Note the use of "%s"
  printf ("%s %s\n", hStr, wStr);

  printf ("3rd char in wStr is %c\n", *(wStr+2));     // Prints 'r'

  // Let's get the 6-th char: should be '\0'
  ch = *(wStr+5);
  if (ch == '\0') {
    printf ("char is string terminator\n");
  }
  else {
    printf ("char is not string terminator\n");
  }
}

int main ()
{
  int i = 1;

  // if-statement:
  if (i == 0) {
    printf ("i is zero\n");
  }


  // if-statement with compound expression:
  if ( (i >= -1) && (i <= 1) ) {
    printf ("-1 <= i <= 1\n");
  }


  // if-else combination
  if (i == 1) {
    printf ("one\n");
  }
  else if (i == 2) {
    printf ("two\n");
  }
  else {
    printf ("larger than two\n");
  }


  // Variation of if-else above:
  if (i == 1) {
    printf ("one\n");
  }
  else {
    if (i == 2) {
      printf ("two\n");
    }
    else {
      printf ("larger than two\n");
    }
  }


  // Equivalent switch statement:
  switch (i) {
    case 1: {
      printf ("one\n");
      break;
    }
    case 2: {
      printf ("two\n");
      break;
    }
    default: {
      printf ("larger than two\n");
    }
  }


  // for-loop example:
  printf ("Numbers 0 through 9: \n");
  for (i=0; i < 10; i++) {
    printf (" %d\n", i);
  }

  
  // while-loop equivalent:
  printf ("Numbers 0 through 9: \n");
  i = 0;
  while (i < 10) {
    printf (" %d\n", i);
    i++;
  }


  // do-while equivalent:
  printf ("Numbers 0 through 9: \n");
  i = 0;
  do {
    printf (" %d\n", i);
    i++;
  } while (i < 10);



  // Example of using "break"
  printf ("Numbers 0 through 9: \n");
  i = 0;
  while (1) {
    if (i == 10) {
      break;
    }
    printf (" %d\n", i);
    i++;
  }
  

  printf ("Odd numbers less than 10:\n");
  i = 0;
  while (1) {
    // If we've reached the limit, break out of the loop.
    if (i == 10) {
      break;
    }

    // If it's an even number, skip to next iteration of loop.
    if (i % 2 == 0) {
      i++;
      continue;
    }

    // Print odd number.
    printf (" %d\n", i);
    i++;
  }

}

int main ()
{
  int A[10];          // Statically-sized unidimensional array.
  double B[20][20];   // 2D array.

  int *A2 = NULL;     // Declaration of 1D array variable.
  double **B2 = NULL; // Declaration of 2D array variable.

  int i, j;           // For-loop variables.

  int sum;            // For use in examples.
  double dSum;      


  // Static example. The space is already allocated, so the
  // array can be used immediately.
  for (i=0; i < 10; i++) {
    A[i] = i * 100;                // Fill the array with some numbers.
  }

  sum = 0;
  for (i=0; i < 10; i++) {
    sum += A[i];                   // Compute the sum of array's numbers.
  }
  printf ("sum = %d\n", sum);      // Print sum.


  // Dynamic version of example using "malloc" to allocate space.
  // Note the use of the "sizeof" keyword.
  A2 = (int*) malloc (sizeof(int) * 10);
  for (i=0; i < 10; i++) {
    A2[i] = i * 100;               // Fill the array with some numbers.
  }

  sum = 0;
  for (i=0; i < 10; i++) {
    sum += A2[i];                  // Compute the sum of array's numbers.
  }
  printf ("sum = %d\n", sum);      // Print sum.



  // 2D example with static array.
  for (i=0; i < 20; i++) {
    for (j=0; j < 20; j++) {
      B[i][j] = i*j;               // Fill the array with some numbers.
    }
  }

  dSum = 0;
  for (i=0; i < 20; i++) {
    for (j=0; j < 20; j++) {
      dSum += B[i][j];             // Compute the sum of array's numbers.
    }
  }
  printf ("dSum = %lf\n", dSum);   // Print sum.

  
  // Dynamic version of 2D example. Note the two-step allocation.

  // Allocate space for 20 pointers-to-double
  B2 = (double **) malloc (sizeof(double*) * 20);
  for (i=0; i < 20; i++) {
    // For each such pointer, allocate a size-20 double array.
    B2[i] = (double*) malloc (sizeof(double) * 20);
  }

  for (i=0; i < 20; i++) {
    for (j=0; j < 20; j++) {
      B2[i][j] = i*j;              // Fill the array with some numbers.
    }
  }

  dSum = 0;
  for (i=0; i < 20; i++) {
    for (j=0; j < 20; j++) {
      dSum += B2[i][j];            // Compute the sum of array's numbers.
    }
  }
  printf ("dSum = %lf\n", dSum);   // Print sum.

  // Must free allocated memory when not needed anymore:
  free (A2);
  free (B2);

}

    1 1 
   1 2 1 
  1 3 3 1 
 1 4 6 4 1