SYNTAX & SIMANTICS OF CPP

COMPUTER:

An Electronic digital data processor that has the ability of receiving, storing and processing the data based on the instruction given to the microprocessor . ex: CPU, MP KIT

COMPUTER SYSTEM:

A device having one or more computers (microprocessors) to perform at least one particular task completely and quickly with user interface is called as a computer system. ex: PC

HARDWARE:

All visible parts of a computer system is known as hardware.

SOFTWARE:

SYSTEM SOFTWARE: Directly related to hardware ex: OS, CPP COMPILER

APPLICATION SOFTWARE: Programmable and controllable by a user ex: PROGRAMMING LANGUAGES.

PROGRAMMING LANGUAGES:

1.PROCEDURAL PROGRAMMING ex. COBOL, FORTRAN

2.STRUCTURED PROGRAMMING ex. PASCAL, C

3.DATAFLOW PROGRAMMING ex: VAL

4.OBJECT ORIENTED PROGRAMMING

a) OBJECT BASED PROGRAMMING ex. ADA

b) OBJECT ORIENTED PROGRAMMING ex. OBJECT C, OB. PASCAL, C++

c) PURE OBJECT ORIENTED PROG. ex. SIMULA, SMALLTALK, JAVA

HISTORY OF C++ :

1950 : BCBL - By Martin Richards

1960: B - By Ken Thompson - at Cambridge University

1972: C - By Dennis Ritchie & Brian Kernighan - at BELL lab

1979: 'C with Clases' - By Bjarne Sroustrop -at BELL lab (AT&T)

1983: C++ - 'C with classes' named as C++

1989: ANCI / ISO C - (C89)

1997: ANCI / ISO C++

1999: C99 STANDARD

C++:

It's an object oriented Programming language.

It's a Versatile Language.

It's a free-form Language.

It's a structured oriented Language.

It's a middle level language.

It's a Strongly typed Language

C++ VARIATIONS AND EXTENSIONS:

ANCI/ ISO C++

UNIX AT/T C++ *

TURBO C++

BORLAND C++

SYMANTEC C++

COMEAU C++

CFRONT C++

OREGON C++ *

SCO/C++ *

ZORTECH C++

GLOCKENSPIEL C++

GNU C++ *

INTEK C++

NDP C++

GUIDELINES C++

WATCOM C++

VISUAL C++

C #

* - Only for UNIX Systems

C++ SUPPORTS:

PROCEDURAL PROGRAMMING (NON BLOCKED)

STRUCTURED PROGRAMMING

OBJECT BASED PROGRAMMING

OBJECT ORIENTED PROGRAMMING

GENERIC PROGRAMMING

DYNAMIC PROGRAMMING

EXCEPTION BASED PROGRAMMING

GRAPHICS PROGRAMMING

ASSEMBLY LEVEL PROGRAMMING

SYSTEM & I/O PROGRAMMING

C++ TERMINALS

PREPROCESSING TOKENS

1) DIRECTIVE IDENTIFIER (# INCLUDE)

2) HEADER FILE NAME

3) PP-NUMBER

4) WHITE SPACE CHARACTERS

5) PREPROCESSING OP

6) ESCAPING CHARACTERS

7) NEW LINE STRINGS - denoted by ' / '

8) COMMENTS

CPP TOKENS

1) IDENTIFIER (VARIABLES)

2) RESERVED IDENTIFIERS (KEYWORDS)

3) LITERALS (CONSTANTS)

4) OPERATORS

5) PUNCTUATORS

CPP MONITORS

1) LABELED STATEMENTS

a) GOTO LABEL:

b) CASE:

c) DEFAULT:

2) EXPRESSION STATEMENTS (group of id & op)

3) COMPOUND STATEMENTS (block/sequence of statements)

4) SELECTION STATEMENTS (DECISION)

a) IF / IF-ELSE

b) SWITCH

5) ITERATION STATEMENTS (REPLETION)

a) FOR

b) WHILE

c) DO - WHILE

6) JUMP STATEMENTS

a) BREAK

b) GOTO

c) CONTINUE

d) RETURN

7) FUNCTION CALL STATEMENTS (BUILT-IN / USER FUNCTIONS)

8) DECLARATION STATEMENTS

1. BLOCK DECLARATION

a) ASM DECLARATION //assembly language codlings

b) 'FRIEND' // friend functions

c) 'TYPE DEF' // Alias for a type

d) STORAGE CLASS SPECIFIER // specify the scope (lifetime & visibility)

1.STATIC

2.EXTERN

3. AUTO // by default for local variables within main & functions

4. REGISTER // allows using CPU register for faster operations.

5. MUTABLE // Allows constant function to change data members.

e) FUNCTION SPECIFIER

1. INLINE // by default for class member functions within the class

2.VIRTUAL // Hide a physically available function Logically

