Input & Output C++

Ms. Sharmistha Roy,

Assistant Professor,
School of Computer Engineering,
KIIT University
Main Function
C++ defines main() function as follows:
int main()
{
// main program code
return 0;
}

Restrictions of using main () function in C++

 Cannot be overloaded.
 Cannot be declared as inline.
 Cannot be declared as static.
 Cannot be called.

Ms. Sharmistha Roy,

Assistant Professor, SCE , KIIT
 Simple C++ program
#include<iostream>
using namespace std;
int main()
{
cout<<“C++ is better than C\n”;
return 0;
}
 #include is a preprocessor directive which add the contents of the ‘iostream’ file to
the program.
 iostream is the standard header file input and output stream which contains a set of
small and specific general purpose functions for handling input and output data.
 Namespace defines a scope for the identifiers that are used in a program. For using
the identifiers defined in the namespace scope we must include the ‘using’
directive.
 std is the namespace where ANSI C++ standard class libraries are defined.
 The ‘using’ namespace statement specifies that the members defined in ‘std’
namespace will be used frequently throughout the program. This will bring all the
identifiers defined in ‘std’ to current global scope.
 cout is the identifier. It represents standard output stream.
 << operator is called the insertion or put to operator. Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Stream based I/O
Streams refer to data flow. It is classified into
Output Stream
Input Stream
Output Stream: which allows to perform write operations on output devices.
“cout” is an object of output stream.
e.g. of output stream operations:
cout<<“KIIT University”;
int age;
cout<< age; cascaded output operations: more than one
cout<< “Age=“ <<age; item can be displayed using a single ‘cout’.

Input Stream: which allows to perform read operation with input devices. “cin”
is an object of input stream.
e.g. of input stream operations:
int age;
cin>> age;
char name[20];
cascaded input operations: input of more than one
cin>> name;
Ms. Sharmistha Roy, item can be performed using a single ‘cin’.
Assistant Professor, SCE , KIIT
 Scope Resolution Operator ::

 It is used to access a global variable from a function in which a

local variable defined with the same name as a global variable.
 Syntax: :: Global_VariableName
 e.g.
#include<iostream.h>
int num=20;
int main()
{
int num=10;
cout<<“Local= “<<num; Output:
cout<<“Global= “<< ::num; Local= 10
return 0; Global= 20
}

Ms. Sharmistha Roy,

Assistant Professor, SCE , KIIT
 Variable Definition at the Point of Use
 In C, local variable can only be defined at the top of a function or at
the beginning of a nested block.
 Whereas in C++, local variables can be created at any position in code,
even between statements. Also in some case, local variable can be
defined prior to their usage.
 e.g. Output:
int main() i=0
{ i=1
for(int i=0;i<5;i++) i=2
cout<<“i=“<<i<<endl; i=3
cout<<i; i=4
return 0; 5
}
 Variable definition at any position in the code reduce the code
readability. Therefore, local variable should be defined at the
beginning or at right places.
Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Variable Definition at the Point of Use
#include<iostream.h>
int i=10; //global variable
int main()
{
cout<<i<<“\n”; //uses global variable
int i=20;
{
int i=30;
cout<<i<<“\n”; //uses locally defined variable within a block
cout<<::i<<“\n”; //uses global variable
}
cout<<i<<“\n”; //uses local variable as defined near main()
Output:
cout<<::i; //uses global variable
10
return 0;
30
}
10
20
Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
10
 Variable Aliases- Reference Variables:
 Reference Variable is an alias of existing variable.
 In C, we have two types of variables:
 Value variable: used to hold numeric values
 Pointer variable: used to hold the address of some other variable
 Here in C++, Reference variable behaves similar to value variable but has an
action of pointer variable. Thus reference variable enjoys the simplicity of value
variable and power of the pointer variable.
 Syntax: DataType & ReferenceVariable = ValueVariable;
 Reference variables are not bound to a new memory location, but to the
variables to which they are aliases.
int main()
{
int a=1, b=2; Output:
int &c= a; a=1 b=2 c=1
cout<<“a=“<<a<<“b=“<<b<<“c=“<<c<<endl; a=2 b=2 c=2
c=b;
cout<<“a=“<<a<<“b=“<<b<<“c=“<<c;
return 0; } Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Variable Aliases- Reference Variables:
 Therefore, if int &c=a; then address of c & a is same.
 It doesnot provide the flexibility supported by the pointer variable. Unlike
