Copyright © 2016
Robert W. Hasker

Note 13: C

C

• Why C?
  • Key design goals: small, close to the hardware
  • Early version of Unix: 13,000 lines of system code; 800 written in assembly, rest in C
  • Highly portable: most likely language implemented on any architecture
  • char *p; for(p = my_str; *p; p++) ...: maps closely to register operations such as autoincrement address modes
• Interactive C tutorial: learn-c.org
• RPN: basic C
  • Reverse Polish Notation: "5 8 2 * + ="
    • not pejorative - based on work by Polish logician Jan Łukasiewicz
  • Building:

            gcc stack.c rpn.c
    

    • Note gcc instead of g++
    • Also have makefile - cover later
  • rpn.c: main
    • core control constructs - same
    • include, prototypes - same
    • stdio.h: getc/getchar/printf/EOF
      • General form for printf: printf(format, data...);
      • %d: int; %f: float; %g: more natural floating-point output; %c: character; %s: string %l: long; %x: hexadecimal
      • should have data item for each % marker
      • compilers will sometimes check, but can always do

                printf("Enter format string: ");
                char format[200]; /* be safe? */
                scanf("%s", format); /* scan reads from stdin */
                printf(format, name, age);
        

    • #define: constants in C
      • textual substitution, no types - more discussion below
    • alternative parameter style - no longer popular
  • stack.h: prototypes
    • Once upon a time: return type defaulted to int
  • stack.c
    • static: only accessible in compilation unit - any other declaration is for different data
      • Very simple version of data hiding
      • can use in C++, but not common since namespaces and classes take on this role
      • Illustrate: effects of removing static and setting sp to 98.
      • Add extern int sp; to stack.h
    • more on rpn.c
      • note char* array of characters in getop()
  • Other examples:
    • ave.c, ave1000.c
    • Illustrates reading until end-of-file, reading ints, reading doubles
    • Note C has const just like C++ (with essentially the same rules)
• see makefile
  • make: Unix utility to construct projects
  • targets, dependencies, commands
    • hard tabs before commands!
    • can have multi-line commands
    • show: update stack.cpp, see what rebuilt
    • show: update stack.h, see what rebuilt
    • How to organize large projects?
      • directories for libraries, link libraries
      • obvious, but bad choice: subdirectories for .h, .cpp files
      • problem: easiest to put code in same folder with the makefile, so subdirectories often require separate makefiles for each
    • makedepend, fastdep: Unix utilities to generate makefiles from sources - great for larger projects
• [Recompile same code using g++]
  • primary goal of C++: backwards compatibility

C-Style Strings

• Strings in C: array of characters
  • "cat": array of four characters
  • char animal[] = {'c', 'a', 't', '\0'}; /* equivalent to = "cat" */
  • How would you compute the length of a string like animal?
  • This works in C++ as well.
    • ... but std::string is both more robust and sometimes more efficient
  • [Write: C loop to write animal using printf("%c", ...)]
• common operations: strlen, strcpy, strcmp, strcat
  • strlen: size; strcpy: copy; strcmp: compare; strcat: add to end (concatenate)
    • Also, safe versions: strncpy, strncmp, strncat - each has a limit to the number of characters to copy/compare/concatenate
  • Using these:

          #include <string.h>
    
    
          char first[40], last[40];
          ...
          cout << "Length of " << first << ": " << strlen(first);
          // first becomes last:
          strcpy(first, last);
          // check if they are ordered
          if ( strcmp(first, last) < 0 )
             cout << first << " before " << last << endl;
    

  • Implementing strlen:

            int strlen(const char str[]) // const: won't change array contents
            {
               int len = 0;
               while ( str[len] != '\0' )
                  ++len;
               return len;
            }
    

  • return type of strcpy
• dangers of strcpy

          strcpy(animal, "giraffe");
  

• strncpy
• See also strncat
• Why no strnlen?
• int countOf(const char *str, char target) - stop on '\0'
  • What if pass NULL to countOf?
    • Note C++ uses nullptr, C uses NULL
  • Could check, but at least document!
• Adding to the end of a string: strcat, strncat

          #define LEN 100
  
          char word[LEN];
          printf("Enter word: ");
          scanf("%s", word);      // trusting user!
          word[LEN - 1] = '\0';   // but not completely...
          if ( word[0] != '\0' )  // at least one char
          {
             char last = word[strlen(word) - 1];
             if ( last != 's' && last != 'S' ) {
                word[LEN - 2] = '\0'; // ensure space...
                strcat(word, "s"); // no need to use strncat
             }
          }
  

Newer features of C

• Traditionally: all data declared at top of function; can now declare where needed like C++
  • This includes for(int i = 0; ...)
• missing return types result in warnings
• tighter typing rules

How do arrays work?

• both C and C++
• see array.c
• build with

          gcc array.c
  

• note size of int vs. double, how address computed
  • general formula: address of x[i] computed as x + i * sizeof(*x)
  • note usefulness of indexing from 0
• trick if really want array to index from another number:

          double underlying_data[7];
          double *numbers = &underlying_data[3];
          ... numbers[-1] = ...
          ... numbers[3] = ...      // (legal values from -3 to +3)
  

