SOLUTION

Function declaration can skip the argument names as they are optional in a function.

SOLUTION

The place of declaration of function or variable determines the scope of that function and variable.

SOLUTION

void datatype specifies an empty set of values and it is used as the return type for functions that do not return a value.

SOLUTION

A function may be without any parameters, in which case, the parameter list is empty.

SOLUTION

The general form of function definition is: type function_name(parameter list)
{
body of function
}

There is no semicolon in function definition.  

SOLUTION

The parameter list is a comma separated list of variables of a function referred to as its arguments.

SOLUTION

If no type is specified in a function , the compiler assumes that the function returns an integer value.

SOLUTION

parameter list is also referred to as Arguments. 

SOLUTION

void data type specifies an empty set of values i.e. why in above function parameter list is empty.

SOLUTION

If no type is specified in a function , the compiler assumes that the function returns an integer value.

SOLUTION

In function declaration, the names of the arguments are optional therefore they can be omitted.

SOLUTION

Type specifies the type of value that the return statement of the function returns. It may be any valid C++ data type.

SOLUTION

User defined functions are the functions created by a programmer.

SOLUTION

These functions are part of standard library, which are made available by the compiler. Hence, these are library or built-in functions.

SOLUTION

The syntax of function definition is: type function-name (parameter list) { body of the function }

SOLUTION

By default, the compiler returns an int value if no type is specified.

SOLUTION

The syntax of a function definition is: type function-name(parameter list) { body of the function } Here, type specifies the type of value that the return statement of the function returns.

SOLUTION

By default, the computer takes an integer value.

SOLUTION

Default values are specified at the time of function declaration, when there is no matching arguments in the function call.

SOLUTION

These functions are a part of compiler package. They are a part of standard library, made available by the compiler.

SOLUTION

Default values are passed in the function prototype. It is useful in case a matching argument is not passed in the function call statement.

SOLUTION

These functions are created by the user as per requirements of a program.

SOLUTION

Specifying void in the function prototype, means that function takes no arguments.

SOLUTION

A function declaration tells the program about the type of the value returned by the function and the number and type of arguments.

SOLUTION

parentheses ( ) are used to enclose the parameters or arguments.

SOLUTION

Type specifies the type of value that the return statement of the function returns. It may be any valid C++ data type.

SOLUTION

 Function are of two types:

. Built in functions are a part of the standard library made available by the compiler.
. And user defined function are created by the programmer.  

SOLUTION

 Calling code refers to the code which has called the function.

SOLUTION

The default values are specified at the time of function declarartion.

for example:     int add(int a = 2, int b = 3);

SOLUTION

Default values are specified at the time of function declaration, when there is no matching arguments in the function call.

SOLUTION

It provides faster access,as variables are stored in CPU registers rather than in memory.

SOLUTION

Array name always points to the first element of an array.

SOLUTION

A short integer is a data type that can represent a whole number which may take less storage, while having a smaller range, compared with a standard integer on the same machine. An unsigned short integer is either positive or zero and ranges from 0 to 65,535.

SOLUTION

Example: int volume(int x, int y, int z); int volume(int, int, int); Both are correct. A function declaration can skip the argument names, but a function definition cannot.

SOLUTION

It is used as the return type for functions that do not return a value.

SOLUTION

Constants have fixed values, their values can not be changed during a program run.

SOLUTION

Example: int sum( int a, int b) { } Here a, and b are arguments.

SOLUTION

There are 5 fundamental data types. These are: int, char, float, double and void.

SOLUTION

In C++, a function must be defined before it is used anywhere in the program.

SOLUTION

The function prototype and the function definition must have same return type, function name, and argument/parameter list.

SOLUTION

Scope determines the lifetime of a variable.

SOLUTION

A function returning reference can appear on the left hand side of an assignment statement. Example: let say min( )is a function, and a call to min(x, y)returns a reference to a or b. Here, min(x,y)=-7 is perfectly all right.

SOLUTION

Function definition tells program about the type of the value returned by the function, and the number and type of arguments.