pointer variable, when a reference is bound to a variable, then its binding
cannot be changed.
 Thus, reference variable must be initialized to some variable only at the point
of its declaration. For e.g.
int main()
{
int a=1, b=2 &c ; //error shows that reference variable must be initialized
&c= a;
return 0;
}
 Constants cannot be pointed to a reference variable. For e.g. int &num = 200;
is invalid.

Ms. Sharmistha Roy,

Assistant Professor, SCE , KIIT
 Variable Aliases- Reference Variables:
 For e.g.
int main()
{
int a=1;
int *p=&a;
int &m=*p;
int k=100;
p=&k;
return 0;
}
 Here m refers to a, which is pointed to by the variable p. The compiler binds
the variable m to a not to the pointer p. If pointer p is bound to some other
variable at run time then it does not affect the value referenced by m & a.
 Therefore here, p=&k, changes the pointer value but not the reference variable
m & the variable a.

Ms. Sharmistha Roy,

Assistant Professor, SCE , KIIT
 Strict Type Checking:
 C++ is a strongly-typed language and it uses very strict type-checking. A prototype must be
known for each function which is called, and the call must match the prototype.
 In C++, functional prototyping is compulsory if the definition is not placed before the
function call whereas, it was not compulsory in original C language.
 For e.g.
int main()
{
int x, y;
cout<<“Enter x & y”;
cin>>x>>y;
cout<<“Maximum= “<<max(x, y); // Error: Function ‘max’ should have a prototype
return 0;
}
int max(int a, int b)
{
if(a>b)
return a;
else
return b;
} Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Strict Type Checking:
 Advantage of strict type-checking is that the compiler warns the user if a
function is called with improper data types. It helps the user to identify errors
in a function call & increases the reliability of a program.
 For e.g.
void swap(int *x, int *y)
{
int t;
t= *x;
*x=*y;
*y=t;
}
main()
{
int a,b;
swap(&a, &b);
float c,d;
swap(&c, &d); //Error because pointers are not integer data type
} Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Parameters Passing by Reference:
 A function in C++ can take arguments passed by value, by pointer, or by
reference.
 A copy of the actual parameters in the function call is assigned to the formal
parameters in the case of pass-by-value, whereas the address of the actual
parameters is passed in the case of pass-by-pointer.
 In the case of pass-by-reference, an alias of the actual parameter is passed.
Variable Name Data Type Storage Location

Actual Parameter Type Value

Formal Parameter Type Value

Fig: Call-by-value

Actual Parameter Type

Value
Formal Parameter Type

Fig: Call-by-pointer/ reference Ms. Sharmistha Roy,

Assistant Professor, SCE , KIIT
 Parameters Passing by Reference:
 For e.g.
Pass-by-pointers Pass-by-reference
void swap(int *x, int *y) void swap(int &x, int &y)
{ {
int t; int t;
t= *x; t= x;
*x=*y; x=y;
*y=t; y=t;
} }
main() main()
{ {
int a,b; int a,b;
swap(&a, &b); swap(a, b);
} }
 Here in the 2nd example, the statement swap(a,b) in main() is translated in to
swap(&a, &b) internally during complilation.
 The prototype of the function void swap(int &x,int &y) indicates that the formal
parameter are of reference type and hence they must be bound to the memory
location of the actual parameter. Thus any access made to reference formal
parameters in swap() refers to the actual parameters.
 Thus the compiler treats them similar to pointers but doesnot allow the
modification of the address stored in them. Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Inline Function:
 Function execution involves the overhead of jumping to and from the calling
statement.
 Trading of this overhead in execution time is considerably large whenever a
function is small, hence in such cases inline function can be used.
 A function in C++ is treated as a macro if the keyword inline precedes its
definition. The drawback in macro is that they are not really functions,
therefore the usual error checking doesnot occur during compilation.
 Syntax is:
inline ReturnType FunctionName (Parameters)
{
// body of a main function
}
 The advantage is that the compiler replaces the function call with the
corresponding function code.
 The support of inline functions allow to enjoy the flexibility and benefits of
modular programming, while at the same time delivering computational
speedup of macros.
Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Inline Function:
 The speed benefits of inline functions diminish as the functions
grows in size.
 Some of the situations where inline expansion may not work are:
 For functions returning values, if a loop, a switch, or a goto
