Compact C++ Language Summary

  This summary was extracted from the C++ standard ISO/IEC 14882:1998,
  working documents leading to the standard and various textbooks.

  It is not intended to be 100% complete. Hopefully it will be
  useful as a memory aid in writing C++ programs.


  • Notation used in this summary
  • Program Structure
  • Executable Statements
  • Function Definition and Call
  • Key Words, Reserved Words
  • Operators Defined in C++
  • Operator Precedence
  • Expressions
  • Basic Types
  • Declarations
  • Object Declarations
  • Exceptions
  • Templates
  • Lexical Entities
  • Preprocessor Directives
  • Some Pragmas defined C++
  • Standard Library Defined in C++
  • Static, four uses and examples
  • Other Links
  • Notation used in this summary

       Notation is kept as simple as possible. 
          local_declarations  means C++ declaration(s) can be inserted
          sequence_of_statements  means C++ executable statement(s) can be inserted
          \_ optional  means this part or section is optional
          /           ( all optional cases not necessarily shown)
          ...  means more of the same allowed, use common sense
          occasionally a statement will be shown in a structure,
          this is just a reminder of something useful or required.
        Comments in the language and this summary start with // , two consecutive
        divide signs.  The rest of the line is a comment.
        The end of a line is interpreted as a white space just like a space or tab.
        The language is free form but is typically entered using indentation.
        Key words, reserved words, must always be lower case.
        Names that can be chosen by the programmer usually have a leading
        uppercase letter or may be all lower case letters. Underscore "_" or
        an embedded capital letter are used to make names readable. 
        All names are case sensitive and no embedded white space is allowed.

    Program Structure

    The "main" function and one or more other functions may be in a file.
    A function may be used like a procedure or subroutine by having no
    return value.
    Files are compiled with the some C++ compiler such as g++, CC,
    Borland, Microsoft, etc. Include file are usually not compiled separately.
    Some typical file structures:
    int main(int argc, char *argv[])        // This could be a complete program  
      return 0;                             // a zero return usually means good
    #include <something>
    void main(void)                         // main function and other functions  
    {                                       // in same file                       
    void procedure_1( formal_parameters )   // functions, procedures, subroutines
    {                                       // may not be nested
         sequence_of_statements             // no return statement needed
    some_type function_1(void)              // no formal parameters
    }                                       // as many functions as desired       
    #include <something>        // a main function that can get command line 
    // this area is known as "file scope" because it is outside of a function
    // global variables (use as few as possible)
    // function prototypes (for locally defined functions, others should come
    //                      in via included files)
    // template definitions
    // external declarations
    int main(int argc,          // argc, the number of command line items
             char *argv[])      // argv, command line items including calling
                                // program name as  argv[0]   
         return good_or_bad;

    Executable Statements

    Any of the following may be used for  sequence_of_statements
    either singly or in groups.
    Statements end with a semicolon or brace. A compound statement may be made
    from a sequence of statements by enclosing them in braces.
           { statement ; statement ; statement ; }  is a statement
    Usually, one statement is written per line.
    Assignment statements  (with some short hand notation)
      x = 10;
      x = x+1;
      ++x;                // same as x = x+1; 
      x++;                // same as x = x+1;  sets a false flag to true 
      --x;                // same as x = x-1; 
      x--;                // same as x = x-1; 
      x = x+20;  
      x += 20;            // same as x = x+20; 
      x -= 20;            // same as x = x-20; 
      x *= 20;            // same as x = x*20; 
      x /= 20;            // same as x = x/20; 
      x %= 20;            // same as x = x%20;    modulo
      x <<= 2;            // same as x = x<<2;    shift left
      x >>= 2;            // same as x = x>>2;    shift right
      x &= 20;            // same as x = x&20;    and bits
      x ^= 20;            // same as x = x^20;    exclusive or bits
      x |= 20;            // same as x = x|20;    or bits
      x = (y=3,y++)       // same as y=3; x=y; y=y+1; 
      x = who ? 3 : y;    // same as if(who)x=3; else x=y; 
      x = sin(x) ;        // function call     
      x = mat[i][j] ;     // subscripting      
    Function call with no return: (a procedure or subroutine in other languages)
      go_do_it();          // no actual parameters, do NOT use "void" here
      exit(0);             // special function that terminates execution  
    Unconditional branches:
      break;              // immediate exit from loop or switch          
      continue;           // immediate jump to end of loop ( not exit )  
                             also used to exit a switch in a loop
      return;             // immediate exit from function, no value returned
      return exp;         // exit from function returning value of exp   
      goto label;         // unconditional jump   ( should not be needed. )
    label: statement;     // label definition     ( should not be needed. )
    Conditional branching:
      if ( expression )           // condition may be any expression, != 0 is true 
         sequence_of_statements   // executed if expression is true or not equal 0
         sequence_of_statements   // executed if expression is false or equal zero
    if-else-if ladder structure
      if(exp_1)               //  the first expression that is true, e.g. exp_i 
           statement_1;       //  causes statement_i to be executed             
      else if(exp_2)          //  then jump to end after statement_n            
           statement_2;       //  use { } even if only one statement for safety
      else if(exp_3)          //  when doing changes or maintenance
    Switch statement:
      switch ( expression )            // constants must be unique
          case constant_1:             // do nothing for this case
          case constant_2:             // drop through and do same as constant_3
          case constant_3:
             sequence_of_statements    // can have but does not need  { }
          case constant_4:
             sequence_of_statements    // does this and next statements also
          case constant_5:
          default:                     // default executes if no constant equals 
             statement_sequence        // the expression. This is optional       
    An expression can be almost anything. e.g. (Pi - 37.026E5 < x) && (a > b)
    Iteration statements:
      for ( initialization ; condition ; increment )
                                      // The flow sequence is :              
                                      //    initialization                   
                                      //    test condition and exit if false 
                                      //    sequence_of_statements
                                      //    increment                        
                                      //    loop back to test condition      
          infinite loop:     for(;;){ statements ... if(stuff)break; ... }
          self initialized:  for(int i=0; i<n; i++){ statements }
      while ( condition )
        sequence_of_statements        // keep repeating while condition is true
          infinite loop:     while(1){ statements ... if(stuff)break; ... }
          non null pointers: while(!P){; statements to work on list }
      } while ( condition ) ;         // test for finished at the end, all    
                                      // other loops test first               
          repeat if changes: do{ statements; if(what)changes=1; ..} while(changes);
      in all iteration statements,  break; causes an immediate exit from loop
                                    continue; causes an immediate increment

    Function Definition and Call

      Function Prototype:
      type function_name(type_1 v1, type_2 *v2, type_3 &v3, const type_4 v4); 
                           // e.g.  char * strcpy(char * s1, const char * s2); 
                           // *v2 says pass a pointer to v2
                           // &v3 says pass by reference
                           // const type_4 v4 says v4 is an 'in' parameter
           a prefix of  static  makes the function visible only in this file
      Function Definition:
      type function_name(int a, float b, const char * ch,...){ function_body }
                          // only parameters passed by pointer or reference can
                          // be modified in the calling function,
                          // a local copy will be made and can be modified,
                          // unsafely, unless  const  is used
      char * strcpy( char * s1, const char * s2 ) { statements }
      Obsolete  example of a function and call passing the address of a scalar
         void func(int *num)
             *num *= *num; // square num back in its place 
         } ...
         func(&i); // call, passing address of i, the lvalue of i ( yuk!)
      C++ example of a function and call passing a reference of a scalar
        void func(int &num)  // says do type checking and pass by reference
            num = num*num;  // square num back in its place
        func(i);  // just a normal call, the compiler knows to pass a reference

    Key Words, Reserved Words

      Reserved words as the name implies are reserved for the language.
      Reserved words must not be used as names of objects, types, functions
      or anything else. Technically these are key words because a few can
      be redefined by the user (without command line or preprocessor
      directives) but resist the temptation! 
      There are relatively few "reserved words" . But don't be complacent.
      The next pages cover a lot of types, objects and other names that are
      not technically reserved words but can create havoc if used in the
      wrong place!
      Some common sequences of reserved words are shown. Spaces are important.
    asm        assembly language, destroys portability
    auto       optional local declaration
    bool       basic declaration of type Boolean
    break      used to exit loop and used to exit switch 
    case       choice in a switch
    catch      catch block that handles a thrown exception
    char       basic declaration of a type character
    class      start a class definition
    const      prefix declaration meaning variable can not be changed
    const_cast remove 'const' property
    continue   go to bottom of loop in  for,  while  and  do loops
    default    optional last case of a switch
    delete     free space created by 'new' ( do not use 'free' )
    do         executable statement, do-while loop
    double     basic declaration double precision floating point
    dynamic_cast cast a pointer type if legal, else return null
    else       executable statement, part of "if" structure
    enum       basic declaration of enumeration type
    explicit   restricts constructors to not allow  myclass a = 7;
    export     precedes a template that can be used by other files
    extern     prefix declaration meaning variable is defined externally
    false      value of type bool
    float      basic declaration of floating point
    for        executable statement, for loop
    friend     a function that can see internal stuff in a class
    goto       jump within function to a label
    if         executable statement
    inline     expand the code rather than call it
    int        basic declaration of integer
    long       prefix declaration applying to many types
    long int   example of a type that is a long integer
    long unsigned int  example of sequence of reserved words  
    mutable    override const member functions in classes
    namespace  a scope for declarations and function prototypes
    new        get storage, free storage later with 'delete' ( do not use malloc)
    operator   followed by an operator symbol, can define overloaded functions
    private    the stuff after this is not visible outside the class
    protected  the stuff after this is for classes that inherit this class
    public     the stuff after this is visible outside the class
    register   prefix declaration meaning keep variable in register
    reinterpret_cast  converts a type into any different type (e.g. int to pointer)
    return     executable statement with or without a value
    short      prefix declaration applying to many types
    signed     prefix declaration applying to some types
    sizeof     operator applying to variables and types, gives size in bytes
    static     prefix declaration to make local variable static
    static_cast  a normal cast with no run time checking
    struct     declaration of a structure, like a record
    switch     executable statement for cases
    template   defines template class or function
    this       the class object, used in 'return' statements and others
    throw      throw an exception
    true       value of type bool
    try        try block that precedes a catch block
    typedef    creates a new type name for an existing type
    typeid     function for getting the type of a typename, == and != comparison
    typename   specifies the following name is a type
    union      declaration of variables that are in the same memory locations
    unsigned   prefix declaration applying to some types
    using      makes an entity in a namespace directly visible
    using namespace  make the namespace visible (in scope)
    virtual    this type of function is hidden if defined by an inheritor
    void       declaration of a typeless variable or no formal parameters
    volatile   prefix declaration meaning the variable can be changed at any time
    wchar_t    basic declaration for type wide character (internationalization)
    while      executable statement, while loop or do-while loop
    also reserved are names that start with __ ( double underscore )
    avoid names that start with _ ( single underscore ) except for special use

    Operators Defined in C++

    Remember! Operators can be redefined and overloaded.
      The "<<" in  a = 2 << 3;  is very different from  cout << a;
    operator definitions ( in executable code, highest precedence first ) :
      ::   scope resolution for class, namespace, etc.
      ( )  grouping parenthesis, function call 
      [ ]  array indexing, also  [ ][ ]  etc.
      ->   selector, structure pointer  employee->wage = 7.50 ;
      .    select structure element     employee.wage = 7.50 ;
      sizeof  size in bytes,   sizeof a     or  sizeof (int)
      typedef defining a type
      ++   increment, pre or post to a variable
      --   decrement, pre or post to a variable
      !    relational not, complement, ! a  yields true or false
      ~    bitwise not, ones complement, ~ a
      +    unary plus,  + a
      -    unary minus, - a
      (type)  a cast, explicit type conversion,  (float) i, (*fun)(a,b), (int *)x
      new     allocate storage ( replaces malloc )
      delete deallocate storage ( replaces free )
      *    indirect, the value of a pointer,  * p is value at pointer p address
      &    the memory address, & b is the memory address of variable b
      .*   pointer to member operator, to class
      ->*  pointer to member operator, to class pointer
      *    multiply, a * b
      /    divide, a / b
      %    modulo, a % b
      +    add, a + b
      -    subtract, a - b
      <<   shift left or insert, left operand is shifted left by right operand bits
      >>   shift right or extract, left operand is shifted right by right operand bits
      <    less than, result is true or false,  a < b
      <=   less than or equal, result is true or false,  a <= b
      >    greater than, result is true or false,  a > b
      >=   greater than or equal, result is true or false, a >= b
      ==   equal, result is true or false,  a == b
      !=   not equal, result is true or false,  a != b
      &    bitwise and,  a & b
      ^    bitwise exclusive or,  a ^ b
      |    bitwise or,  a | b
      &&   relational and, result is true or false,  a < b && c >= d
      ||   relational or, result is true or false,  a < b || c >= d
      ?    exp1 ? exp2 : exp3  result is exp2 if exp1 != 0, else result is exp3
      :    see above
      =    store
      +=   add and store
      -=   subtract and store
      *=   multiply and store
      /=   divide and store
      %=   modulo and store
      <<=  shift left and store
      >>=  shift right and store
      &=   bitwise and and store
      ^=   bitwise exclusive or and store
      |=   bitwise or and store
      ,    separator as in   ( y=x,z=++x )
      zero evaluates to false ( a null pointer has an equivalent zero value )
      non zero evaluates to true ( !null_pointer is true )
      * is heavily overloaded, so is &

    Operator Precedence

    operator precedence and associativity is:                                Assoc
      highest :  ::                                                            LR
                 ( )   [ ]   ->    .       x++          x--                    LR
                 !     ~     +<unary>      -<unary>     ++x  --x  *<dereference>
                 &<address of>     sizeof  (type)<cast> new  delete            RL
                 .*    ->*                                                     LR
                 *     /     %                                                 LR
                 +     -                                                       LR
                 <<    >>                                                      LR
                 <     <=    >     >=                                          LR
                 ==    !=                                                      LR
                 &                                                             LR
                 ^                                                             LR
                 |                                                             LR
                 &&                                                            LR
                 ||                                                            LR
                 ?     :                                                       RL
                 =     +=    -=    *=    /=   %=   >>=   <<=   &=   ^=   |=    RL
      lowest :   ,                                                             LR
    LR means associate left to right, RL means associate right to left


    variable names    start with alphabetic or underscore, followed by 
                      alphabetic, numeric or underscore
                      I  some_name  ELSE   Else   z999  __do_not_use
    numbers           decimal integer ( no U or L yields shortest type )
                      (int)                1     12349
                      (unsigned int)       1U    12349U
                      (long int)           1L    1234569L
                      (unsigned long int)  1UL   1234569UL
                      floating point ( default is double )
                      (double)        .1    1.   1.5E-20
                      (float)         .1F   1.F   1.5E-20F
                      (long double)   .1L   1.L   1.5E-20L
                      octal ( 0 prefix ) and hexadecimal ( 0x prefix ) integers 
                      ( no U or L yields shortest type )
                      (int)                   01777       0x248F
                      (unsigned int)          01777U      0x248FU
                      (long int)              01777L      0x248FL
                      (unsigned long int)     01777UL     0x248FUL
    character         single character between apostrophes
                      plus special backslash codes
                      'a'  'Z'  '\n'
    string            characters between quotes plus special backslash codes
                      a null is automatically placed at end of every string
                      "Hello"   "good by \n"
    let exp, exp1, exp2, exp3  etc. stand for expressions
    expressions are:
      unary_operator expression
      expression binary_operator expression
      ( expression )
      variable post_operator    ( ++ and -- )

    Basic Types

    Basic types:
      char      character type, usually one byte ( a string is array of char )
      bool      boolean type has values true and false, usually one byte
      int       integer type, usually 2 or 4 bytes ( default ) may be 8 bytes
      float     floating point type, usually 4 bytes  IEEE 32 bit
      double    floating point type, usually 8 bytes  IEEE 64 bit
      void      no type, typeless
      enum      enumeration type ( user defines the type name )
    Type modifiers, prefix for basic types:
      signed    has a sign ( default )
      unsigned  no sign bit in variable
      long      longer version of type   (short or long  alone means  short int  or
      short     shorter version of type   long int  because  int  is the default )
      const     variable can not be stored into
    Storage class, prefix for types:
      auto      local variable ( default, not really needed )
      static    persistent when function exits, not auto
      volatile  can change from outside influence
      extern    variables are defined elsewhere, externally
      register  assign variable to register, usually ignored by modern compilers
    Other stuff:
      inline    expand code inline rather than call the function(only a hint)
      virtual   use unless over ridden by later definition, functions only
      friend    can access internals of other classes
      class     a basic data structure type
      struct    a basic data structure type
      union     overlay previously defined data types
    Modifier type:
      *         makes a pointer to what follows
      &         makes a reference to what follows
         int i = 1000;   // allocate storage and initialize value to 1000 
         int *ptr;       // allocate storage for a pointer, garbage initially 
         ptr = &i;       // ptr now points to i 
         *ptr = 100;     // change value of i to 100 

    Type Declarations

    Declarations have the forms:
      basic_type variable ;
      basic_type variable_1, variable_2=value;  // only initializes variable_2 
      prefix_type(s) basic_type modifier_type variable , variable ,... ;
      Atype variable[val][val]...[val]={data,data,...};    
      struct struct_name {                  // struct_name is now a type name
         Atype variableA;                   // any declaration                 
         Atype variableB;
         Atype variable;
      } variable1, variable2, ... ;         // variables are optional          
      struct struct_name {                  // struct_name is now a type name   
         Atype variableA : length1;         // any declaration : length in bits 
         Atype variableB : length2;         // type is int, unsigned or signed  
         Atype variableN : lengthN;
      } variable1, variable2, ... ;         // variables are optional, they can  
                                            // also be arrays and pointers       
      struct_name another_variables;        // don't need extra 'struct' in C++
      union union_name {                    // union_name is now a type name    
        float variable_1;                   // variable_1 overlays variable_2    
        int   variable_2;
        Atype variable;
        } variable1, variable2, ...;        // variables are optional            
      union_name variableX ;                // use an existing union definition  
        variableX.variable1=3.5;            // set a float component
        variableX.variable2=7;              // integer clobbers float
      enum enum_type                        // enum_type is now a type name             
        enumeration_name_1,                 // establishes enumeration literals  
        enumeration_name_2=number,          // assigns value to enumeration lit
      } variable1, variable2, ...;          // variables are optional      
      enum_type variable;                   // use an existing enum type definition   
      enum_type variable = enumeration_name_1;  // normal initialization
      typedef existing_type new_type_name ; // e.g. typedef unsigned int size_t  
      typedef char * string;                // 'string' is now type  char *
      class aClass                          // define a class
        friend some_other_class;            // if two mutually related classes
        public:                             // stuff after this is visible outside
          double myStuff;
          virtual void function_1(f_p's);   // can be redefined when inherited
          void aMethod(void){myStuff=3.5};  // an inline defined method
          aClass();                         // special function, the constructor
          ~aClass();                        // special function, the destructor
        protected:                          // stuff after this is for inheritors
          virtual any funct2(any)=0;        // pure virtual, makes class abstract.
          int for_descendents;
        private:                            // stuff after this only for inside
          int HandsOff;
          MyFunction(formal_parameters);    // full definition later
          inline Funct(const int i){HandsOff=i;}; // full definition here
      aClass::aClass()             // all functions not defined above
      {                            // must be defined ( body implemented )
         // code for constructor if not inlined above
         // code for function if not inlined above
      aClass class_variable;               // make an object of type 'aClass'
      aClass *class_pointer = & class_variable;  // make a pointer to above
      aClass *class_pointer = new aClass();  // a typical class pointer, constructed
      class_variable.myStuff = 3.51;       // set a variable in a class object
      class_variable.aMethod();            // use a function from a class object
      class_pointer->myStuff = 3.52;       // set a variable using a pointer
      class_pointer->aMethod();            // use a function via a class pointer
      class aDerivedClass : public aClass  // public may be protected or private
        double more_stuff;
        void aNewMethod(void){myStuff=3.6};   // an additional method
        virtual void function_1(f_p's); // this will do something different
      }       // this derived class has all the stuff from 'aClass' plus more
      void aDerivedClass::function_1(f_p's)

    Declaring Objects of Types Given Above

    Samples of variable declarations:
      auto xyz;              // int is default, bad practice
      unsigned long int pqr;
      extern int global_stuff, remote_function();
      register int quick, *my_ptr;
      void just_do_it();    // no return value 
      char *my_string;      // typedef char * string;  then string my_string;
      char *argv[];
      struct account{
         char name[20];
         float bal;
         unsigned sex:1;
      } person;
      struct account *p;
      p=&person;           // p is pointer to person 
      (*p).bal=100.00;     // older usage 
      p->bal=100.00;       // better usage, means same as above 
    Automatic setting of array size based on data
      char msg[]="Set the size to correct length \n";
      char *p="auto length";
      char ary[3]="Element in an array of messages"; // 3 items, 0,1 and 2 
      float matrix[][3]={1.,2.,3.,4,.5.,6.};      // fills in blank with 6 
      float ***a;  // (a+10)[0][0][0] is a way to index 3 dimensional array
                   // old usage, not liked in C++
      int ia[4][3]=
        {{0, 1, 2},
         {3, 4, 5},
         {6, 7, 8},
         {9, 0, 1}}; // initialization using nested {{},{},{},{}};
    Getting storage/ freeing storage ( do not use malloc and free ! )
      aClass *p=new aClass; 
      delete p;


    Exception throwing and catching
         // normal code that may throw exceptions
         throw "ooopse: can't do it";
         // nested to any depth
            throw   stuff; // stuff is of type stuff_type
         // a throw exits, something like a return, but to a catch rather 
         // than to the caller
      catch(const char *some_string){ // do something, like print and exit }
      catch(stuff_type &some_stuff)  { // do something with some_stuff }
      catch(...){ // everything not caught above comes here }
      try - catch structures can be placed anywhere executable statements
      are allowed. In particular, the entire main program can be a try - catch
      structure and a class may contain a try - catch structure.


    Templates must be defined at file scope.
    There is significant differences in the way various compilers
    handle the compiling and linking of templates.
    Simple template definition and instantiation of a function.
    // define a template, must be at file level
    // first a "function template" ( still use "class" ) then a class template
    template < class typ >             // one or more dummy names for types
    typ funct( typ x, typ y, typ z)
       typ a, b;                      // substitution is made everywhere
       a = x + y;                     // for the actual types, including operations
       b = y - z;
       return a * a / b;
    #include <iostream>
    int main()
      int i = funct(3, 5, 7);     // funct( any numeric type 3 actual parameters )
      long j = funct(3L, 5L, 7L);        // can also be in expressions 
      unsigned k = funct(3U, 5U, 7U);
      float x = funct(3.1F, 5.2F, 7.3F);
      double y = funct(3.1, 5.2, 7.3);
      cout << i << " int, "
           << j << " long, "
           << k << " unsigned, "
           << x << " float, "
           << y << " double.\n";
      return 0;
    } // end main

    Lexical Entities

    Lexical entities are treated as a single symbol. In addition to
    user defined names and reserved words there are operator and other
    special lexical entities:
    Operators and punctuation as single special characters:
     !  %  ^  &  *  (  )  -  +  =  {  }  |  ~
     [  ]  \  ;  '  :  "  <  >  ?  ,  .  /  #
    Operators and other groups of special characters
     ->   ++   --   .*   ->*  <<   >>   <=   >=   ==   !=   &&
     ||   *=   /=   %=   +=   -=   <<=  >>=  &=   ^=   |=   ::
     //   /*   */   ##   <%   %>   <:   :>   %:
     ...  %:%:
    Trigraphs for users who do not have certain special characters:
      ??=  #     ??(  [     ??/  \     ??)  ]     ??'  ^
      ??<  {     ??!  |     ??>  }     ??-  ~
    Character constants for special characters:
          Backslash codes for in character constants and strings:
          these can be used as characters when enclosed in apostrophes
          the equivalent ASCII control character is shown as ^G for control G
      \a  alert, audible alarm, bell, ^G
      \b  Backspace, ^H
      \f  Form feed, new page, ^L
      \n  New line, carriage return and line feed, ^M^J '??/n' in trigraph notation
      \o  Octal constant, \oddd, \ddd
      \r  Carriage return, no line feed, ^M
      \t  Horizontal tab, tab, ^I       " col 1 \t col 2 \t  \n" in string notation
      \v  Vertical tab, ^K
      \x  Hexadecimal constant,  \xdd    0 <= d <= F
      \0  null, zero value character, ^@
      \"  Quote character , '\"'
      \'  Apostrophe character , '\''
      \\  Backslash character
      \?  Question mark character , '\?'
      \ddd  Octal character value 0 <= d <= 7

    Preprocessor Directives

      #include "my_file.h"        search current working directory first
      #include <iostream>         search command line directory then system
      #define ONE 1               Obsolete, use  const One=1;
      #define do_it(a) ((a<0)?-(a):(a+1))   macro substitution, beware!
      #define note /* this comment gets inserted every \
                      time  note  appears */
                                  backslash  \  at end of line means continue  
      #undef ONE                  undefines a previously defined macroname
      #error                      stop compiling at this point
      #if expression              conditional compilation, start if structure
      #elif expression            else if expression != 0 compile following code
      #else                       else compile following code
      #endif                      end of conditional compiling
      #ifdef macroname            like #if, compiles if macroname defined
      #ifndef                     like #if, compiles if macroname undefined
      #line number [filename]     set origin for __LINE__ and __FILE__
      #pragma                     gives the compiler commands
     Predefined macros
      __LINE__     current line number
      __FILE__     current file name
      __DATE__     month/day/year of compilation
      __TIME__     hour:minute:second of compilation
      __STDC__     supposed to mean standard C/C++ compilation mode
      __cplusplus  non zero if compiling C++, supposed to be six digits
                   for a C++ that conforms to the ISO 14882:1998 standard

    Some Pragmas, Compiler Directives

     #pragma starts a compiler specific directive
             these directives are usually available also as command line options
      pragmas can not change the semantics of the C++ code but may change
      optimization level, interface conventions or other compiler operation.

    Standard Library Defined in C++

    Note that the file names do NOT have a  .h   in them
    Standard Template Library file names for  #include < >
    If you do NOT use  using namespace std;  then use library-name::function-name
    To safely bring in Standard "C" libraries, use these include files
    (Remember, no  .h  in the  #include < > )

    Static, four uses and examples

    The "traditional" use of the reserved word 'static' was to declare a
    local variable in a function to be preserved between function calls.
    The implication was static memory assignment rather than using the stack. (4)
    The next most common use of 'static' is to make a name at file scope
    local to the file rather than having the name visible to the linker where
    code in other files could access the name. This applies to both variables
    and functions. When 'static' is used in a function prototype it must also
    be used in the function definition. (3)
    A class variable can be declared static in order to have all instances of
    that class share a common memory location. The user must actually cause
    the global static memory allocation outside of the class. (2)
    A class member function can be defined so that it does not need a class
    instance to exists. No "this" is available because no object is passed
    as the first invisible parameter to a static member function. Static
    member functions can be called from other languages. (1)
    //  test various cases  note //! is about 'static'  FOUR USES !!
    //                                1) a static member function, no object to call
    //                                2) a static class object, shared by all instances
    //                                3) makes object or function local to a file
    //                                4) makes object persist between calls
    #include <iostream>
    class Base
        Base(void) { B2=2; B3=3;}
        static void BF1(void);   //! definition can not go here                 1)
        void BF2(void) { cout << B1 << "  " << B2 << " BF2 in Base \n";
                         B2=5; }
        static B1; //! no  =1;  here                                            2)
        int B2;
        int B3;
    int Base::B1 = 1; //! has to be at file scope. Not in 'main' or in class
                      //! only one per total program, not in .h file
    void Base::BF1(void) //! can not use word static in front of this
      cout << B1 << " BF1 static in Base \n"; //! can not use B2 or B3 in here
    static int j;  //! means local to this file, not visible to linker          3)
    int main(void)
      static  i;   //! means not on stack, value saved from call to call        4)
      Base a, b;
      a.BF1();     //! object can be used, any object, same result
      Base::BF1(); //! no object needed, but do need  Base:: syntax
      return 0;
    //  results, note B1 is changed in object 'a' and B1 gets changed also in 'b'
    //          while B2 is changed in object 'a' and B2 in  'b' unaffected
    //  1  2 BF2 in Base                                  B1==1, B2==2, B2=5 in 'a' 
    //  1 BF1 static in Base                              B1==1, B1=4        global
    //  4  5 BF2 in Base                                  B1==4, B2==5, B2=5 in 'a'
    //  4  2 BF2 in Base                                  B1==4, B2==2, B2=5 in 'b' 
    //  4 BF1 static in Base                              B1==4, B1=4        global
    //  4  5 BF2 in Base                                  B1==4, B2==5, B2=5 in 'b'

    Other Links

    Go to top

    Last updated 4/8/05