Write a c plus plus program to demonstrate call by value and call by reference?

Answer 1

#include<iostream>

void byval(int y)

{

std::cout<<"byval: &y="<<&y<<std::endl;

}

void byref(int& z)

{

std::cout<<"byref: &z="<<&z<<std::endl;

}

int main()

{

int x=42;

std::cout<<"main : &x="<<&x<<std::endl;

byval(x);

byref(x);

return(0);

}

Example output:

main : &x=001DF800

byval: &y=001DF72C

byref: &z=001DF800

When you pass by value, the y argument has a different memory address to that of x. In other words, y is a copy of x (you pass the value of x, not x itself). Thus any changes made to y will have no affect upon x. Often this is desirable, but note that when passing a complex object by value, you will automatically invoke the object's copy constructor, which is often unnecessary. Pass by value should only be used when the function needs to modify the argument's value, but without affecting the argument that was passed.

When you pass by reference, the z argument has the same address as x. Thus z refers to x. In other words, z is an alias, an alternate name, for x, thus any changes made to the value of z will also change the value of x, since they are one and the same variable. If the function does not actually need to alter the value of the reference, then the reference should be declared constant. This assures the caller that the object's immutable members will not be altered by the function.

Note that you can also achieve pass by reference by passing a pointer to the variable. Pointers are always passed by value, thus the pointer will actually be a copy of the pointer you pass, but both pointers will still refer to the same memory address, thus the net effect is a pass by reference. However, if a pointer is guaranteed to be non-NULL, then it is more efficient to pass the address being pointed at by reference, since references can never be NULL (a NULL reference will invalidate your program).

To pass a pointer by reference, you need to add an extra level of indirection. Thus when passing a pointer to an int (int*), you need to pass a pointer to a pointer to int instead (int**). The pointer to pointer is passed by value, but the pointer to int is effectively passed by reference, thus allowing you to change the value of both the pointer and also what it is pointing at (unless one, the other, or both, are declared const).

Answer 2

The c++ concept of polymorphism can be illustrated without the use of functions.Eg:

#include

using namespace std;

int sum( int a, int b){

return a+b;

}

void sum(int a, int b, int &c){

c = a+b;

}

int main(){

int a, b, c;

cout<<"Enter the two numbers:\t";

cin>>a>>b;

c = sum(a+b);

cout<<"Sum = "<

sum(a,b,c);

cout<<"Sum = "<

return 0;

}