exists.
 For functions not returning values, if a return statement exists.
 If functions contain static variables.
 If inline functions are recursive.

Ms. Sharmistha Roy,

Assistant Professor, SCE , KIIT
 Literals- Constant Qualifiers:
 Literals are constants, to which symbolic names are associated for
the purpose of readability and ease of handling standard constant
values.
 C++ provides the following three ways of defining constant:
 # define preprocessor directive
 Enumerated data types
 const keyword
 In C, variables can be initialized with constant values at the point of
its definition like: float PI = 3.1452;
 However, an accidental change of the value of the variable PI is not
restricted by C.
 But, C++ overcomes this by supporting a new constant qualifier for
defining a variable, whose value cannot be changed once it is
assigned with a value at the time of variable definition.
 The qualifier used in C++ to define such variables is the const
qualifier. Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Literals- Constant Qualifiers:
 Syntax: const [DataType] VariableName = ConstantValue;
 Note that if DataType is ommitted, it is considered as int by default.
 E.g. #include <iostream>
const float PI = 3.1452;
int main()
{
float radius, area;
cout<<“Enter radius”;
cin>> radius;
area= PI * radius * radius;
cout<<“ Area of circle is “<< area;
}
 In the above program, the use of statement like: PI = 2.3; leads to
compilation error: Cannot modify a const object.
 In C++, the const qualifier can be used to indicate the parameters that are
to be treated as read-only in the function body.
Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Function Overloading:
 The definition of several functions with the same name, but with different
actions is called function overloading.
 In C++, two or more functions can be given the same name provided each has
a unique signature (in either the number or data type of their argument).
 void show (int val)
{
cout<<“Integer: “<< val <<endl;
}
void show (char *val)
{
cout<<“String: “<<val;
}
int main() Output:
{ Integer: 5
show (5); String: Hello World
show (“Hello World”);
return 0;
} Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Function Overloading:
 It is interesting to note the way in which the C++ compiler
implements function overloading.
 Although the functions share the same name in the source text,
the compiler uses different names.
 The conversion of a name in the source file to an internally used
name is called name mangling.
 For e.g. in the previous program, the C++ compiler might
convert the name void show(int) to the internal name VshowI,
while an analogous function void show (char *) with a character
argument might be called VshowCP.
 The actual names which are used internally depend on the
compiler and are not relevant to the programmer.
 Advantage: Function overloading helps in reducing the need for
unusual function names, making code easier to read.
Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Function Overloading:
 Overloading of the functions should be done with cautions. We should not
overload unrelated functions.
 Function overloading can lead to surprises. For e.g.
 void show (float val)
{
cout<<“Integer: “<< val <<endl;
}
void show (char *val)
{
cout<<“String: “<<val;
}
int main()
{
show (0); // Error: Ambiguity between ‘show(float)’ and ‘show(char *)’
return 0;
}
 Here zero could be interpreted as a NULL pointer to a char i.e. (char *) 0 or as a
float with the value zero. Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Default Arguments:
 C++ allow us to call a function without specifying all its arguments. In such
cases, the function assigns a default value to the parameter which does not have a
matching argument in the function call.
 Default values are specified when the function is declared.
 The compiler looks at the prototype to see how many arguments a function uses
and supply the default values when they are not specified by the programmer
explicitly. For e.g.
#include<iostream.h> default value
float amount (float principal, int period, float rate= 0.15);
int main()
{
float value;
value= amount(5000,7); // Here the function uses default value of 0.15 for rate.
value= amount(5000,5,0.12); // Function passes an explicit value of 0.12 for
rate
return 0;
}
Ms. Sharmistha Roy,
Assistant Professor, SCE , KIIT
 Default Arguments:
 Default argument is checked for type at the time of declaration and evaluated at
the time of call.
 Default arguments must be known to the compiler prior to the invocation of a
function with default arguments.
 It reduces the burden of passing arguments explicitly at the point of a function
call.
 One important point to note is that, only trailing arguments can have default
values and therefore, we must add defaults from right to left.
 We cannot provide a default value to a particular argument in the middle of an
argument list.
 int mul (int i, int j=5; int k=10); // legal
 int mul (int i=5, int j); // illegal
 int mul (int i=0, int j; int k=10); // illegal
 int mul (int i=2, int j=5; int k=10); // legal

Ms. Sharmistha Roy,

Assistant Professor, SCE , KIIT