2. OBJECTIVES
• To be able to use references as function
parameters.
• To be able to return references by
functions
• To understand the difference between
static and dynamic memory allocation
• To be able to allocate, process and
deallocate dynamic arrays
3. PASSING REFERENCES TO
FUNCTIONS
• 3 methods for passing values to
functions: by value, address,
reference.
• When passed to functions, references
have a clear advantage over pointers.
4. void set(int x, int &ce, int &co)
{
if((x%2)==0)
ce++;
else
co++; Passing by reference
}
- Is like passing the address of variable used as
int main(){ argument in function call.
int num,
- When reference is used within the function,
int even = 0; compiler automatically uses odd variable, which
int odd = 0; is referenced by co.
cin>>num;
set(num, even, odd);
cout<<“even:”<<even<<“ odd:”<<odd;
}
5. Reference parameter can be preceded with const to prevent a
function from changing them inadvertently
void fun(const int &cref)
{
cout<<cref/15; //Okay
cref++; //ERROR! Can’t modify a const reference
}
//Pointers as function parameters
void set(int x, int *ce, int *co){
if((x%2)==0)
*ce++; //A pointer has to be dereferenced
else
*co++;
}
set(num, &even, &odd); //Function called
6. Both same effect, but references as function
parameter have several advantages
• Code is cleaner, no *.
• Does not have to remember to pass address of
function argument.
• Unlike passing with a pointer, no memory location
required.
7. RETURNING REFERENCES BY
FUNCTIONS
• A function may return a reference.
• Returning a reference by a function
also permits the function to be called
from left side of assignment operator.
8. Function returns a reference to the a[n] array
const int SIZE = 6;
element.
int & put_val(int a[], int n){
if(n>=SIZE || n<0){
cout<<“Out of boundaries”; exit(1);
}
return a[n]; } OUTPUT:
array[0] = 0
array[1] = 2
// put_val(array, i) = i *2;
array[2] = 4
// array[I] = i *2;
array[3] = 6
array[4] = 8
int main(){ array[5] = 10
int array[SIZE];
for(int i=0; i<SIZE; i++)
put_val(array, i)=i*2; //function call on the left
for(int j=0; j<SIZE; j++)
cout<<“array[“<<j<<“] = “<<array[j]<<endl;
}
9. • Less prone error than a direct assignment.
• put_val() checks at runtime that the array
boundaries are not exceeded before it returns
a reference to an array element.
• Prevents runtime errors such as array
overflows/underflows(caused by assigning a
value to an array element specified by the
index that is outside of the boundaries of the
array)
11. STATIC VERSUS DYNAMIC
• STATIC MEMORY ALLOCATION - fixed size array to allocate
memory.
• An amount of memory allocated - reserved when the program is loaded
into memory.
• Could fail if run on comp. system lack enough memory.
struct comp_part{
char code[7];
char description[30];
int on_stock;
int sold;
float price;
};
comp_part list[100];
12. • DYNAMIC MEMORY ALLOCATION solve
this problem.
• Allocate memory at run-time.
• pointer_var = new data_type(initial value);
• delete pointer_var;
• Eg:
float *fpt = new float(0.0);
if(fpt==0){ //checks for memory allocation error
cout<<“Memory allocation error.”; exit(1);
}
*fpt = 3.45; //uses pointer to access memory
cout<<*fpt;
delete fpt; //frees memory allocate dynamically
