Overview on

Functions, Arrays, Pointers &

Structure
Functions
What is a function?
• A function is a block of code designed to tackle a specific
problem.

C++ functions generally adhere to the following rules.

• Every function must have a name.
• They can contain up to 32 characters, they must begin with a
letter, and they can consist of letters, numbers, and the
underscore (_) character.
• All function names have one set of parenthesis immediately
following them.
• The body of each function, starting immediately after
parenthesis of the function name, must be enclosed by braces.
Declaring, defining and calling functions
Declaring function:
• The interface of a function (also called its
prototype) specifies how it may be used.
• It consists of three entities:
• The function return type. This specifies the type
of value the function returns.
• The function name - a unique identifier
• The function parameters (also called its signature). This
is a set of zero or more typed identifiers used for passing
values to and from the function.
simple function example:
#include<iostream>
#include<conio>
void starLine(); //prototype
int main()
//func definition
{ void starLine()
starLine(); //Calling the function with a name starLine {
cout<< “Data type Range” << endl; for(int j=0;j<45;j++)
starLine(); cout<< “*”;
cout<< “char -128 to 127” <<endl cout<<endl;
<< “short -32,768 to 32,767” <<endl }
<< “ int system dependent” <<endl
<< “long -2,147,483,648 to 2,147,483,647” << endl;
starLine();
return 0;
}
#include<iostream.h>
#include<conio.h>
void nextMsg();
int main()
{
cout<< “Hello!\n”;
nextMsg();
return 0; void nextMsg()
} {
cout<< “GoodBye!\n”;
return;
}
 Function Parameters and arguments

• The arguments of function calling:

– Call by value (passing by value) or
– Call by reference (passing by reference)
#.....
void Foo(int num)
{ num = 0;
cout<< “num = ” << num << “ \n”;
} int main()
{ int x = 10;
Foo(x);
cout<< “x = ”<<x<< “\n”;

return 0;
}
//Pass by reference
#.....
#.....
void Foo(int & num)
{
num = 0; int main()
cout<< “num = ” << num
{ << “
\n”; int x = 10;
} Foo(x);
cout<< “x = ”<<x<< “\n”;
getch();
return 0;
}
#.......
void order(int &, int &);
int main()
{

int n1 = 99, n2=11;

int n3 = 22, n4=88;
order(n1,n2);
order(n3,n4); void order(int & num1,int & num2)
cout<< “n1=”<<n1<<endl; {
cout<< “n2=”<<n2<<endl; if(num1 > num2)
cout<< “n3=”<<n3<<endl; {
int temp=num1;
cout<< “n4=”<<n4<<endl;
num1 = num2;
return 0; num2 = temp;
} }
  }
Global vs Local variables
int xyz; // xyz is global
void Foo ( int xyz ) // xyz is local to the body of Foo
{
if(xyz > 0)
{
double xyz; // xyz is local to this block
…
}
}
• Use scope operator ‘::’ which takes a global
entity as argument.
int num1 = 2;
void fun1(int num1)
{
//…
num1=33;
cout<<num1; // the out put will be 33
cout<<::num1; //the out put will be 2 which is the global
if(::num1 != 0)//refers to global num1
//…
}
Function overloading
• Having more one fun with same name.
• functions with the same name -overloaded
functions.
• But, C++ requires that each overloaded
functions differ in its argument list.
• Overloaded functions enable you to have
similar functions that work on different types
of data.
int abs ( int i ); int abs(int i)
{
float abs ( float x ); if(i<0)
int main ( ) return i*-1;
else
{ return I;
}
…
ians = abs(i);//calling abs
float abs(flaot x)
with int arguments {
fans = abs(p);//calling abs if(x<0.0)
with float arguments return x*-1.0;
else
… return x;
}
}
 
Recursion
• A function which calls itself is said to be recursive.
• Recursion is a general programming technique applicable
to problems which can be defined interms of themselves.
• Take the factorial problem, for instance which is defined
as:
– factorial of 0 is 1
– factorial of a positive number n is n time the factorial of n-1.