SOLUTION

By default, the computer assumes an integer value, and for the functions returning non-integer values, the type specifier must be given.

SOLUTION

Function call need not be purely by value, or reference. Mix of the two is also possible.

SOLUTION

Function prototyping is must in a C++ program. The syntax of function prototyping is: type function-name (parameter list);

SOLUTION

The auto storage-class specifier declares an automatic variable, a variable with a local lifetime.

SOLUTION

auto storage-class specifier declares an automatic variable, a variable with a local lifetime.

SOLUTION

Unions allow same portion of memory to be accessed as different data types, since all of them are in fact the same location in memory. The keyword union is used for declaring and creating a union.

SOLUTION

Variables that are not initialized contain garbage values left over from the program that last used the memory.

SOLUTION

L suffix indicates it is long integer constant.Example: 25 is an integer constant, whereas 25L is a long integer constant.

SOLUTION

The variables declared in the outermost block of a function have function scope.

SOLUTION

The return has two functions: 1. Causes immediate exit from the function and return control to the operating system. 2. Used to return a value to the calling code.

SOLUTION

The name of a structure follows the simple rules for a variable name. So a structure name cannot start with a  digit.

SOLUTION

Each instance of a structure, which is declared by the struct_name var_name; statement is called the structure variable.

SOLUTION

A structure variable can be passed by value as well as by reference.

SOLUTION

- > is the member access operator to access the pointers being declared, inside a structure.

SOLUTION

It is called as such, because it is a group of several variables under one roof.

SOLUTION

To access a variable of a structure the ‘.’ operator is used in the format; Structure_name.Variable_name

SOLUTION

We can not compare two structures.

SOLUTION

In call by reference, the original values get changed.

SOLUTION

When a structure is defined as global, then its members also become global. Thus, they can be used by any function.

SOLUTION

Both are being passed by value since, no reference variable is being used.

SOLUTION

Here the structure variable is being passed by value. As a result, there wouldn’t be any change in the values of the structure variable.

SOLUTION

An array can never contain elements of different data types.

SOLUTION

Since c is a member of variable cc therefore, cc.c is used to access it.

SOLUTION

cout will display the values of a and b, which are the members of function struct. These members are called with the help of dot operator.

SOLUTION

A structure is a utility to access 2 or more interrelated variables.

SOLUTION

A structure is declared using the struct keyword, followed by its name.

SOLUTION

While declaring a structure without a tag, only one variable can be declared.

SOLUTION

In structures, by default the members are public while in classes, they are private.

SOLUTION

Nested structures contain structures within structures.

SOLUTION

An array wherever being declared, should contain elements of the same data type.

SOLUTION

 a) Program always begins its execution by the main( ) function.
 b) This function primarily consist of function calls.

SOLUTION

Function prototype is not needed when the function definition appears before its calling function.

SOLUTION

A program to find larger of the two numbers using functions is:

#include< iostream.h>

#include< conio.h>

int main()

{

  clrscr();

  int x,y;

  void largest(int , int );// FUNCTION DECLARATION

  cout <<"Enter two numbers";

  cin>> x>> y;

  largest (x,y);

  getch();

  return 0;

}

void largest(int x, int y)

{

if(x < y)

cout<< y <<" is largest";

else if(x > y)

cout<< x<<" is largest";

else

cout<< x<<"and"<< y<<"are equal";

}

Output:

SOLUTION

A program to show that the arguments are passed by reference:

#includeh>

#include

void duplicate(int&a, int&b, int&c)

{

a*=2;

b*=2;

c*=2;

}

int main()

{

int x=2, y=6, z=8;

duplicate(x,y,z);

cout<<”x=”<< x<<”, y=”<< y<<”, z=”<< z;

getch();

}

Output:

SOLUTION

#include< iostream.h>

#include< conio.h>

#include< string.h>

void chg(char * &nm)

{

strcpy(nm, "batra");

}

void main()

{

char name[ ] = "shweta";

cout<< name << "t";

chg(name);

cout<< name << "t";

getch();

}