3.EXPLICIT //prevent constructor's implicit cast one arg. initialization

f) ACCESS SPECIFIER

1.PUBLIC // be default for structure/union members

2.PROTECTED

3.PRIVATE // by default for class members

g) TYPE SPECIFIER

1.BUILT IN DATA TYPE

a) BASIC DATA TYPES (SIMPLE TYPE)

( ALSO : ELEMENTARY DATA TYPES

PRIMITIVE DATA TYPES

FUNDAMENTAL DATA TYPES

ARITHMETIC DATA TYPES

PRIMARY DATA TYPES )

1.INTEGRAL TYPE

[SIGNED/UNSIGNED] INT, SHORT, CHAR, LONG

2. FLOATING POINT TYPE

FLOAT, DOUBLE, LONG DOUBLE

3. PSEUDO TYPE (VOID)

b) DERIVED TYPE / COMPOUND TYPE

1. POINTER

2. ARRAY

3. FUNCTION

2.USER DEFINED DATA TYPE

a) CLASS SPECIFIER (CLASS KEY)

1. STRUCTURE

2. CLASS

3. UNION

b) ENUMERATED SPECIFIER

1. ENUM

2. FUNCTION DEFINITION

3. DECLARATORS

a) INITIALIZERS (click me)

b) QUALIFIERS

1. CONSTANT QUALIFIERS

ex: const PI = 3.1415; // by default integer type

2.VOLATILE QUALIFIER

ex: volatile long clock; // opposite to constant

c) FUNCTION DECLARATOR (FIRST LINE OF FN DEFINITION)

4. TEMPLATE DECLARATION

a) GENERIC FUNCTIONS

ex :template < typename MAC > void quick ( MAC* a, int u, int l);

b) GENERIC CLASSES

ex: template < class MAC, class MAN, int z > class array

{ MAC x; MAN y[ z] };

CPP NON TERMINALS IMPLEMENTATION

1.DECLARATION:

DECLARATION INTRODUCES A VARIABLE INTO THE PROGRAM AND SPECIFIES IT'S TYPE.

1.LOCAL VARIABLE DECLARATION

ex: auto int x; int y; // defined within main or any function

2.STRUCTURE DECLARATION (STRUCTURE SPECIFIER)

ex: struct MAC {int i; float j;};

3.ENUMERATED DECLARATION

ex: enum BOOLEAN {false, true};

4.FUNCTION DECLARATION:

ex: void mac (int, float);

5.CLASS DECLARATION

ex: class MAC { int x; float y; public: mac( ) { } };

6.EXTERNAL VARIABLE DECLARATION

ex: extern int j;

2.DEFINITION:

IF THE DECLARATION ALSO SET ASIDE MEMORY FOR THE VARIABLE ,THEN IT IS SAID TO BE DEFINITION.

1.VARIABLE DEFINITION

ex: int x;

2.ARRAY DEFINITION

ex : int a[20];

3.STRUCTURE DEFINITION

ex: MAC mac1; //(CREATING ARRAY VARIABLE)

4.ENUMERATED DEFINITION

ex: BOOLEAN istrue; //(BOOLEAN IS OF TYPE ENUM)

5. FUNCTION DEFINITION

ex: inline void mac (int x, float k) {cout<<x<<k;}

6.CLASS DEFINITION

ex : MAC mac1,mac2; //(MAC IS A CLASS NAME)

7. POINTER DEFINITION

ex: int* p;

8. NAMESPACE DEFINITION

ex : namespace MAC { int x; class MAC{ int y}; }

3.COMPINING BOTH DECLARATION & DEFINITION

1.STRUCTURE SHORTHAND

ex 1: struct MAC { int i; float j} mac1;

ex 2: struct { int i; float j;} mac1;

2.ENUMERATED SHORTHAND

ex 1: enum BOOLEAN { false, true} istrue;

ex 2: enum { false, true} istrue;

3.FUNCTION SHORTHAND:

ex1: void main(){ --- }

4.ANONYMOUS

1. ENUM ANONYMOUS

ex: enum{false,true};

2. UNION ANONYMOUS

ex: static union{ int x; float j;};

3. NAMESPACE ANONYMOUS

ex: namespace { float y; }

5.INITIALIZATION

1.AUTO INITIALIZATION

a) STATIC VARIABLE DEFINITION

ex: static x;

b) GLOBAL VARIABLE DEFINITION

ex: int i;

c) EXTERN VARIABLE DEFINITION

ex: int t;

2. EXPLICIT INITIALIZATION

a) CONSTANT INITIALIZATION

ex: const x = 10;

b) VARIABLE INITIALIZATION

ex: int i =0;

c) ARRAY INITIALIZATION

ex: int a[20]={0};

d) STRUCTURE INITIALIZATION

ex: struct {int x; float y;}x1={0};