int factorial(unsigned int n )

{
return n = = 0 ? 1 : n * factrial ( n-1);
}
For n set to 4, the following figure shows the recursive call:

Factorial ( 4 )

24
4 * Factorial ( 3 )

6
3 * Factorial ( 2 )

2
2 * Factorial ( 1 )

1 1
• The stack frames for these calls appear sequentially
on the runtime stack, one after the other.
• Stack frame – The section of memory where the
local variables, arguments, return address and
other information of a function are stored, is called
stack frame or activation record.
• A recursive function must have at least one
termination condition which can be satisfied.
• Otherwise, the function will call itself indefinitely
until the runtime stack overflows.
• The three necessary components in a
recursive method are:
– A test to stop or continue the recursion
– An end case that terminates the
recursion
– A recursive call(s) that continues the
recursion
• Try to use a recursive function call to solve the
Fibonacci series. The Fibonacci series is :
– 0,1,1,2,3,5,8,13,21,…
• The recursive definition of the Fibonacci series
is as follows:
– Fibonacci (0) =0
– Fibonacci (1) =1
– Fibonacci (n) =Fibonacci (n-1) +Fibonacci (n-2);
Arrays
What is Array
• A collection of identical data objects, which are stored in consecutive
memory locations under a common heading or a variable name.
Properties of arrays:
• Arrays are zero-bounded;  index of the first element is 0 and the last element
is N-1, where N is the size of the array.
Ex array[0], array[1],…array[N-1]
• It is illegal to refer to an element outside of the array bounds.
• Array can only hold values of one type
Array declaration
• Declaring the name, type and setting the number of elements in an array is
called dimensioning the array.
• The array must be declared before one uses.
• In the array declaration one must define:
– type of the array (i.e. integer, floating point, char etc.)
– Name of the array (identifier)
– number of elements in the array (total number of memory locations to
be allocated or the maximum value of each subscript)
Initializing Arrays
• Declaring an array of local scope (within a function) will not
initialize, so its content is undetermined.
• Declaring a global array (outside any function)  initialize all
elements to zero.
• Ex. Global array declaration: int day [5];
• every element of day will be set initially to 0:
Accessing and processing array elements
• Any elements of array can be access individually for reading or modifying (like
variable).
• But, to access individual elements, index or subscript must be used.
• The format is the following:
name [ index ] ;
• In c++ the first element has an index of 0 and the last element has an index,
which is one less the size of the array (i.e. arraysize-1).
• Thus, day[0] is the first element and day[4] is the last element.
• Following the previous examples where day had 5 elements, we can use the
following to refer to each element:
Arrays as parameters
• At some moment we may need to pass an array to a function as a
parameter.
• In order to admit arrays as parameters the only thing that we
must do when declaring the function is to specify in the argument
the base type for the array that it contains, an identifier and a
pair of void brackets [] . For example, the following function:
void procedure (int arg[ ])
• admits a parameter of type "Array of int " called arg . In order to
pass to this function an array declared as:
int myarray [40];
• it would be enough with a call like this:
procedure (myarray);
Here you have a complete example:
// arrays as parameters
#include <iostream.h>
#include <conio.h> 
void printarray (int arg[], int length)
{
for (int n=0; n<length; n++) void main ()
    cout << arg[n] << " "; {
cout << "\n";
int firstarray[] = {5, 10, 15};
} 
int secondarray[] = {2, 4, 6, 8, 10};
void mult(int arg[], int length)
{ printarray (firstarray,3);
for (int n=0; n<length; n++) printarray (secondarray,5);
    arg[n]=2*arg[n]; mult(firstarray,3);
} 
cout<<”first array after being doubled is\n”;
printarray (firstarray,3);
getch()
}
String of Characters: What is String?
• What type of variables used so far???… numerical
variables?? int, float,… char
• What if you need to represent successive
characters, like words, sentences, names, texts, etc.
• Until now we have only used them as constants, but
not variables able to contain them.
• In C++ there is no specific elementary variable type
to store string of characters.
• In order to fulfill this feature we can use arrays of
type char, which are successions of char elements.
• The maximum size of 20 characters is not
required to be always fully used.
• For example, name could store at some
moment in a program either the string of
characters "Hello" or the string "studying C++”.
• Therefore, since the array of characters can
store shorter strings than its total length, there
has been reached a convention to end the valid
content of a string with a null character, whose
constant can be written as '\0’.
•We could represent name (an array of 20 elements of type char) storing the
strings of characters "Hello" and "Studying C++" in the following way:

