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[]) { local_declarations sequence_of_statements return 0; } // This could be a complete program

// a zero return usually means good

#include <something> void main(void) { local_declarations sequence_of_statements } void procedure_1( formal_parameters ) { local_declarations sequence_of_statements } some_type function_1(void)

// main function and other functions // in same file

// functions, procedures, subroutines // may not be nested // no return statement needed // no formal parameters

{ local_declarations sequence_of_statements } // 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, char *argv[]) { local_declarations sequence_of_statements 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; x++; --x; x--; x = x+20; x += 20; x -= 20; x *= 20; x /= 20; x %= 20; x <<= 2; x >>= 2; x &= 20; x ^= 20; x |= 20; x = (y=3,y++) x = who ? 3 : y; x = sin(x) ; x = mat[i][j] ; // argc, the number of command line items // argv, command line items including calling // program name as argv[0]

// // // // // // // // // // // // // // // // // //

same same same same

as as as as

x x x x

= = = =

x+1; x+1; sets a false flag to true x-1; x-1;

same as x = x+20; same as x = x-20; same as x = x*20; same as x = x/20; same as x = x%20; modulo same as x = x<<2; shift left same as x = x>>2; shift right same as x = x&20; and bits same as x = x^20; exclusive or bits same as x = x|20; or bits same as y=3; x=y; y=y+1; same as if(who)x=3; else x=y; function call 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); Unconditional branches: break; continue; return; return exp; goto label; label: statement; Conditional branching:

// special function that terminates execution

// immediate exit from loop or switch // immediate jump to end of loop ( not exit ) also used to exit a switch in a loop // immediate exit from function, no value returned // exit from function returning value of exp // unconditional jump // label definition ( should not be needed. ) ( should not be needed. )

if ( expression ) { sequence_of_statements } else { sequence_of_statements } if-else-if ladder structure if(exp_1) statement_1; else if(exp_2) statement_2; else if(exp_3) statement_3; ... else statement_n; // // // // //

// condition may be any expression, != 0 is true // executed if expression is true or not equal 0

// executed if expression is false or equal zero

the first expression that is true, e.g. exp_i causes statement_i to be executed then jump to end after statement_n use { } even if only one statement for safety when doing changes or maintenance

