وجدت هذ الموضوع في احد المواقع وأردت نقله لكم
الشرح بالانكليزي
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
{
local_declarations
sequence_of_statements
return 0; // a zero return usually means good
}
#include <something>
void main(void) // main function and other functions
{ // in same file
local_declarations
sequence_of_statements
}
void procedure_1( formal_parameters ) // functions, procedures, subroutines
{ // may not be nested
local_declarations
sequence_of_statements // no return statement needed
}
some_type function_1(void) // 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, // argc, the number of command line items
char *argv[]) // argv, command line items including calling
// program name as argv[0]
{
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; // 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[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
}
else
{
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
statement_3;
...
else
statement_n;
Switch statement:
switch ( expression ) // constants must be unique
{
case constant_1: // do nothing for this case
break;
case constant_2: // drop through and do same as constant_3
case constant_3:
sequence_of_statements // can have but does not need { }
break;
case constant_4:
sequence_of_statements // does this and next statements also
case constant_5:
sequence_of_statements
break;
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 )
{
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 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
Expressions
Expressions:
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:
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; // 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
...
enumeration_name_n
} 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
}
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; // 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;
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 > // 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
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 instances
// 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 1)
void BF2(void) { cout << B1 << " " << B2 << " BF2 in Base \n";
B2=5; }
private:
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
B1=4;
}
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.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 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'