H e l l 0 \0

S t u d y i n g C + + \0

•Notice how after the valid content it is included a null

character ('\0') in order to indicate the end of string. The
empty cells (elements) represent indeterminate values.
Initialization of Strings
• Because strings of characters are ordinary arrays they fulfill same rules as
any array.
• For example, if we want to initialize with predetermined values:
char mystring[ ] = { 'H', 'e', 'l', 'l', 'o', '\0' };
• string of characters have an additional way to initialize its values: using
constant strings.
– specified enclosed between double quotes ( “ “ ), for example:
Eg: "the result is: "
• is a constant string that we have probably used in some occasion.
• Unlike single quotes ( ' ) which allow to specify single character constants,
double quotes ( " ) are constants that specify a succession of characters.
• These strings enclosed between double quotes have always a null
character ( '\0' ) automatically appended at the end.
Assigning Values to Strings
• Array of character can store values using assignment
operators. But the following is not allowed.
mystring=”Hello”;
• This is allowed only during initialization. So, what would be
valid is to assign a string of characters to an array of char
using a method like this:
mystring[0] = 'H';
mystring[1] = 'e';
mystring[2] = 'l';
mystring[3] = 'l';
mystring[4] = 'o';
mystring[5] = '\0';
• But, this does not seem to be a very practical method.
Functions to manipulate strings
• The cstring library ( string.h ) defines many functions to perform
some manipulation on strings.
a. String length
• Returns the length of a string, not including the null character (\0).
strlen (const char* string );
b. String Concatenation:
• Appends src string at the end of dest string. Returns dest.
• Has two forms,
– Appending the whole content of the source
strcat (char* dest , const char* src );
– Appending part of the source
strncat (char* dest , const char* src, int size );
• Where size is the number of characters to be appended
c. String Copy:
• Overwrites the content of the dest string by the
src string. Returns dest.
• Has two forms,
– Copy the whole content of the source
strcpy (char* dest , const char* src );
– Appending part of the source
strncpy (char* dest , const char* src, int size );
• Where size is the number characters to be copied
d. String Compare:
• Compares the two string string1 and string2.
• Has two forms,
– Compare the whole content of two strings
strcmp (const char* string1 , const char* string2 );
– Compare only part of two strings
strncmp (const char* string1 , const char* string2, int size );
• Where size is the number characters to be compaired
• The compare function returns three different values:
– returns 0 (if the strings are equal)
– returns negative int(if the first is less than the second string)
– returns positive int (if the first is greater than the second string
 Multidimensional Arrays

• It is arrays of arrays.
• Ex. a bi-dimensional array can be imagined as
a bi-dimensional table of a uniform concrete
data type

type multid_array_name[row_size][col_size];
• Matrix represents a bi-dimensional array of 3
per 5 values of type int .
• The way to declare this array would be:
int matrix [3] [5] ;
• Ex. the way to reference the second element
vertically and fourth horizontally would be:
matrix[1][3];
Structures
• A structure is a collection of one or more
variable types grouped together.
• Structure referred using a single name (group
name) and a member name.
 struct [structure tag]
{
Member definition;
Member definition;
…
Member definition;
}[one or more structure variables];

//Example 1: //Example 2:
struct Student Struct Inventory{
{ char ID[8]; char description[15];
char FName[15];
char part_no[6];
char LName[15];
int quantity;
char Sex;
float cost;
int age;
}; // all structures end with semicolon
float CGPA;
};
Referencing members of a structure
• To refer to the members of a structure use dot operator (.)
• The General syntax::
VarName.Member;
• Where VarName is the varaibale name of the structure variable and
Member is varaibale name of the members of the structure
Eg:- For the above student structure:
•  
struct Student Stud; //declaring Stud Student structure
strcpy(Stud.FName,”Abebe”); //assigned Abebe as First Name
Stud.CGPA=3.21; //assignes 3.21 as CGPA value of Abebe
sout<<Stud.FName; //display the name
sout<<Stud.CGPA; // display the CGPA of Abebe
 Initializing Structure Data
• You can initialize members when you declare a structure, or you can
initialize a structure in the body of the program.
• Here is a complete program.
….
struct cd_collection
{
char title[25];
char artist[20];
int num_songs;
float price;
char date_purchased[9];
} cd1 = {"Red Moon","Sams and Sneeds", 12,11.95,"08/13/93"};
cout<<"\nhere is the info about cd1"<<endl;
cout<<cd1.title<<endl;
cout<<cd1.artist<<endl;
cout<<cd1.num_songs<<endl;
cout<<cd1.price<<endl;
cout<<cd1.date_purchased<<endl;
• A better approach to initialize structures is to use
the dot operator(.).
• the dot operator(.) is one way to initialize individual
members of a structure variable in the body of your
program.
• The syntax of the dot operator is :
structureVariableName.memberName;
here is an example:
#include<iostream.h> //initialize members here
.... strcpy(cd1.title,"Red Moon Men");
void main() strcpy(cd1.artist,"Sams");
{ cd1.num_songs= 12;
cd1.price = 11.95;
clrscr();
strcpy(cd1.date_purchased,"22/12/02");
struct cd_collection{ //print the data
char title[25]; cout<<"\nHere is the info"<<endl;
char artist[20]; cout<<"Title : "<<cd1.title<<endl;
int num_songs; cout<<"Artist : "<<cd1.artist<<endl;
cout<<"Songs : "<<cd1.num_songs<<endl;
float price;
cout<<"Price : "<<cd1.price<<endl;
char date_purchased[9]; cout<<"Date purchased :
}cd1; "<<cd1.date_purchased;
getch();
}
Arrays of Structures
• Arrays of structures are good for storing a complete employee file,
inventory file, or any other set of data that fits in the structure format.
• Consider the following structure declaration:
struct Company
{
int employees;
int registers;
double sales;
}store[1000];

• Declare 1,000 store structures with the definition of the Company

structure, each one containing three members.
• NB. Be take care of resource limitation.(imagine RAM 64MB)
Array of structures can be declared after
the declaration of the structure.
  struct Company
{
int employees;
int registers; void main()
double sales; {
}; /*no structure variables struct Company store[1000]; /*the
defined yet*/ variable store is array of the structure
Company*/
 
…
#include<iostream.h>
}
…
Pointers
Introduction
• Variables are memory cells that can access by an identifier.
• variables are stored in concrete places of the computer
memory.
• A pointer is a variable which stores the address of another
variable.
• The only difference between pointer variable and regular
variable is the data they hold.
There are two pointer operators in C++:
– & the address of operator
– * the dereference operator
• The & literally mean “address of.” always produces the
memory address of whatever it precedes.
• The * operator, when used with pointers, either declares a
pointer or dereferences the pointer’s value.
• A pointer is simply the address of an object in memory.
• Generally, objects can be accessed in two ways:
– directly by their symbolic name, or
– indirectly through a pointer.
• The act of getting to an object via a pointer to it, is called
dereferencing the pointer.
Assigning values to pointers:
• p_age is an integer pointer. The type of a pointer is very
important.
• p_age can point only to integer values, never to floating-
point or other types.
• To assign p_age the address of a variable:
int age = 26; int * p_age; p_age = &age;
OR
int age = 26; int * p_age = & age;
• Two ways to print the value of age:
cout<<age;//prints value of age
cout<<*p_age;//dereferences p_age;
Pointer to void
• note that we can’t assign the address of a float type
variable to an integer pointer variable and similarly the
address of an interger
• variable can not be stored in a float or character pointer.
• flaot y;
• int x;
• int *ip;
• float *fp;
• ip = &y; //illegal statement
• fp = &x; //illegal statement
Arrays of Pointers
• If you have to reserve many pointers for many different
values, you might want to declare an array of pointers.
int *iptr[10]; //reserves an array of 10
integer pointers
• The above statement will create the following
structure in RAM
iptr[4] = &age;// makes iptr[4] point to address
of age.
Pointer and arrays
• The concept of array goes very bound to the one of pointer. In fact, the identifier of
an array is equivalent to the address of its first element, like a pointer is equivalent to
the address of the first element that it points to, so in fact they are the same thing.
• For example, supposing these two declarations:

int Numbers[20];
int * p;
• the following allocation would be valid:

p = numbers;
• At this point p and numbers are equivalent and they have the same properties, with
the only difference that we could assign another value to the pointer p whereas
numbers will always point to the first of the 20 integer numbers of type int with
which it was defined.
• Therefore, although the previous expression was valid, the following allocation is not:

numbers = p;
• N.B: An array name is just a pointer, nothing
more. The array name always points to the
first element stored in the array. 
int ara[5] = {10,20,30,40,50};
cout<< *(ara + 2); //prints ara[2];
• The expression *(ara+2) is not vague at all if
you remember that an array name is just a
pointer that always points to the array’s first
element.
• Consider the following character array:
char name[] = “C++ Programming”;
• cout<<name[0]; // ____C__
• cout<<*name; // _____C__
• cout<<*(name+3); //_________
• cout<<*(name+0); //____C____
Pointer Arithmetic
• Different data type occupy different space.
• For example, in the case of integer numbers,
char occupies 1 byte, short occupies 2 bytes
and long occupies 4.
Pointer Arithmetic
• Different data type occupy different space.
• For example, char occupies 1 byte, short occupies 2 bytes and long
occupies 4.
• Let's suppose that we have 3 pointers:
char *mychar;
short *myshort;
long *mylong;
• And that we know that they point to memory locations 1000 , 2000
and 3000 respectively. So if we write:
mychar++;
myshort++;
mylong++;
• Now let us have a look at a code that shows increments through
an integer array:
void main()
{
int iara[] = {10,20,30,40,50};
int * ip = iara;
cout<<*ip<<endl;
ip++;
cout<<*ip<<endl;
ip++;
cout<<*ip<<endl;
ip++;
cout<<*ip<<endl;
}
Pointer and String
• If you declare a character table with 5 rows
and 20 columns, each row would contain the
same number of characters.
• You can define the table as:
Char names[5][20]={{“George”},{“Mesfin”},{“John”} ,
{“Kim”},{“Barbara”}};
The above statement will create the
following table in memory:
G e o r g e \0

M e s f i n \0

J o h n \0

K i m \0

B a r b a r a \
0
• Here is the definition for such an array:
char *name [5] = {{“George”},{“Mesfin”},
{“John”}, {“Kim”},{“Barbara”}};
•   To print the first string, we should use:
cout<<*names; //prints George.
•  To print the second use:
cout<< *(names+1); //prints Michael
Pointer to pointer:
• As the memory address where integer, float or character is stored it can
be stored into a pointer variable, the address of a pointer can also be
stored in another pointer. This pointer is said to be pointer to a pointer.
• An array of pointer is conceptually same as pointer to pointer type. The
pointer to pointer type is declared as follows:
Data_type ** pointer_name;
• Note that the asterisk is double here.
int **p; //p is a pointer which holds the address another pointer.
–E.g.:
char a;
char * b;
char ** c;
a = 'z';
b = &a;
c = &b;
• supposing the randomly chosen memory
locations of 7230 , 8092 and 10502 , could be
described thus:
End!