e) ENUMERATED INITIALIZATION

a) ENUM MEMBER INITIALIZATION

ex: enum {one=1,two=2};

b) ENUM VARIABLE INITIALIZATION

ex: enum {false,true} boolean=true;

f) POINTER INITIALIZATION

a) REFERENCE TO POINTER

ex: int* p = & x;

b) VALUE TO POINTER

ex: char * p = " mcmillan " ;

c) POINTER TO POINTER

ex: int* p = &x , **q = &p;

f) FUNCTION INITIALIZATION // also for constructors

and templates

ex: void mac (int=5, char='t', float=7.9);

g) CLASS INITIALIZATION

a) DEFAULT CONSTRUCTORS

ex : class mac{public:mac( ){ }}; mac m1;

b) PARAMETER CONSTRUCTOR

ex : class mac{int i; public:mac(int t ){i=t}};

mac m1(6);

6.FUNCTION PARAMETER EVALUATIONS (ARGUMENT PASSING TYPES)

I. CALL BY NAME

1.PASS BY VALUE

ex: mac(6, 6.8); // fn call

2.PASS BY VARIABLE

a) PASSING BASIC VARIABLE

ex: mac (a,b); //fn call

b) PASS BY USER DEFINED VARIABLES

ex: void mac ( DISTANCE d1, DISTANCE d2); // fn declaration

II . RETURN BY NAME

1.RETURN BY VALUE

ex: float x = mac ( 5, 4.3); // fn call

2. RETURNING USER DEFINED VARIABLE.

ex: DISTANCE mac ( DISTANCE d2) // fn declarator

ex: BOOLEAN mac (DISTANCE d1, DISTANCE d2) //fn declarator

III . CALL BY REFERENCE

1.PASS BY REFERENCE

ex: void mac( int& a, float& j) // declarator

3.RETURN BY REFERENCE

ex: int& mac (int, float); //declaration

IV . CALL BY POINTER

1.DEFAULT PASS BY ADDRESS

ex: void mac (int a[10] ) // declarator

mac ( b); // fn call , b is an array of int.

2.PASS BY POINTER

ex: void mac (int* a ) // declarator

mac ( &b); // fn call , b is a variable of type int.

3. POINTER TO ARRAY CALL

ex: void mac( int* a, float* j) // declarator

mac ( b, c); // fn call , b & c are arrays.

7.FUNCTION CALLING TYPES

1. STANDALONE FUNCTION CALL

ex: getch( ); // built in function call

ex: mac(5,5.6); // ordinary fn call

ex: DISTANCE ( ); //constructor call from anywhere in the program

2. ASSIGNMENT FUNCTION CALL

a) RIGHT SIDE FUNCTION CALL

ex: float j = mac(5);

b) LEFT SIDE FUNCTION CALL

ex: maximum(a,b)=100;

3.DISPLAY FUNCTION CALL

ex: cout<<mac(5);

4. ONE ARGUMENT SEQUENCE CALL

ex: mac (( i++ ,i+2, ++ i, i+4)); // same as i += 6; mac ( i);

5.ACCESS OPERATOR CALL

ex: part1.mac( );

6.SCOPE RESOLUTION OPERATOR FUNCTION CALL

ex: DISTANCE :: mac( ); // calling from derived class

ex: DISTANCE :: mc( ); // from main fn, only if mc( ) is static

7.CONSTRUCTOR COLON CALL

ex: DISTANCE1 ( ) : DISTANCE ( ) { } // from derived class constructor

8.POINTER ACCESS ARROW CALL

ex : ptr -> mac ( );

8. FUNCTION OVERLOADING SELECTION RULES

1. EXACT MATCH

ex: int to int , char to char , array name to pointer, sting to char array, int to const

int, fn name to pointer to function

2. INTEGRAL PROMOTION RULES

ex: bool / char/ short to int , float to double, double to long double

3. IMPLICIT TYPE CONVERSION RULES

ex: int to double, DERIVED* to BASE* , int to unsigned int , float to int

4. EXPLICIT TYPE CONVERSIONS

ex: (float) int to float , (int)double to int

5. DEFAULT ARGUMENTS

ex: mac ( t) to void mac( int x, float u=8.8);

6. VARIABLE LENGTH ARGUMENTS

ex: mac (t,u,e) to void mac(int x...);

9.POINTER DATA TYPE

1.POINTER TO BASIC DATA TYPES

ex: int x=4,*p=&x;

2.POINTER TO DERIVED TYPE

a) POINTER & ARRAYS

i) POINTER TO ARRAY

1) POINTER TO CHARACTER ARRAY

ex: char* s ="mcmillan"; cout<<s;

2) POINTER TO OTHER BASIC TYPE

ex: int i [ ] = { 0 }, *p = i ;

ii) ARRAY OF POINTERS