Switch statement: switch ( expression ) { case constant_1: break; case constant_2: case constant_3: sequence_of_statements break; case constant_4: sequence_of_statements case constant_5: sequence_of_statements break; default: statement_sequence // constants must be unique // do nothing for this case // drop through and do same as constant_3 // can have but does not need { } // does this and next statements also

// default executes if no constant equals // 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 ) { sequence_of_statements } // The flow sequence is : // initialization // test condition and exit if false // sequence_of_statements // increment // loop back to test condition examples: 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

examples: infinite loop: while(1){ statements ... if(stuff)break; ... } non null pointers: while(!P){ P=P.next; statements to work on list } do { statement_sequence } while ( condition ) ; // test for finished at the end, all // other loops test first

example: 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 bi ts < <= > >= == != & ^ | && || ? : = += -= *= /= %= <<= >>= &= ^= |= , 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: highest : :: ( ) [ ] -> . x++ Assoc LR LR

x--

lowest :

! ~ +<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 , LR

LR means associate left to right, RL means associate right to left Expressions Expressions: variable names start with alphabetic or underscore, followed by alphabetic, numeric or underscore I some_name ELSE Else z999 __do_not_use decimal integer ( no (int) (unsigned int) (long int) (unsigned long int) floating point (double) (float) (long double) U or 1 1U 1L 1UL L yields shortest type ) 12349 12349U 1234569L 1234569UL

numbers

( default is double ) .1 1. 1.5E-20 .1F 1.F 1.5E-20F .1L 1.L 1.5E-20L ( 0x prefix ) integers 0x248F 0x248FU 0x248FL 0x248FUL

octal ( 0 prefix ) and hexadecimal ( no U or L yields shortest type ) (int) 01777 (unsigned int) 01777U (long int) 01777L (unsigned long int) 01777UL character

single character between apostrophes plus special backslash codes 'a' 'Z' '\n' characters between quotes plus special backslash codes a null is automatically placed at end of every string "Hello" "good by \n"

string

let exp, exp1, exp2, exp3 etc. stand for expressions expressions are: variables

numbers characters strings 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; int *ptr; ptr = &i; *ptr = 100; Type Declarations Declarations have the forms: basic_type variable ; basic_type variable_1, variable_2=value; // only initializes variable_2 // // // // allocate storage and initialize value to 1000 allocate storage for a pointer, garbage initially ptr now points to i change value of i to 100

prefix_type(s) basic_type modifier_type variable , variable ,... ; Atype variable[val][val]...[val]={data,data,...}; struct struct_name { Atype variableA; Atype variableB; ... Atype variable; } variable1, variable2, ... ; struct struct_name { Atype variableA : length1; Atype variableB : length2; ... Atype variableN : lengthN; } variable1, variable2, ... ; struct_name another_variables; union union_name { float variable_1; int variable_2; ... Atype variable; } variable1, variable2, ...; union_name variableX ; variableX.variable1=3.5; variableX.variable2=7; enum enum_type { enumeration_name_1, enumeration_name_2=number, ... enumeration_name_n } variable1, variable2, ...; enum_type variable; // establishes enumeration literals // assigns value to enumeration lit // variables are optional // use an existing enum type definition // struct_name is now a type name // any declaration

// variables are optional // struct_name is now a type name // any declaration : length in bits // type is int, unsigned or signed // variables are optional, they can // also be arrays and pointers // don't need extra 'struct' in C++ // union_name is now a type name // variable_1 overlays variable_2

// variables are optional // use an existing union definition // set a float component // integer clobbers float // enum_type is now a type name

enum_type variable = enumeration_name_1; // normal initialization typedef existing_type new_type_name ; // e.g. typedef unsigned int size_t typedef char * string; class aClass { friend some_other_class; public: double myStuff; virtual void function_1(f_p's); void aMethod(void){myStuff=3.5}; aClass(); ~aClass(); // 'string' is now type char * // define a class // if two mutually related classes // stuff after this is visible outside // // // // can be redefined when inherited an inline defined method special function, the constructor 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 } aClass::MyFunction(formal_parameters) { // 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) { whatever_the_function_is_to_do; } 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; p->bal=100.00;

// older usage // 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; Exceptions Exception throwing and catching try { // 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 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 > typ funct( typ x, typ y, typ z) { typ a, b; a = x + y; // one or more dummy names for types // substitution is made everywhere // 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 \b \f \n \o \r \t \v \x \0 \" \' \\ \? alert, audible alarm, bell, ^G Backspace, ^H Form feed, new page, ^L New line, carriage return and line feed, ^M^J '??/n' in trigraph notation Octal constant, \oddd, \ddd Carriage return, no line feed, ^M Horizontal tab, tab, ^I " col 1 \t col 2 \t \n" in string notation Vertical tab, ^K Hexadecimal constant, \xdd 0 <= d <= F 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__ __FILE__ __DATE__ __TIME__ __STDC__ __cplusplus current line number current file name month/day/year of compilation hour:minute:second of compilation supposed to mean standard C/C++ compilation mode 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 algorithm bitset complex deque exception fstream functional iomanip ios iosfwd iostream istream iterator

limits list locale map memory new numeric ostream queue set sstream stack stdexcept streambuf string strstream typeinfo utility valarray vector To safely bring in Standard "C" libraries, use these include files (Remember, no .h in the #include < > ) cctype cassert cerrno cfloat climits clocale cmath csetjmp csignal cstdarg cstddef cstdio cstdlib cstring ctime cwchar cwctype 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) // static.cc 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 instan ces // 3) makes object or function local to a file // 4) makes object persist between calls #include <iostream> class Base { public: Base(void) { B2=2; B3=3;} static void BF1(void); //! definition can not go here void BF2(void) { cout << B1 << " " << B2 << " BF2 in Base \n"; B2=5; } private: static B1; //! no =1; here 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 B1=4; } static int j; //! means local to this file, not visible to linker int main(void) { static i; //! means not on stack, value saved from call to call Base a, b; a.BF2(); a.BF1(); //! object can be used, any object, same result a.BF2(); b.BF2(); Base::BF1(); //! no object needed, but do need Base:: syntax b.BF2(); 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 1 4 4 4 4 2 BF2 in Base BF1 static in Base 5 BF2 in Base 2 BF2 in Base BF1 static in Base 5 BF2 in Base B1==1, B1==1, B1==4, B1==4, B1==4, B1==4, B2==2, B1=4 B2==5, B2==2, B1=4 B2==5, B2=5 in 'a' global B2=5 in 'a' B2=5 in 'b' global B2=5 in 'b' 3)

1)

2)

4)