• two-dimensional arrays
  • int table[10][6];
    • data stored by rows
    • that is, above declaration has 10 rows and 6 columns within each row
      • have row 0, row 1, up to row 9
    • draw picture (10 rows, 6 columns each row)

      	0	1	2	3	4	5
      0
      1
      2
      …
      9

  • how to find address of table[2][3]?
  • to convert index to memory location, need: start address, number of rows, number of columns, size of each item
  • size of array (number of bytes): number_of_rows * number_of_columns * item_size
  • address of A[I][J]: start address (A) + (I * number_of_columns * item_size) + (J * item_size)
  • apply to table[2][3]
  • [note why second (and higher) dimensions needed when pass arrays to functions]
    • must know number of columns!
• low level vs. high level views
  • Data layout really helpful during debugging
  • Well-written code doesn't depend on layouts (or documents dependencies well)
  • For sanity, park the matrix in a class and provide problem-dependent operations
• Ways to view computing:
  1. mathematics
  2. high level languages: Ruby, Java, C++
  3. low level languages: C, Fortran
  4. assembly
  5. microcode
  6. gate logic
  7. high/low voltage circuits
  8. transistors/resistors/diodes
  9. quantum mechanics
• Why is math the top and bottom of this list?
• What is the next step up from mathematics?

#define

• Given

          #define X Y
  

  all occurrances of X (case-sensitive) are replaced by Y
  • in C (and early C++): poor man's constant:

            #define MAX_LEN 50
    

    so

            int nums[MAX_LEN];
    

    translates to

            int nums[50];
    

  • problem: no type information, C++ (and newer C) have better solutions
  • careful: don't put semicolon, comment after it; whole rest of line included in translation:

            #define MAX_LEN 50;
            int nums[MAX_LEN];
    

    translates to

            int nums[50;];
    

    which won't compile
• Example with computation:

          #define MAX_STRING_LENGTH 100
          #define MAX_DECLARED_STRING MAX_STRING_LENGTH + 1
  
          char name[MAX_DECLARED_STRING];  /* but see discussion below */
  

• Can also have parameters:

          #define max(a, b) a > b ? a : b
          #define sqr(x) x * x
  

• General form of macro:

          #define name value
          #define name(arguments) value
  

  • The space after the name or close paren is very important
  • The full macro must be on one line or use \ as a line continuation character
• Win: no run-time overhead:

          double y = max(u, v);
          i = sqr(j);
  

  translates to

          double y = u > v ? u : v;
          i = j * j;
  

• A problem with using macros:
  • i / sqr(j) translates to

            i / j * j;
    

    which is equivalent to (i / j) * j; should write:

            #define sqr(x) (x * x)
    

  • But sqr(a + b) translates to (a + b * a + b)!
    • need parens around uses of x:

              #define sqr(x) ((x) * (x))
      

  • but consider something like sqr(max(u, v)): ((u > v ? u : v) * (u > v ? u : v))
    • or worse: sqr(++x): ((++x) * (++x)) - the result depends on the compiler & machine!
    • See error messages for broken1.c
    • no good way to fix this
    • templates are better: guranteed one-time evaluation of argument
• another issue: no up front type checking; get error messages that are hard to interpret
  • #define was a good idea that has been generally superceded by const, templates, and inline in C++
• But still useful:
  • automatically hiding copy, move constructors and assignment operator in C++:

        #define NOCOPY(T) T(const T&)=delete;T(const T&&)=delete;void operator=(const T&)=delete;void operator=(const T&&)=delete;
    

    which can be used as

        class Roster
        {
           ...
           NOCOPY(Roster);
        };
    

  • Definition of assert:

        #define assert(test) ((test) ? cerr \
                              : (cerr << "Assertion failure on line " \
                                      << __LINE__ << " of " << __FILE__ \
                                      << ": " << #test << endl))
    

    • uses \ for line continuation
    • need cerr on both sides for type checks
    • uses fact that __LINE__ is current line, __FILE__ is current file (in pre-processor)
    • #test turns the test into a quoted string
    • Thus writing

              assert(x > 0);
      

      gives

              ((x > 0) ? cerr : (cerr << "Assertion failure on line "
                                      << 25 << " of " << "prog3.cpp"
                                      << ": " << "x > 0" << endl));
      

  • generally: generating code on the fly to minimize busywork

Conditional Compilation

• another good use for #define: conditional compilation
  • this is where code can compile differently depending on compile-time information
• tools:
  • #ifdef macro_name: true if a macro is defined using #define
  • #ifndef macro_name: true if name not defined
  • #if: true if expression is non-zero
  • #else: else part of #ifdef
  • #endif: end of #if
• example: want some code to compile for windows, others for non-windows:

  #ifdef _Windows	
     cout << "This is compiled for Microsoft Windows." << endl;
  #else
     cout << "This is compiled for a non-Microsoft Windows system." << endl;
  #endif
  

• temporarily comment out large section of code, perhaps to narrow down a compilation problem:

          #if 0 
  
          ... errant code ...
  
          #endif
  

• enable code only when need extra debugging:

          // comment out following for release builds
          #define DEBUG
  
          ...
  
          #ifdef DEBUG
             ...
          #endif
  

• application we've already seen: making sure a file is included just once:

          // 
          // util.h: utilities
          //
  
          #ifndef _util_h
          #define _util_h
          
          declarations, etc.
  
          #endif
  

Review

• C = C++ without classes
• static, extern
• more discussion of arrays, 2-d arrays
• #define
• why inline is better than #define
• why #define is still useful