Transcript الشريحة 1
Array in C++ / review
An array contains multiple objects of identical
types stored sequentially in memory.
The individual objects in an array, referred to as
array elements, can be addressed using a number,
called index or subscript.
The array is the most commonly used data
storage structure.
It helps us to see how object-oriented
programming and data structures relate to each
other.
Like a regular variable, an array must be declared
before it is used. A typical declaration for an array in
C++ is:
type name [ no of elements];
You can create an array from any type with the
exception of some special types.
An array always occupies a contiguous memory space.
To know how much memory spaces an array needs,
for example, if we have an array of 10 elements, this
space is 10*sizeof(float) = 40 bytes.
when declaring an array, there is a possibility to
assign initial values to each one of its elements.
To access the values of an array; being able to
both read and modify its value by using this
format :
name[index]
# include <iostream>
# include <iomanip>
using namespace std;
int main()
{
int n[10];
for( int i=0;i<10;i++)
n[i] =0;
cout<<“Element”<<setw(13)<<“value”<<endl;
for(int j=0; j<10;j++)
cout<<setw(7)<<j<<setw(13)<<n[j]<<endl;
return 0;
}
How to assign initial values to a char array :
char name[ ] = “welcome back";
This definition is equivalent to
char name[ ] = {‘w’,‘e’,‘l’,‘c’,‘o’,‘m’,‘e’, ‘ ‘ ,
‘b’,‘a’,‘c’,‘k’,‘\0’};
Multidimensional arrays
can be described as "arrays of arrays".
Multidimensional arrays are not limited to two
indices.
#define WIDTH 3
#define HEIGHT 2
int table [HEIGHT][WIDTH];
int n,m;
int main ()
{ for (n=0;n<HEIGHT; n++)
for (m=0; m<WIDTH; m++) {
table [n][m]=(n+1)*(m+1); }
return 0; }
Array Advantages:
Easier to declare and use.
Can be used with most of the data types.
Array Disadvantages:
Fixed size data.
Ex: if the number of elements to be stored are
more than the maximum size, the array cannot
accommodate those new values.
Any Question?
Refer to chapter 1 of the book for further reading
Function
Review
FUNCTIONS
If you are looking to provide a solution for a more
complex problem, it will help to divide the problem into
smaller units.
Functions can be defined in any order, however, the first
function is normally main.
Definition syntax:
type name ( parameter1, parameter2, ...)
{ statements }
Prototype and Definition
In a function definition, the function header is similar in
form to the prototype(declaration) of a function.
State the differences between the prototype and
function declaration?
When do the function must be declare?
The prototype provides the compiler with all the
information it needs when a function is called, what are
these information and what will happen after that?
Can the function declaration be omitted ? When ?
■ RETURN VALUE OF FUNCTIONS
When a function is called, an argument of the same type
as the parameter must be passed to the function for each
parameter.
Note: the arguments can be also any kind of expressions.
If the function is any type other than void, the return
statement will cause the function to return a value to the
function that called it.
When the program flow reaches a return statement or the
end of a function code block, where it goes?
■ PASSING ARGUMENTS
Passing values to a function when the function is called is
referred to as passing by value, does it access the object it
self directly?
However, function arguments can also be passed by
reference.
17
Other topics to review
Overloading function .
Inline function .
Recursion .
Default arguments.
Any Question?
Refer to chapter 1 of the book for further reading
Pointers
21
Each cell can be easily located in the memory because it has a
unique address.
Reference operator (&)
The address that locates a variable within memory is what we
call a reference to that variable.
This reference can be obtained by preceding the identifier of a
variable with an ampersand sign (&), known as reference
operator.
Note that using the address/refrence operator, &, for a given
object creates a pointer to that object.
Example: given that var is an int variable, &var is address of
the object var
Dereference operator (*)
A variable which stores a reference to another variable is
called a pointer.
Using a pointer we can directly access the value stored in
the variable which it points to.
To do that, precede the pointer's identifier with an
asterisk (*), which acts as dereference operator and that
can be translated to "value pointed by".
Pointer variable declaration and initialization
A pointer is an expression that represents both the address
and type of another object.
Any pointer is placed during runtime in the specific
memory address.
An expression such as &var is a constant pointer; however,
C++ allows you to define pointer variables, that is, variables
that can store the address of another object.
In a declaration, the star character * always means “pointer
to.”
Example: int *ptr;
Pointer variables contain memory addresses as their values.
After declaring a pointer variable, you must point the pointer at
a memory address by using the address operator.
Example :
int y = 5; // declare variable y
int *yPtr; // declare pointer variable yPtr
the statement
yPtr = &y; // initialize-assign address of y to yPtr
26
27
Indirection operator
The indirection operator(dereference operator) * is used
to access an object referenced by a pointer:
Given a pointer, ptr, *ptr is the object referenced by
ptr.
Example:
long a = 10, b, *ptr;
ptr = &a;
// Let ptr point to a.
b = *ptr;
Note : The indirection operator * has high precedence,
just like the address operator &. Both operators are
unary.
29
References
DEFINING REFERENCES
A reference is another name, or alias, for an object that
already exists.
Defining a reference does not occupy additional
memory.
Any operations defined for the reference are performed
with the object to which it refers.
31
The ampersand character, &, is used to define a reference. Given
that T is a type, T& denotes a reference to T.
Example:
float x = 10.7; float& rx = x;
//The place contents the value 10.7. have two names and one
address.
cout<<x<< endl;
//output: 10.7
cout<<&x<<endl;
//address of x in memory
cout<<rx<< endl;
// output: 10.7
cout<<&rx<< endl;
//address of x in memory = &x
32
Any Question?
Refer to chapter 1 of the book for further reading
Classes
In C++
What is a class
Can make a new type in C++ by declaring a class.
A class is an expanded concept of a data structure: instead of
holding only data, it can hold both data and functions.
It is just a collection of variables with a set of related functions.
The variables in the class are referred to as the member
variables or data members.
The functions in the class manipulate the member
variables. They are referred to as member functions or methods
of the class.
An object is an instantiation of a class. In terms of
variables, a class would be the type, and an object would
be the variable.
A class enables you to encapsulate these variables and
functions into one collection, which is called an object.
Declaring a Class
To declare a class, use the class keyword followed by a
class name and an opening brace, then list the data
members and methods of that class.
End the declaration with a closing brace and a
semicolon.
Example:
class Part
{
int modelnumber;
double cost;
void SetPart(int mn, double c);
void ShowPart();
};
Note :
You cannot initialize data members where you declare
them.
A method declaration can also include the
implementation, or you can implement it separately).
All methods can be accessed only through an object of the
class.
Defining an object
An object is an individual instance of a class.
To define an object of a new type just as defining an
integer variable (or any other variable):
Part wheel;
This code defines wheel, which is an object whose
class (or type) is Part.
Calling Data Member and methods
Once you define an actual Part object, for example, wheel
you use the dot operator (.) to access the members of that
object.
Therefore, to assign 50 to wheel’s modelnumber member
variable
wheel.modelnumber = 50;
In the same way, to call the ShowPart() function,
wheel.ShowPart();
//method calling
Assign Values to Objects, Not to Classes
In C++ you don't assign values to types; you assign values to
variables.
For example,
int x = 50;
//define x to be an int
int = 50;
// wrong
In the same way,
Part.modelnumber = 50; //wrong
you must define a Part object and assign 50 to the
modelnumber of that object.
Part wheel;
//just like int x;
wheel.modelnumber = 50; //just like x = 50;
Using Access Specifiers
C++ allows to control where the data members of a class can
be accessed to protect them .
An access specifier is a word that controls where the data
members in a class can be accessed.
An access specifier affects all members of the class that come
after it until another access specifier is encountered or until
you reach the end of the class.
class ClassName
{
classMembers;
accessSpecifier:
classMembers;
};
A class has two kinds of access specifiers: public and
private.
• public members can be accessed anywhere that an object of
the class can be accessed and from within the class (that
is, in the class’s methods).
• private members can be accessed only from within the class
itself.
Note: an object of the class cannot access the private
members, except through public methods.
If no access specifier is provided in the class, all members
default to private.
Example
class Part
{
public:
int modelnumber;
double cost;
void SetPart(int m, double c);
void ShowPart();
};
Now wheel.modelnumber = 50;
compiles without problems.
Private and Public Data
Usually the data within a class is private and the
functions are public. However, there is no rule for that .
Memory Allocation
Declaring this class doesn't allocate memory for a Part .
It just tells the compiler what a Part is, what data it
contains, and what it can do.
It also tells the compiler how big a Part is (that is, how
much room the compiler set for each Part (objects) that
you create).
Creating Methods
You can declare a method two ways.
The most common way is to declare a method inside
the class declaration and then implement it outside.
2. The second way is to declare and implement the
method at the same time inside the class declaration.
However, there is special syntax for the method
definition. A member function definition begins with the
return type, followed by the name of the class, two
colons (::), the name of the function, and its parameters.
1.
The general syntax for a method implementation that occurs
outside a class:
return_type ClassName::methodName(parameterList)
{
method implementation;
}
The double colon (::) is called the scope resolution operator.
Constructor and Destructor
These are special kinds of methods that can be in a class, and
they are optional
They provide special functionality that other methods cannot
provide.
A constructor is executed every time you declare a new
object.
It is normally used to set initial values for the data
members.
always has the same name as the class and cannot have a
return value (not even void).
A destructor is the opposite of a constructor and is
executed when the object is destroyed.
It is always named the same name as the class, but with
a tilde (~) at the beginning.
It cannot have arguments or a return value.
A destructor is often used to perform any necessary
cleanup tasks.
Both constructors and destructors are like methods; they can
be declared and implemented at the same time or declared
and implemented separately.
The syntax for declaring and implementing at the same time:
class ClassName
{//constructor
ClassName(argumentList)
{implementation;}
//destructor
~ClassName()
{implementation;}
//other members };
Here is the syntax for declaring and then implementing:
class ClassName
{
ClassName(argumentList);
~ClassName();
//other Member;
};
ClassName::ClassName([argumentList])
{implementation;}
ClassName::~ClassName()
{implementation;}
Notice : the constructor can have arguments. If you create
a constructor with arguments, the user of the class must
supply values for these arguments when creating an object.
Notice : the destructor cannot have arguments. It is called
automatically, so no chance for the user to provide
arguments.
Because a constructor can have arguments, it might
become necessary to overload the constructor. This is legal
in C++ and is quite common in large classes. Overloading
the constructor in this way gives your class versatility and
provides users of the class with many options.
The destructor cannot be overloaded since there is no
return type or arguments.
Separating Classes into Files
What are the benefit of separating classes in to files ?
Normally, to do the separation, the class declaration is
placed in one file (header file), and the implementation of
all the methods is put in another file.
The class declaration file is normally called ClassName.h.
The implementation file is normally called
ClassName.cpp.
Then you include the header file in your program with an
#include directive.
However, instead of including two files (ClassName.h and
ClassName.cpp), you have to include only ClassName.h.
The compiler will include the .cpp file automatically
Don’t forget: the two files need to be in the same directory
to achieve that).
Pointers To Objects
An object of a class has a memory address.
You can assign this address to a suitable pointer.
For example
Part part1(320);
Part * partPtr = &part1;
Now we can use the pointer like :
(*partPtr).setPart();
Arrow Operator
You can use the class member access operator -> (arrow
operator) instead of a combination of (*) and (.) .
Syntax:
objectPointer->member
This expression is equivalent to
(*objectPointer).member
The difference between the class member access
operators (.) and (->) is that the left operand of the dot
operator must be an object, whereas the left operand of
the arrow operator must be a pointer to an object.
Any Question?
Refer to chapter 1 of the book for further reading