SOLUTION

Every file maintains two pointers called get_pointer(in input mode file) and put_pointer(in output mode file) which tells the current position in the file where writing or reading will take place.

SOLUTION

The file mode describes how a file is to be used : to read from it, to write to it, to append it and so on.

SOLUTION

Whenever an I/O function that takes a file handle as an input parameter raises an error, it will pass this file handle as a third parameter to the error handler function.

SOLUTION

seekp() and tellp() are used to manipulate the put_pointer used for performing write operations on a file.

SOLUTION

A stream is an abstraction that represents a device on which input and output operations are performed. A stream can basically be represented as a source or destination of characters of indefinite length.

SOLUTION

In computing, end-of-file, commonly abbreviated EOF is a condition in a computer operating system where no more data can be read from a data source. The data source is usually called a file or a stream.

SOLUTION

These functions operate on an offset calculation from the beginning, end, or current position in the stream.

SOLUTION

A text file is a kind of computer file that is structured as a sequence of lines. A text file exists within a computer file system.

SOLUTION

File processing in C++ is performed using the fstream class. To perform file processing, you can declare an instance of an fstream object. If you do not yet know the name of the file you want to process, you can use the default constructor. Unlike the FILE structure, the fstream class provides two distinct classes for file processing. One is used to write to a file and the other is used to read from a file.

SOLUTION

The ofstream function provides an interface to write data to files as output streams.

SOLUTION

Class hierarchy: streambuf - - > filebuf. filebuf class applies the functionality of the streambuf class to read and write from/to files.

SOLUTION

The tellg() gets the position of put pointer and therefore the output will be 1.

SOLUTION

The function seekg() sets current get position in a stream.

SOLUTION

A is the array name and contains the starting address.

SOLUTION

The reason for this is p gives the value stored in the variable p. *(&p) gives the data value stored in the address &p i.e., the data value of x. Since a points to p, *a gives the value of p. Also, b has the same address as that of a, *b also gives the value of a which in turn produces the addition of *a and *b i.e. 2.125 + 2.125.

SOLUTION

These orphaned memory blocks when increase in number, bring an adverse effect on the system. This situation is known as memory leak.

SOLUTION

When a member function is called, it is automatically passed an implicit argument that is a pointer to the object that invoked the function. This pointer is called 'this'.

SOLUTION

A function returning a reference can appear on the left-hand side of an assignment statement.
For example, min(x,y) = -2;

SOLUTION

Pointers also, may be arrayed like any other data type. To declare an array holding 5 int pointers, the declaration would be as follows:
int *ip[5];     //array of 5 int pointers
After this declaration, contiguous memory would be allocated for 5 pointers that can point to integers.

SOLUTION

Many possible reasons lead to the situation of memory leaks. Most common of these are:
1. forgetting to delete something that has been dynamically allocated (i.e., using new)
2. failing to notice that code may bypass a delete statement under certain circumstances.
3. assigning the result of a new statement to a pointer that was already pointing to an allocated object.

SOLUTION

It allocates memory of one integer to as and intializes it with value 10.

SOLUTION

In pointer arithmetic, all pointers increase and decrease by the length of the data type they point to.

SOLUTION

The statement
int *ptr = new int[10];
allocates memory of 10 contiguous integers and stores beginning address in pointer ptr. Whereas, the statement
int *ptr = new int (10);
allocates memory of one integer to ptr and initializes it with value 10.

SOLUTION

Pointer variables are declared like normal variables except for the addition of the unary * character. The general form of a particular declaration is as follows :
type * var_name;

SOLUTION

To refer to the structure members using -> operator, it is written as
struct pointer -> structure-member.

SOLUTION

A reference is a type of pointer and when it is declared it must be initialised with the variable it is a reference to.

SOLUTION

A pointer is a variable that holds a memory address, usually the location of another variable in memory.

SOLUTION

When the amount of memory to be allocated is known beforehand and the memory is allocated during compilation itself, it is referred to as static memory allocation.

SOLUTION