1) ARRAY OF CHARACTERS

ex: char* m[ ]={"manoj", "macmillan", "mccluskey" };

2) ARRAY OF BASIC TYPES

ex: int x=2, y=5, *p[ ] = { &x , &y };

b) POINTER AND FUNCTION

i) POINTER TO ARGUMENTS

1) SIMPLE ARGUMENTS

ex: void mac ( int* t ); //declaration

mac ( &x ); //call

2) ARRAY ARGUMENTS

ex: void mac( int* t , char* s); //declaration

mac (a , d); //call

ii) POINTER TO FUNCTION

ex: int (*mac) (char* , const char*); // pointer declaration

c) POINTER TO POINTER

ex: int x=5,* p= &x, ** q=&p;

3.POINTER TO USER DEFINED DATA TYPE

ex: struct mac {int s}*p; p->s=5;

ex: class mac{int s; public:void mc(){ }}; mac *p=new mac(); p->mc;

10.OBJECT ORIENTED DESIGN

1.OVERLOADING

a) FUNCTION OVERLOADING

1. DIFFERENTIABLE BY NO OF ARGUMENTS

ex: void mac( int x, float y);

void mac( int x);

2. DIFFERENTIABLE BY TYPE OF ARGUMENTS

ex: void mac( int x, float y);

void mac( double x, int y); // Be careful in types

b) OPERATOR OVERLOADING

1. NO ARGUMENT UNARY OPERATOR

ex: [mac] operator ++ ( ); // mac is optional

[mac] operator ++ (int); // post increment

2. NON RETURNING ARITHMETIC ASSIGNMENT

ex: part1 + = part2; // argument is of type PART

3. RETURNING ASSIGNMENT / ARITHMETIC ASSIGNMENT

ex: PART operator = (PART& part1)

mac operator += (mac m) // cascading +=

if (part 1 <= part 2) // different bool/ int type.

4. OVERLOADING BY FRIEND

ex: friend mac operator ++( mac& p, int); //post inct

friend mac operator + (int x, mac p); // t =10 + e;

5. OVERLOADING << and >> OPERATORS

ex: istream& operator >>(istream& p, PART& part1)

c) CAST OVERLOADING

1. ONE ARGUMENT CAST CONSTRUCTOR

ex: PART part1 = 5.6; // Basic type to User Defined

ex: DISTANCE d1= part1; // User to User Defined

2. CAST DATA CONVERSION

ex: float j = d1; // User Defined to Basic data type

ex: DISTANCE d1 = part 1; // User to Another User

2. CONSTRUCTORS

a) DEFAULT CONSTRUCTORS

ex: DISTANCE ( ) { i =0 ; j =0.0 ;} // declarator

b) PARAMETERIZED CONSTRUCTORS

ex: DISTANCE ( int a, float b) { i =a; j = b;}

c) INITIALIZED CONSTRUCTORS

ex: DISTANCE ( int i ; float b =0.0) { i =a; j =b;}

d) CAST CONSTRUCTORS

ex: DISTANCE ( float b) { i=(int) b; j =b-i;}

e) OVERLOADED CONSTRUCTORS

ex: DISTANCE( ) {i=0;j=0.0} ;

DISTANCE (int a, float b) { i=a; j = b;}

f) DYNAMIC CONSTRUCTORS

ex: STRING ( ) { length =0; name = new char(length+1);}

g) COPY CONSTRUCTOR

ex: PART part 2 = part 1; //implicit constructor for Same user types

ex: DISTANCE ( DISTANCE& part5 ) { i = part5.i; j = part5.j;}

h) COPY CAST CONSTRUCTORS

ex: DISTANCE ( PART P) ; //assign user to another user type

3. INHERITANCE

a) SINGLE INHERITANCE

ex: class DERIVED : public BASE

b) MULTIPLE INHERITANCE

ex: class DERIVED : public BASE1 , private BASE2

c) MULTI LEVEL INHERITANCE

ex: class DERIVED1 : public BASE

class DERIVED2 : public DERIVED1

d) HIERARCHICAL INHERITANCE

ex: class DERIVED1 : public BASE

class DERIVED2 : public BASE

e) HYBRID INHERITANCE

ex: class DERIVED1 : public BASE

class DERIVED2 : public BASE

class DERIVED3 : public DERIVED2

4. CONSTRUCTOR CALLING SEQUENCE

a) SINGLE INHERITANCE

ex: BASE, DERIVED

b) MULTIPLE INHERITANCE

ex: BASE1, BASE2 , DERIVED

c) MULTI LEVEL INHERITANCE

ex: BASE , DERIVED1, DERIVED2

d) HIERARCHICAL INHERITANCE

ex: BASE , DERIVED2

e) HYBRID INHERITANCE

ex: BASE, DERIVED2 , DERIVED3

TO BE CONTINUED...