Transcript EEL 3801 C++ as an Enhancement of C Comments Can be done with // at the start of the commented line. The end-of-line terminates.

EEL 3801
C++ as an Enhancement of C
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 <iostream.h> 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 <iostream.h>
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 <iostream.h>
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 <iostream.h>
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, nonmodifiable parameters can be passed to
functions as references to constant
variables
EEL 3801 – Lotzi Bölöni
Reference Parameters
#include <iostream.h>
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 preprocessor directive.
Such variables cannot be changed.
const float PI = 3.14159;
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:
same as area(1,1)
area(5) ==> same as area(5,1)
area(5,5) ==> same as area(5,5)
area() ==>
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 <iostream.h>
float value = 1.2345;
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 <iostream.h>
int square(int x) { return x * x; }
float square(float y) { return y * y; }
main()
{
cout << square(7) << ‘\n’;
cout << square(7.5) << ‘\n’;
}
EEL 3801 – Lotzi Bölöni