When the amount of memory to be allocated is not known beforehand rather it is required to allocate (main) memory as and when required during runtime itself, then, the allocation of memory at run time is referred to as dynamic memory allocation.

SOLUTION

An array is a group of homologous elements in memory, whereas a pointer is a variable that holds a memory address.

SOLUTION

A null pointer is a regular pointer of any pointer type which has a special value that indicates that it is not pointing to any valid reference or memory address.

SOLUTION

Using a pointer to a constant, the constant value can not be modified, however the pointer can be made to point to another location.

SOLUTION

The two operators that C++ offers for dynamic memory allocation and deallocation are new and delete. The operator new allocates the memory dynamically and returns a pointer storing the memory address of the allocated memory. The operator delete deallocates the memory pointed by the given pointer.

SOLUTION

The member functions of a class exist at one place in memory and are used by all the objects.  When an object calls a function, the function is automatically passed a pointer to that object.  Thus, the function has the address of the object and can use its data.  This pointer is called the ‘this’ pointer.
Example –

#include< iostream.h>

class stu{

   int rno;

   int marks;

  public:

   stu(int a, int b){

      rno=a;

      marks=b;

   }

   void disp(stu s){

     cout<< this->rno;

     cout<< this->marks;

     cout<< "nPassed Object";

     cout<< s.rno;

     cout<< s.marks;

   }

};

void main(){

  stu s1(10,100);

  stu s2(11,98);

  s2.disp(s1);

}

SOLUTION

#include< iostream.h>
       struct item{
                     int code;

    int price;

   };

item* func(item *ptr){

  cin>>ptr->code;

  cin>>ptr->price;

  return ptr;

}

void main(){

   item i1,*pi;

   pi = func(&i1);          // function call

   cout<< "from Pointer "<< pi->code<< pi->price;

   cout<< "from variable "<< i1.code<< i1.price;

}                          

SOLUTION

          #include< iostream.h>

class Emp{

       int code;

   public :

       void getdat(int x){code=x;}

       void dispdat(){cout<< "code = "<< code;}

};

Emp* func(int x, Emp &Em){

  Emp *p;

  Em.getdat(x);

  cout<< "Value passed";

  p = &Em;

  return p;

}

void main(){

   Emp e1, e2;

   Emp *ep;

   e2.getdat(3);

   ep = func(5,e1);  // function call

   e1.dispdat();

   e2.dispdat();

   ep->dispdat();

}         

SOLUTION

Once a structure has been defined, variables, including pointers can be declared for it.  When memory is allocated dynamically for a structure, it is called a dynamic structure.
Example

struct A{

     int a;

     char b;

};

A v1,*v2;

v2=new A;

SOLUTION

A structure that has a member that refers to the structure itself is known as a self referential structure.
Example -

struct guest{

     int tel;

     char name[20];

     guest *next;            // pointer to type guest

};

SOLUTION

In both the cases, the original data changes after the function call.       
When reference is passed, the prototype is something like –

void func1(int &, int &);          

The actual parameters are simply given new names and accessed through them. The function call is the same as the call when function is called by value.

When pointers are passed, the prototype is something like -

void func2(int *, int *);          

SOLUTION

A constant pointer means that the address in it cannot be changed. 

int a=12;                 // integer variable with value 12

int  *pa = &a;           // pointer pa stores address of a

++pa;                      // increment (address in)  pa

int *const cpa=&a;    // constant pointer named cpa stores address of a

++cpa;                    //error, constant pointer cannot be changed

A pointer to a constant means that the pointer holds the address of a constant. 

const int cnum=23;                // constant cnum declared

const int *pcnum = &cnum;    // pointer to a constant stores address of cnum

++cnum;                             // Error,  cnum is a constant    

SOLUTION

An array of pointers is an array, each element of which is a pointer.
An array of integer pointers would be declared as – int *N[5]; 

Now, each of the array elements, N[0], N[1], N[2], N[3] and N[4] would hold the address of an integer variable. Look at the statements below –

          int a = 12;

          int b = 23;

          int c = 34;

          int d = 45;

          int e = 56;

          N[0] = &a;

          N[1] = &b;

          N[2] = &c;

          N[3] = &d;

          N[4] = &e;