Output of the above program would be:

SOLUTION

The return statement stops the executions and returns back to the calling function. When a return statement is executed, the function is terminated at that point.

Return statement is optional in a void function, whereas if a function returns a value, it must have a return statement.

SOLUTION

(a) void abc (int a,int b)

                         {

                               int c;

                               -------------

                          }

(b) int abc (int a; int b)

        {

             int c;

             -----------

             return(c);

          }

(c) void abc (void)

                          {

                           int c;

                           -------------

SOLUTION

Prototypes enable the compiler to provide stronger type checking. The compiler also catches the differences between the numbers of arguments used to call a function and the number of parameters in the function. It is a good programming style to declare the prototypes in the global declaration section, before the main. It adds flexibility, provides excellent quick reference to the functions used in the program and enhances documentation.

SOLUTION

Both function prototype and function definition should have must exactly have the same (i) return type (ii) function name and (iii) same argument / parameter list with same number and type in both.

SOLUTION

When function prototype appear within the defiition of calling function, it is Known as local prototype. It is local to the block in which it appears and to the blocks which appear under that block.

SOLUTION

In Declaration you will just declare the function with its return type, which shows that this function will be used in future. and usually declaration is done before starts the main loop.

In Definition you will define the function including its body and all statements, which does some tasks.

SOLUTION

Many small functions in a program make  it easier for ---
a)     program maintenance
b)     updation of the program and
c)     debugging of the program

SOLUTION

Three parts of a functions are:-
i)     Function declaration
ii)    Accessing a function. 
iii)   Returning from function.

SOLUTION

 Advantages of using functions are:
       i)      They make program easier by handling small part of the program at a time.
       ii)     Avoid ambiguity.  
       iii)    They reduce program size.
       iv)    Make program more readable and understandable.

SOLUTION

A program to explain the concept of a function is:

#include< iostream.h>

#include< conio.h>

 int cube(int a);// function declaration

 void main()

{

int x, result;

clrscr();

cout<<"Enter the number";

cin>> x;

result=cube(x); // calling the function

cout<<"n Cube of "<< x<<"n is n"<< result;

getch();

}

int cube(int a) // function definition

{

int compute;

compute=a*a*a;

return(compute);

}

Output:

SOLUTION

A program to return more than one value is:

#include< iostream.h>

#include< conio.h>

void prevnext(int x, int&prev, int&next)

{

prev=x-1;

next=x+1;

}

int main()

{

int x=98, y, z;

prevnext(x,y,z);

cout<<”Previous=”<< y<<”,Next=”<< z;

getch();

return 0;

}

Output:

SOLUTION

The program to show the addition of two numbers:

#include< iostream.h>

#include< conio.h>

int add(int c, int d)

{

 int z;

 z=c+d;

 return (z);

}

int main()

{

 int a, b, sum;

 clrscr();

 cout<<"nEnter two numbers to add";

 cin>> a>> b;

 sum=add(a,b);

 cout<<"The result is "<< sum;

 getch();

 return 0;

}

Output:

SOLUTION

We can access the structure member with the help of . or -> operator.

SOLUTION

A structure is a user defined data type. The body of structure is terminated using semicolon( ;).

SOLUTION

Technically in C++, there is no difference between a structure and a class. By default, all members are public in a structure whereas all members are private by default in a class.

SOLUTION

We define the function as:

Type function-name (parameter list)

{

body

SOLUTION

An example of built-in function is: exit().

SOLUTION

C++ allows the programmers to define their own functions. These functions are called user-defined functions.

SOLUTION

A function is a subprogram that acts on data and often returns a value.

SOLUTION

A function prototype is a declaration of the function that tells the program about the type of the value returned by the function and the number and type of arguments.

SOLUTION

The values that are passed when the function is called are called arguments or actual parameters.

SOLUTION

A function can be invoked in two ways: 
• Call by value 
• Call by reference 
In call by value, the method copies the values of actual parameters, whereas in call by reference, a reference or the address of the original variable is passed.