EEL 3801 C++ as an Enhancement of C

EEL 3801 – Lotzi Bölöni Comments  Can be done with // at the start of the commented line.  The end-of-line terminates the comment.  Cannot be used for more than one line.  The C comment indicator ( /*... */ ) can be used also if comment is to be for longer than one line.

EEL 3801 – Lotzi Bölöni Stream Input  C++ uses the standard input stream cin and the stream extraction operator >> to serve the same purpose of scanf() in C.  >> also called the get from operator.  Does not require format strings and conversion specifiers.

EEL 3801 – Lotzi Bölöni Stream Input  C++ knows what is the type of the data being read because the variable has been declared already.  The variable name to which the value read will be assigned does not need to be preceded by the & operator.  Must include the include file.

EEL 3801 – Lotzi Bölöni Stream Output  C++ uses the standard output stream cout and the stream insertion operator << to serve the same purpose of printf() in C.  << also called the put to operator.  Other than that, it has the same basic features as the cin stream and the >> operator.

EEL 3801 – Lotzi Bölöni Example #include main() { cout << “Enter your age:” ; int my_age; cin >> my_age; if (my_age < 18) cout << “you are a minor”; else cout << “You are getting old!”; }

EEL 3801 – Lotzi Bölöni Another Example #include main() { cout << “Enter two integers:” ; int x,y; cin >> x >> y; cout << “The sum of “ << x << “and “ << y << “ is “ << x+y << ‘\n’; }

EEL 3801 – Lotzi Bölöni Declarations  In C, all variable declarations must appear before any executable statements.  In C++, that is not the case.  Variables can be declared anywhere in the program as long as they precede the statement where the declared variable is first used.  See previous example.

EEL 3801 – Lotzi Bölöni Declarations  The variables can even be declared inside a loop specification parenthesis. for (int i = 0; i <= 5; i++) { cout << i << ‘\n’; }

EEL 3801 – Lotzi Bölöni Creating New Data Types  Like in C, enum, struct or union data structures are defined as models.  Unlike C, when an instance is declared, a data type is being automatically created.  The keywords struct, enum or union are not required.  typedef also not necessary - it is implicit.

EEL 3801 – Lotzi Bölöni Example struct Name { char first[10]; char last[10]; }; Name x; No need to use typedef or to say: struct Name x;

EEL 3801 – Lotzi Bölöni Function Prototypes  Unlike in C, functions prototypes are required.  When the function is defined prior to its use - the header serves as the prototype  C++ uses the prototype for type checking.  If nothing is placed within the parenthesis of the function prototype, C++ interprets that as void. C interprets as turning off checks.

EEL 3801 – Lotzi Bölöni Inline Functions  Similar in nature to preprocessor macros, but with some significant differences: –type checking is done in inline functions –no unexpected side effects as in macros –can be debugged with a debugger.  Only advises the compiler to replace the code segment in the text itself.  Only done by compiler for small functions.

EEL 3801 – Lotzi Bölöni Inline Functions  Otherwise, used as a regular C++ function.  If inline function is changed, all files in the program that use it must be recompiled. #include inline float cube(const float s) { return s*s*s;} main() { cout << “The answer is” << cube(4); }

EEL 3801 – Lotzi Bölöni Reference Parameters  Permit call by reference without using pointers.  A reference parameter is an alias for its corresponding argument.  Uses the & operator just as * is for pointers.  All operations on the reference parameter are actually performed on the original variable itself.

EEL 3801 – Lotzi Bölöni Reference Parameters  Do not have to be used only in function calls. int count = 1; //declare integer variable int &c = count;// c is alias for count c++; // increments count using its alias  For efficiency if argument is large, non- modifiable parameters can be passed to functions as references to constant variables

EEL 3801 – Lotzi Bölöni Reference Parameters #include void square_by_reference(int &); main() {int z = 4; cout << “z = “ << z; square_by_reference(z); cout << Z is now = “ << z; } void square_by_reference(int &cref) { cref = cref * cref; }

EEL 3801 – Lotzi Bölöni Reference Parameters - Caveats  Reference variables must be initialized in their declarations.  Cannot be reassigned as aliases to other variables.  Cannot be de-referenced using *  Cannot be used to perform pointer arithmetic.

EEL 3801 – Lotzi Bölöni Reference Parameters - Caveats  Can point to references, but you are actually pointing at the variable for which the reference is an alias.  Cannot compare references for the same reason.  Cannot get the address of a reference (same)  When returning reference (or a pointer) to a variable defined in function, make it static.

EEL 3801 – Lotzi Bölöni Constant Variables  The const keyword can be used to declare constant variables in a function.  Better than using the #define pre- processor directive.  Such variables cannot be changed. const float PI = ;  Constant variable must be initialized at declaration.

EEL 3801 – Lotzi Bölöni Constant Variables  Placing const in array declaration is illegal in C, but legal in C++.  Visible to debugger, while #define directives are not.  Pointers can also be declared as constant with the const operator.

EEL 3801 – Lotzi Bölöni Dynamic Memory Allocation  C++ Uses new and delete in lieu of malloc() and free.  Already saw that.

EEL 3801 – Lotzi Bölöni Default Arguments  Values can be specified for the parameters so that if an argument is not supplied, the default value is used by the function.  Must be the leftmost arguments in the parameter list.  Can be done with an inline function also.

EEL 3801 – Lotzi Bölöni Default Arguments int area(int length = 1, int width = 1) { return length * width; } Can be called in the following ways: area() ==> same as area(1,1) area(5) ==> same as area(5,1) area(5,5) ==> same as area(5,5)

EEL 3801 – Lotzi Bölöni Scope Resolution Operator  In C and C++, variables of the same name can be declared when one is global and the other local.  References to a variable while the local is in scope, refer to the local variable.  In such cases, the global variable is “invisible” and cannot be referenced.

EEL 3801 – Lotzi Bölöni Scope Resolution Operator  Scope resolution operator :: permits such a global variable to become visible where the local variable of the same name is in scope.  Cannot be used to refer to another variable of the same name in another function - just global variables.  In general, using two variables of the same name is not good programming practice.

EEL 3801 – Lotzi Bölöni Scope Resolution Operator #include float value = ; main() { int value = 7; cout << “Local value = “ << value << “Global value = “ << ::value ‘\n’; }

EEL 3801 – Lotzi Bölöni Function Overloading  In C, it is not legal to have two functions of the same name in the same program.  That is not the case in C++ as long as the functions have different sets of parameters.  Even the same parameters but of a different type is sufficient to distinguish them.  This is called function overloading.

EEL 3801 – Lotzi Bölöni Function Overloading  When overloaded function called, the C++ compiler selects the proper function by inspecting the order, types and number of arguments.  Typically used to write common functions that do the same things to different data types.

EEL 3801 – Lotzi Bölöni Function Overloading #include int square(int x) { return x * x; } float square(float y) { return y * y; } main() { cout << square(7) << ‘\n’; cout << square(7.5) << ‘\n’; }