The following two statements would give the same output.

cout<< a;

cout<< *N[0];

Lets look at another example using a string.

char N[]=“Discover Wildlife”;

cout<< N;

cout<< *N;

cout<< *(N+1);

                             Output of these lines: Discover WildlifeDi

(code contd.)

char *p=N;

cout<< p;

cout<< *p;

cout<< *(p+1);

Output of these lines: Discover WildlifeDi

SOLUTION

The name of an array is regarded as a pointer.  It holds the address of the first element of the array.  Consider the statements below - 

int A[10] = {1,2,3,4,5,6,7,8,9,10};  

A is the array name, it holds the address of the first element A[0].

cout<< A;                 //displays the address of the first element

cout<< *A;               //displays value at that address i.e.  1

cout<< A+1;             //displays another address

cout<< *(A+1);          //displays  value at that address  i.e.  2

SOLUTION

The ‘*’ is also called the indirection operator and ‘&’ is also called address of operator.
When a pointer is declared, the ‘*’ is used :-    int *pa;

When an address is to be stored the ‘&’ is used :-  pa = &a;

SOLUTION

The ‘delete’ operator frees (de-allocates) the memory pointed to by the pointer.
The memory allocated using new remains allocated until it is freed using the delete operator.  If the allocated memory is not de-allocated, then with every run of the program the amount of available memory decreases.  The general form of using the  delete operator is,

          delete pointer_variable_name;

delete pa;            // frees memory pointed to by pa

delete [10] A;      // frees memory allocated to array A, array size is optional

SOLUTION

The ‘new’ operator allocates memory dynamically and returns a pointer that stores the address of the location where memory has been allocated.  The general form of allocating is :
             pointer_variable_name = new  data_type;

Here, data type can be any valid data type, including structures and classes.  Bytes are allocated according to the data type and the address is stored in the pointer variable of the same data type. 

For example :       int *pa;

                               pa = new int;

                              *pa=12;                 // 12 is stored at the address in pa

Here, 2 bytes will be allocated for an integer which will be accessed through the address in pointer pa.

SOLUTION

Static Memory Allocation : when memory to be allocated is known beforehand, it is allocated during compilation.  Generally in a program, variables are declared along with data type and arrays are declared with size and memory is allocated accordingly.
Dynamic Memory Allocation : when the amount of memory required is not known beforehand, it is allocated while the program is running, and is known as dynamic memory allocation.  Two operators are used  - new and delete. Memory for allocation at runtime is obtained from the free store or heap.

SOLUTION

Four logically separate areas are created after a C++ program is compiled.
-  One area holds all the program statements that are to be executed i.e. the compiled program code.  

- The next area holds all the global variables being used. 

- The third area, also called Stack, stores all local variables, arguments passed to functions and the return address when functions are called. 

SOLUTION

           #include< iostream.h>

class Emp{

       int code;

   public :

       void getdat(int x){code=x;}

       void dispdat(){cout<< "code = "<< code;}

};

Emp& func(int x, Emp& Em){

  Em.getdat(x);

  cout<< "Value passed";

  return Em;

}

void main(){

   Emp e1, e2;

   e2.getdat(3);

   func(5,e1) = e2;   //function call

   e1.dispdat();

   e2.dispdat();

}                           

SOLUTION

When memory is allocated dynamically using the ‘new’ operator, it remains occupied even when the program is over.  Such occupied memory blocks are known as orphaned memory blocks .  Gradually, as the number of such blocks increases, there is less memory available to the program which affects its working.  This situation is called Memory Leak.
Some reasons for memory leak are - 

·          there is no delete in the program to free dynamically allocated memory  

·          the statement with delete is bypassed in certain situations

·          ‘new’ assigns the value to a pointer which already holds an address

Memory leak can be avoided by –

·          always freeing the dynamically allocated memory

SOLUTION

       #include< iostream.h>
             void main()

{

   char *tmp; int i,j;

   char *list[]={"Asia", "Bahamas","Canada","Denmark","England"};

   for( i=0;i< 5;i++)

       cout<< list[i]<< endl;

   for( i=0,j=4; i < 2;i++,j--)

{

       tmp=list[i];

       list[i]=list[j];

       list[j]=tmp;

}

   for( i=0;i < 5;i++)

      cout<< list[i]<< endl;

SOLUTION

       #include< iostream.h>

void main()
{

    char A[80];

    char *str;

    char* funblank(char*);          // function prototype

    cout<< "Enter string ";

    cin.getline(A,80);

    str=funblank(A);                   // function call

    cout<< A<< endl;

    cout<< str<< endl;

}

   char* funblank(char* t)
{

   char *tmp;int i=0;

   while(*t !='?')
   {

       if(*t!=' ')
      {

          tmp[i]=*t;

          ++i;

       }

       ++t;

    }

    tmp[i]='?';

    return tmp;

SOLUTION

In stack, the items are stored sequentially, thus forming a linear data structure.

SOLUTION

In tree, the elements are not stored in a sequence therefore it’s a non-linear data structure.

SOLUTION

In insertion sort a single element is get considered at a time, inserting each in its suitable place.

SOLUTION

Bubble sort works by repeatedly stepping through the list to be sorted, comparing two items at a time and swapping them if they are in the wrong order.

SOLUTION

Insertion sort works if the very first element stores the minimum element of the array. In C++, INT_MIN constant from Limits.h, can be used to store minimum possible integer value.

SOLUTION

No. of rows = 4 - (-2) + 1 = 4 + 2 + 1 = 7
No. of columns = 6 - (-3) + 1 = 6 + 3 + 1 = 10
No. of elements = Rows X Columns = 7 X 10 = 70 elements.

SOLUTION

this pointer refers to the current object we are working on.

SOLUTION

In call by value method, the called function creates its own copies of original values sent to it. Any changes, that are made, occur on the function’s copy of values and are not reflected back to the calling function.

SOLUTION

A pointer points to the address of a variable. It cannot be used as integers.

SOLUTION

j is a reference to i. If, we assign value of p to j, then value of i also changes.

SOLUTION

Data can be of different types. It can be numeric, alphabetic, or alphanumeric.

SOLUTION

&::i is an illegal declaration used in the code.

SOLUTION

“string.h” header file defines the string functions like strlen, strcpy. These functions cannot be used without using string.h header file.  

SOLUTION

Simple data structures are normally built from primitive data types like integers, real, characters, boolean.

SOLUTION

Application (or user) level is a way of modelling real-life data in a specific context, also called the problem domain. The data structure can be designed from user level perspective.

SOLUTION

Non-primitive data types are those data types types which are composed of primitive data types such as int, float, char.

SOLUTION

The syntax of single dimension array is “datatype arrayname[size]” whereas multi dimension arrays are accessed using more than one index. Example names[][]. It can be 2 dimensional or 3 dimensional.

SOLUTION

One space is needed for null character, which acts as a terminator symbol.

SOLUTION

One space is needed for null character, which acts as a termination symbol.

SOLUTION

The syntax of single dimension array is “datatype arrayname[size]” whereas multi dimension arrays are accessed using more than one index. Example names[][]. It can be 2 dimensional or 3 dimensional.

SOLUTION

Simple data structures can be combined in various ways to form more complex structures called compound data structures.

SOLUTION

The total number of elements in an array [a][b] is a x b. Here 5 x 6 =30.

SOLUTION

A pointer is a variable that holds a memory address, usually the location of another variable in memory.

SOLUTION

In computer science, dynamic memory allocation (also known as heap-based memory allocation) is the allocation of memory storage for use in a computer program during the runtime of that program.

SOLUTION

Static memory allocation refers to the process of allocating memory at compile-time before the associated program is executed, unlike dynamic memory allocation or automatic memory allocation where memory is allocated as required at run-time.

SOLUTION

A memory leak or leakage in computer science is a particular type of memory consumption by a computer program where the program is unable to release memory it has acquired.

SOLUTION

The pointer is an integer that is intended to hold a memory address. The pointer may be an array or scalar. A pointer can be an assumed size array – that is, the last dimension may be left unspecified by using a '*' in place of a value – but a pointer cannot be an assumed shape array. No space is allocated for the pointer.

SOLUTION

The 'this' pointer is a pointer accessible only within the non-static member functions of a class, struct, or union type. It points to the object for which the member function is called.

SOLUTION

Functions can be declared to return a reference type. There are two reasons to make such a declaration. The information being returned is a large enough object that returning a reference is more efficient than returning a copy. The type of the function must be an l-value.

SOLUTION

An array of pointers is used to store addresses of more than one data elements. Each element of the pointer array points to the address of an element.

SOLUTION

The pointer variable is used to store address of a varible. we can declare a pointer variable using astrick (*) Example: int *marks; Here marks is a pointer variable which can hold address of an integer variable.  

SOLUTION

char * funstring(char *);

SOLUTION

    float rate;
          float *fp;

          fp = &rate;

SOLUTION

Every pointer has a base data type.  It holds the address of variables of that data type.  When 1 is added to a pointer, the size of the data type is added to it.  Suppose pointer pa holds the address of integer variable a, as 1001.  Adding 1 to pa will give 1003.  This is because the size of int is 2.
Suppose pf is a pointer that holds the address of float variable f, as 2300.  Adding 3 to pf will add  3 times the size of float i.e. 12, to the address in pf, making it 2312.

SOLUTION

The four regions are:
1. Program code
2. Global variables
3. Stack
4. Heap

SOLUTION

Free Store is also called Heap. It is unallocated memory that is used during program execution. Memory that is dynamically allocated from this free store is unnamed and is manipulated through the address i.e. pointers.

SOLUTION

A reference variable is an alias or another name for an existing variable while a pointer is a variable that stores an address.  The reference does not occupy memory space but a pointer does. The declaration too is different –
          int a;                      // variable  named a

int &alsoa = a;         // reference alsoa created, is an alias for a;

int  *pa;                // pointer pa created

pa=&a;                 // address of a stored in pa          

SOLUTION

Pointers are variables that store memory addresses.

SOLUTION

Normally when we declare a pointer, we give it a type which is the same as the type of the variable whose address it will store.  i.e.  int *ptr; will create pointer ptr which will hold addresses of integer variables.
Pointer to void is like a general purpose pointer that can store address of any data type.  It is used only in certain situations.To declare a pointer to void, give the statement  -  void * ptr;

SOLUTION

A is the address where the system has placed the array and it will stay here till the end of the program. As it is the base address of the array, it is a constant and cannot be changed. However, we can declare a pointer and assign A to it. Now, the pointer variable can be incremented, if required. 

int A[]={1,2,3,4,5};

int *p;

p=A;

SOLUTION

A[3] refers to the value in array A with index number 3.
*(A + 3) refers to the value at the address A + 3.
In both the cases here, the same element is accessed.

SOLUTION

In statement -          int *p1 = new int(12);
Bytes are allocated in memory, to store an integer and initialized to 12, the address of this memory location is stored in pointer p1. 

In statement -          int *p2 = new int [12];

SOLUTION

Compound data structures are classified into following two types : Linear data structures and non-linear data structures. Linear data structures are single level data structures whereas non-linear data structures are multilevel data structures.

SOLUTION

Data Structure refers to a named collection of variables of different data types which can be possessed as a single unit.

SOLUTION

There are different perspectives while designing a data structure. The implementation requires writing a set of procedures that create and manipulate instances of that structure.

SOLUTION

Primitive data types are fundamental or standard data types, such as integer, real or character data types.

SOLUTION

Non-primitive data types are defined by the users. That is why, they are called as user defined data types.

SOLUTION

A string of characters is collection of character array. A character array is also known as character string.

SOLUTION

This is because the last element of an array is a null character ‘0’.