Unix, C & C++ UNIT - V Snapshot

Introduction Kind of inheritance C++ inheritance and Class Scope Types of inheritance Virtual Base Class Pointers Pointers to Objects this Pointer Pointers to Base and the Derived Classes Virtual Functions Abstract classes Introduction to Files Opening and closing of files Random Access File Command Line Argument UNIX Shell Programming Basic Unix Commands Vi Editor Programming the Shell

5.0

Introduction

It is a fundamental aspect of human intelligence to seek out, recognize, and create relationships among concepts. We build hierarchies, matrices, networks, and other interrelationships to explain and understand the ways in which things interact. C++ attempts to capture this in inheritance hierarchies. Inheritance is a technique of organizing information in a hierarchical form. Typically, the pure virtual functions in an abstract base class are never implemented. Because no objects of that type are ever created, there is no reason to provide implementations, and the ADT works purely as the definition of an interface to objects which derive from it. Files are used to store information permanently and to retrieve it whenever required. The file handling techniques of C++ support file manipulation in the form of stream objects. UNIX is an increasingly popular operating system. Traditionally used on minicomputers and workstations in the academic community, UNIX is now available on personal computers, and the business community has started to choose UNIX for its openness.

5.1

Objective

The objective of this lesson makes the learner aware of the fundamentals of inheritance, pointers and files. The fundamental concepts include types of inheritance,

Page 113

Unix, C & C++

pointers to objects, this pointer, virtual functions and UNIX shell programming. Towards end of this lesson the student can get the basic knowledge about command line argument and advanced shell programming.

5.2
5.2.1

Content

Inheritance One of the most useful features of classes is inheritance. It is possible to declare a class, which inherits the properties of another class or classes. This means that, with good class design, applications, which are based on proven re-usable code, can be built. Thus classes extend the feature of reusability of code, particularly complex code. Definition: Inheritance is the mechanism by which a new class inherits the members of an already existing class. Suppose a class A inherits the properties of a class B, it means A inherits from B. Objects of class A thus have access to attributes and methods of class B without the need to redefine them. If class A inherits from class B, then B is called superclass of A. A is called subclass of B. Objects of a subclass can be used where objects of the corresponding superclass are expected. This is due to the fact that objects of the subclass share the same behaviour as objects of the superclass. In addition to the members inherited from the superclass, the subclass can also include additional members. Superclasses are also called parent classes. Subclasses may also be called child classes or just derived classes. The subclass can again be inherited, making this class the superclass of the new subclass. This leads to a hierarchy of superclass/subclass relationships. The general format for inheriting a class is: class new_class: access specifier existing_class { members; }; In this case, new_class is the name of the subclass that is to be created. access specifier can be either public, private or protected. existing class is the name of the superclass whose members are to be inherited by the subclass. members refer to the extra instance variables and functions that the subclass can include in addition to the members of its superclass. If a subclass inherits from more than one class then these classes along with an access specifier have to be separated by a comma ,. class new_class: access specifier existing_class1, access specifier existing_class2 Page 114

Unix, C & C++

{ members; }; where, existing_class1 and existing_class2 are the already existing class that are to be inherited. Example Consider a class called Sphere defined as follows: class Sphere { int r; public: Sphere(); int getDiameter(); float getVolume(); }; Sphere::Sphere() { cout<< Enter radius; cin>>r; } int Sphere:: getDiameter() { return (r+r); } float Sphere:: getVolume() { return (4/3)*3.14*r*r*r; } Now to create a class for ball and since a "ball is a sphere" the members of the sphere class can be inherited in creating the ball class. This way repeating the same set of coding can be avoided. The ball class is created as follows: class ball: public Sphere { public: void ballcolor(); }; void ball::ballcolor() { cout<< Ball color is red;

Page 115

Unix, C & C++

} The class "ball" has all the member functions present in Sphere. In addition to the members r, getDiameter(), getVolume() inherited from the Sphere, an additional member function has been added ("ballcolor()") to hold the color of the ball. When an object of class ball is created in the main(), all the functions (getDiameter(), getVolume() and ballcolor()) can be called using this object. However reverse is not true. This means that using an object of class Sphere the function ballcolor() cannot be called. #include<iostream.h> class Sphere { int r; public: Sphere(); int getDiameter(); float getVolume(); }; Sphere::Sphere() { cout<< "Enter radius:"; cin>>r; } int Sphere:: getDiameter() { return (r+r); } float Sphere:: getVolume() { return (4/3)*3.14*r*r*r; } class ball: public Sphere { public: void ballcolor(); }; void ball::ballcolor() { cout<< " Ball color is red"; } main() { ball b;

Page 116

Unix, C & C++

cout<< b.getDiameter()<<"\n"; cout<<b.getVolume()<<"\n"; b.ballcolor(); } Output: Enter radius: 12 24 5425.92 Ball color is red When the object b of class ball is created the constructor of the super class is called. If there exists a constructor for ball class, first the constructor of Sphere class is called and then the constructor of the ball class is called. Through the constructor a value is assigned to the instance variable r and then the diameter, volume and color are computed. 5.2.1.1 Kinds of Inheritance C++ provides three forms of inheritance: private inheritance (the default) protected inheritance public inheritance. a. Private Inheritance General form class Derived:Base_Class { access specifier: members; }; or class Derived: private Base_Class { access specifier: members; }; In this case, the Derived class inherits the members of the Base_class in private mode. So, all the members of the Base_class become private in Derived class. Thus, Protected Members become Private Members Public Members become Private Members

Page 117

Unix, C & C++

b. Protected Inheritance General form class Derived: protected Base_Class { access specifier: members; }; In this case, the Derived class inherits the members of the Base_class in protected mode. So, the protected and public members of the Base_class become protected in Derived class. Thus, Protected Members become Protected Members Public Members become Protected Members c. Public Inheritance General form class Derived: public Base_Class { access specifier: members; }; In this case, the Derived class inherits the members of the Base_class in public mode. So, the public members of the Base_class become public in Derived class. Thus, Protected Members become Protected Members Public Members become Public Members Note that the private members of a base class will never be accessible in the derived class. 5.2.1.2 C++ Inheritance and Class Scope

Every class in C++ has its own individual scope even when it inherits members from other classes. Those members that are explicitly defined in the class definition of a derived class belong to the scope of that class, those members which are members in virtue of inheritance belong to the scope of the super-class from which they were inherited. The scope rules for C++ classes have a number of consequences. 1) Those member functions which belong to the scope of a derived class will only have access to the data members within the scope of the derived and to those data members which are inherited from the public or protected section of the super-

Page 118

Unix, C & C++

class. 2) Constructors for a derived type must make use of super-class constructors in order to initialise the data members inherited from the super-class. Where the data members of a superclass should not be accessible for all but accessible to members of the subclass, those members should be declared in the protected section of the superclass. 5.2.1.3 Types of Inheritance

The inheritances seen so far come under the category of single inheritance. There are five different types of inheritance namely: Single Inheritance Multilevel Inheritance Multiple Inheritance Hierarchical Inheritance Hybrid Inheritance

Single Inheritance In this type of inheritance a new class called the derived class inherits the members of a single class called the base class. There is only one level of inheritance. This means that the newly created class does not have any derived class and has only a single parent class. This is diagrammatically represented as:

class A

class B
Single Inheritance In this case class A is the super class of class B. Multi-level inheritance In this type of inheritance a new class called the derived class inherits the

Page 119

Unix, C & C++

members of a single class called the base class. This newly created class becomes a parent class for another class. Thus, there exists more than one level of inheritance. This is diagrammatically represented as:

class A class B

class C
Multi-level inheritance In this case class A is the super class of class B, which in turn is the base class of class C. Multiple Inheritance In this type of inheritance a new class called the derived class inherits the members of more than one class. This is diagrammatically represented as follows:

class A

class B

class C
Multiple inheritance

In this case, class C inherits the members of both class A as well as class B. Thus class C has two parent classes.

Page 120

Unix, C & C++

Hierarchical Inheritance In this type of inheritance more than one new class inherits the members of a single base class. This is diagrammatically represented as follows:

class A

class B

class C

Hierarchical inheritance In this case, two classes B and C inherit the members of class A. Hybrid Inheritance A combination of any two or more types of inheritance is called hybrid inheritance.

class A class B class D

Hybrid Inheritance
In this case, class B and C inherit the members of class A through hierarchical inheritance and these two classes (B and C) are in turn inherited by D through multiple inheritance. Multiple Inheritance Single inheritance implies that a class has only one direct super-class; Multiple inheritance allows the derivation of a class from more than one base class. Consider a Page 121

class C

Unix, C & C++

class as follows: #include<iostream.h> class Add { int x,y; public: Add() { cout<< Constructor Inside Add class<<endl; cout<< Enter two numbers; cin>>x>>y; } void sum() { cout<< Sum<<(x+y)<<endl; } }; class Subtract { int a,b; public: Subtract() { cout<< Constructor Inside Subtract class<<endl; cout<< Enter two numbers; cin>>a>>b; } void diff() { cout<< Difference<<(a-b)<<endl; } }; class Math : public Add, public Subtract { public: Math() { cout<< Constructor Inside Math class<<endl; } }; main() { Math m; m.sum(); m.diff();

Page 122

Unix, C & C++

} Output: Constructor Inside Add class Enter two numbers 3 4 Constructor Inside Subtract class Enter 2 numbers 5 6 Constructor Inside Math class Sum7 Difference-1 The class Math has two base classes Add and Subtract. By creating an object of class Math the members sum() and diff() of class Add and Subtract respectively can be called. However, using an object of class Add, the function diff() cannot be accessed and similarly using an object of class Subtract the function add() cannot be accessed. 5.2.2 Virtual Base Class

A potential problem for multiple inheritance occurs when a chain of inheritance derives from a single class via two or more paths, thus causing duplication of inherited data and functions.

As can be seen from the diagram, classes B and C inherit the member function fun() of class A using hierarchical inheritance. Class D inherits the members of class B and class C through multiple inheritance. Ultimately, class D will have 2 copies of the function fun()- one inherited from class B and the other inherited from class C. While Page 123

Unix, C & C++

trying to access the function fun() in D, the compiler will not know which function to access although both functions are the same. This will result in compilation error. To avoid this problem the keyword virtual is included in the inheritance list: class A { public: int memberA; //etc. }; class B : virtual public A { // B members ... }; class C : virtual public A { // C members ... }; class D : public B, public C { // has access to one and only one memberA } To illustrate this consider the following example: #include<iostream.h> class Grand { protected: int data; public: Grand() { data =1; } }; class Mother : public Grand { }; class Father : public Grand { }; class Child : public Mother, public Father { Page 124

Unix, C & C++

public: int getdata() { return data; // This is an error since the term data is ambiguous } }; void main() { Child c; cout << c.getdata(); } Output: None- error in name resolving In this case the class Child has two copies of the variable data of class Grand. One it inherits through the class Father and the other through the class called class Mother. When the function getdata() of the Child class is called the compiler gets confused as it would not know which of the data it has to call, although both are the same. This problem can be fixed by using the keyword virtual when deriving class Mother and class Father from class Grand. The program is thus modified as follows: Example #include<iostream.h> class Grand { protected: int data; public: Grand() { data =1; } }; class Mother : virtual public Grand {}; class Father : virtual public Grand {}; class Child : public Mother, public Father { public: int getdata() { return data; } }; Page 125

Unix, C & C++

void main() { Child c; cout << c.getdata(); } Output: 1 The virtual keyword tells the compiler to inherit only one sub-object into subsequent derived classes. 5.2.3 Pointers

Pointers can be confusing and at times, one may wonder why one would ever want to use them. The truth is, they can make some things much easier. For example, using pointers is one way to have a function modify a variable passed to it; it is also possible to use pointers to dynamically allocate memory, which allows certain programming techniques, such as linked lists. Pointers point to locations in memory. Picture a big jar that holds the location of another jar. In the other jar holds a piece of paper with the number 12 written on it. The jar with the 12 is an integer and the jar with the memory address of the 12 is a pointer Pointer syntax can also be confusing, because pointers can both give the memory location and give the actual value stored in that same location. When a pointer is declared, the syntax is this: variable_type *name; Notice the *. This is the key to declaring a pointer and it is used before the variable name. There are two ways to use the pointer to access information about the memory address it points to. It is possible to have it give the actual address to another variable. To do so, simply use the name of the pointer without the *. However, to access the actual value in that particular memory location pointed by the pointer, use the *. The technical name for doing this is dereferencing. In order to have a pointer actually point to another variable it is necessary to have the memory address of that variable also. To get the memory address of the variable, put the & sign in front of the variable name. This helps in retrieving the address of that variable. This is called the reference operator, because it returns the memory address. Example #include <iostream.h> int main() { int x; int *pointer; Page 126

Unix, C & C++

pointer =&x; cout<<Enter the input : ; cin>>x; cout<<*pointer; return 0; } Output: Enter the input : 3 3 The cout outputs the value in x. Why is that? Well, look at the code. The integer is called x. A pointer to an integer is then defined as "pointer". Then it stores the memory location of x in pointer by using the ampersand (&) symbol. If you wish, you can think of it as if the jar that had the integer had an ampersand (&) in it then it would output its name (in pointers, the memory address) Then the user inputs the value for x. Then the cout uses the * to put the value stored in the memory location of pointer. If the jar with the name of the other jar in it had a * in front of it, then it would give the value stored in the jar, the name of which is stored in this jar. It is not too hard, the * gives the value in the location. The un astricked gives the memory location. Notice that in the above example, pointer is initialized to point to a specific memory address before it is used. If this was not the case, it could be pointing to anything. This can lead to extremely unpleasant consequences to the computer. one should always initialize pointers before you use them. The keyword new is used to initialize pointers with memory from free store (a section of memory available to all programs). The syntax looks like the example: Example int *ptr = new int; It initializes ptr to point to a memory address of size int (because variables have different sizes, number of bytes, this is necessary). The memory that is pointed to becomes unavailable to other programs. This means that the careful coder will free this memory at the end of its usage. The delete operator frees up the memory allocated through new. To do so, the syntax is as in the example. Example delete ptr; After deleting a pointer, it is a good idea to reset it to point to NULL. NULL is a standard compiler-defined statement that sets the pointer to point to, literally, nothing. By doing this, you minimize the potential for doing something foolish with the pointer. Pointers to Objects As stated earlier, a pointer can point to an object created by a class. Consider the

Page 127

Unix, C & C++

following statement: item x; where item is a class and x is an object defined to be of type item. Similarly one can define a pointers it_ptr of type item as follows: item *it_ptr; Object pointers are useful is creating object at run time. Pointer is used to access the public members of an object. Consider a class item defined as follows: class item { int code; float price; public: void getdata(int a, float b) { code = a; price = b; } void show(void) { cout << code : << code << \n << Price: << price << \n\n; } }; Lets us declare an item variable x and a pointer ptr to x as follows: item x; item *ptr = &x; The pointer ptr is initialized with the address of x. One can refer to the member functions of item in two ways, one by using the dot operator and the object, and another by using the arrow operator and the object pointer. The statements, x.getdata(100,75.50); x.show(); are equivalent to ptrgetdata(100,75.50); ptrshow(); Since *ptr is an alias of x, one can also use the following method: (*ptr).show(); The parenthesis is necessary because the dot operator has higher precedence than the indirection operator *. Page 128

Unix, C & C++

Create the objects using pointers and new operator as follows: item *ptr = new item; This statement allocates enough memory for the data members in the object structure and assigns the address of the memory space to ptr. Then ptr can be used to refer to the members as shown below:

ptrshow();
If a class has a constructor with arguments and does not include an empty constructor, one must supply the arguments when the object is created. Create an array of objects using pointers. For Example, the statement item *ptr = new item[10];//array of 10 objects create a memory space for an array of 10 objects of item. Remember, in such cases, if the class contains constructors, it must also contain an empty constructor. The following example illustrates the use of pointers to objects. One object is assigned to another object rather than passing the values as an argument. #include <iostream.h> class item { int code; float price; public: void getdata(int a, float b) { code = a; price = b; } void show(void) { cout << "Code : " << code << "\n"; cout << "Price : " << price << "\n"; } }; const int size = 2; main() { item *p = new item [size]; item *d = p; int x, i; float y; for(i=0;i<size;i++) { Page 129

Unix, C & C++

cout << "Input code and Price for Item : " << (i+1); cin >> x >> y; p->getdata(x,y); p++; } for(i=0; i<size;i++) { cout << "Item : " << (i+1) << "\n"; d->show(); d++; } } Output: Input code and Price for Item 1 : 1001 5000 Input code and Price for Item 2 : 1002 10000 Item : 1 Code : 1001 Price : 5000 Item : 2 Code : 1002 Price : 10000 this Pointer C++ uses unique keyword called this to represent an object that invokes a member function. this is a pointer that points to the object calls this function. For example, the function call A.max() will set the pointer this to the address of the object A. The starting address is the same as the address of the first variable in class structure. This unique pointer is automatically passed to a member function when it is called. The pointer this acts as an implicit argument to all the member functions. Consider the following simple example: class ABC { int a; .... .... }; The private Variable a can be used directly inside a member function, like a = 123; The following statement is used to do the same job; this -> a = 123; Page 130

Unix, C & C++

Since C++ permits the use of shorthand form a = 123, programmers are not using the pointer in this explicit manner. However, user have been implicitly using the pointer this when overloading the operators using member function. Recall that, when a binary operator is overloaded using a member function, one passes only one argument to the function. The other argument is implicitly passed using the pointer this. One important application of the pointer this is to return the object it points to. For example, the statement return *this; inside a member function will return the object that invoked the function. This statement assumes importance when we want to compare two or more objects inside a member functions and return the invoking object as a result. Example: person greater(person x) { if x.age > age; return x; // argument object else return *this // invoking object Invoke the above function by the call, max = A.greater(B); This function will return the object B (argument object) if the age of the person B is greater than of A, otherwise, it will return the object A (invoking object) using the pointer this. Remember, the dereference operator * produces the contents at the address contained in the pointer. A complete program to illustrate the use of this is given below. #include <iostream.h> #include <string.h> class person { char name[20]; int age; public: person (char *s, int a) { strcpy(name, s); age = a; } person greater(person x) { if(x.age >= age) return x; Page 131

Unix, C & C++

else return *this; } void display(void) { cout << "Name :" << name <<"\n"; cout << "Age :" << age << "\n"; } }; main() { person P1("Arun",37), P2("Kumar",30), P3("Subash",40); person P(" ",0); P = P1.greater(P3); //P3.greater(P1) cout << "Elder person is:\n"; P.display(); P = P1.greater(P2); //P2.greater(P1) cout << "Elder Person is :\n"; P.display(); getch(); } Output: Elder person is: Name :Subash Age :40.549999 Elder Person is : Name :Arun Age :37.5 Pointers to Base and Derived Classes A pointer to a base class can be assigned the address of one of the bases derived class objects. If the derived class overrides members of the base, the compiler associates pointer reference accesses with the base class components of the object. This means that if a derived class member overrides a base class member, the pointer ignores the override. #include<iostream.h> class Base { public: void fun_base() Page 132

Unix, C & C++

{ cout << "\nBase"; } }; class derv : public Base { public: void fun_der() { cout << "\nDerv1"; } }; void main() { derv dv1; derv *ptr; ptr=&dv1; ptr->fun_base(); } Output: Base 5.2.4 Virtual Functions

The same function name is used in both the base and derived classes, the function in base class is declared as virtual using the keyword virtual preceding its normal declaration. When a function is made virtual, c++ determines which function to use at run time based on the type of objects pointed to by the base pointer, rather than the type of the pointer. When a virtual function is called from a pointer, the compiler does not always know what type of object the pointer is pointing to. In this case, it may not know which version of the function to call at compile time and this judgment is delayed until runtime. At runtime, when the function call is executed, the code finds out the type of object whose address is in the pointer and calls the appropriate function, depending on the class of the object. Static Binding As in traditional programming languages, the compiler calls fixed functions based on the code. The linker replaces the identifiers with a physical address. Essentially, all function calls are resolved at compilation itself. Connecting to the functions in the normal way at compilation is called early or static binding.

Page 133

Unix, C & C++

Statbind.cpp #include<iostream.h> class Base { public: void show() { cout << \nBase; } }; void main() { Base b; b.show(); } Output: Base Late Binding Selecting a function during runtime is called late or dynamic binding. In this program, the compiler does not know which version of show() to call since it depends on which type of object ptr points to. It could be an object of derv1 or derv2 class. At runtime the program sees which type of object ptr points to and accordingly calls either derv1::show() or derv2::show. dynabind.cpp #include <iostream.h> class Base { public: virtual void show() { cout << \nBase; } }; class derv1 : public Base { public: void show() { cout << \nDerv1; }

Page 134

Unix, C & C++

}; class derv2 : public Base { public: void show() { cout << \nDerv2; } }; void main() { derv1 dv1; derv2 dv2; Base* ptr; ptr = &dv1; ptr-> show(); ptr = &dv2; ptr->show(); } Output: Derv1 Derv2 Late binding increases the power and flexibility of the program. It is also used to perform the same kind of action on different objects. However it requires some overhead and excessive use of late binding results in loss in speed and reduced runtime efficiency of code. Abstract Classes Abstract classes are classes from which no objects will be instantiated, but serve as the base for derived classes. They are enforced in C++ using pure virtual functions. A class that contains at least one pure virtual function is said to be an abstract class since it contains one or more functions for which there are no definitions. No object of an abstract class can be created. An abstract class is designed only to act as a base class, upon which other classes may be built. #include<iostream.h > class A { public: virtual void print() = 0; }; void main()

Page 135

Unix, C & C++

{ A *a; a = new A; // This object cannot be created a->print(); } Program will result in an error Example #include <iostream.h> class number { protected: int value; public: virtual void show() = 0; // pure virtual function void Setvalue(int v) { } }; class hexa : public number { public: void show() { cout << The number is : << value << endl; } }; void main() { hexa h; h.Setvalue(15); h.show(); } Output: The number is: 1 Since the class number has a function show() assigned zero (without code), it is called as an abstract class and it cannot be instantiated. Pure Virtual Functions

Page 136

Unix, C & C++

A pure virtual function is a virtual function with no body. This is so when there is no need for the base class version of a particular function. The declaration of the pure virtual function has an assignment-to-zero notation to indicate that there is no definition for the function. The prototype for this is virtual return_type Function_name(parameter list)=0; When a derived class does not redefine a virtual function, the version defined in the base class will be executed. In situations like this, a base class may not be able to define an object sufficiently to allow a base class virtual function to be created or like all derived classes override a virtual function. To handle these kind of cases, C++ supports pure virtual functions. The compiler requires each derived class to either define the function or re declare it as a pure virtual function. A class containing pure virtual functions cannot be used to declare any objects of its own. If the derived class fails to override the pure virtual function then an error is encountered. Example #include <iostream.h> class number { protected: int value; public: virtual void show() = 0; // pure virtual function void Setvalue(int v) { value = v; } }; class hexa : public number { public: void show() { cout << The number is : << hex << value << endl; } }; void main() {

Page 137

Unix, C & C++

hexa h; h.Setvalue(15); h.show(); } Output: The number is: f Here show() is a pure virtual function and is not defined completely in the class number. It is defined only in the subclass hex. As a result no instance of the class number can be created (since it is not complete) and number is called an abstract class. 5.2.5 File Class and Hierarchy

Files are used to store information permanently and to retrieve it whenever required. The file handling techniques of C++ support file manipulation in the form of stream objects. A stream is a general name given to the flow of data in an input/output process. In fact cin and cout used so far are themselves stream objects. These stream objects are pre-defined in the header file iostream.h. Both cin and cout are used for standard input and output respectively. The extraction operator >> is a member of the istream class and the insertion operator << is a member of the ostream class. Both of these classes are derived from ios class. Disk files require a different set of classes than files used with standard input and output. C++ has two basic classes to handle files, ifstream and ofstream. ifstream handles file input (reading from files) and ofstream handles file output (writing to files). There is another class called fstream which can handle both input and output. All these classes are present in the header file fstream.h. Hence this header file has to be included for programs pertaining to disk file handling. The following diagram illustrates the stream class hierarchy.

Stream Class Hierarchy

Page 138

Unix, C & C++

5.2.5.1 open()

Opening and Closing of files

The first operation generally done on an object of one of the stream classes is to associate it to a real file, that is to say, to open a file. The function used for this purpose is open(). The general syntax of open() is: void open (const char * filename, openmode); where filename is a string of characters representing the name of the file to be opened and openmode is a combination of the following flags: ios::in ios::out ios::ate ios::app ios::binary Open file for reading Open file for writing Erase file before reading or writing Every output is appended at the end of file Binary mode

The class ios is a virtual base class for the istream and ostream. The iostream(input and output stream) is a class with multiple inheritance from both istream and ostream. These flags can be combined using bitwise operator OR (|). For example, if a file "example.bin" is to be opened in binary mode to add data it can be written as follows: ofstream file; file.open ("example.bin", ios::app | ios::binary); Suppose no mode is specified, this function will directly open an already existing file in read mode when used with an object of ifstream and in write mode when used with an object of ofstream. The member functions open of classes ofstream, ifstream and fstream include a default mode when opening files that vary from one to other: Class ofstream ifstream fstream Default mode to parameter ios::out ios::in ios::in | ios::out

The default value is only applied if the function is called without specifying a mode parameter. If the function is called with any value in that parameter the default mode is stepped on, not combined. close()

Page 139

Unix, C & C++

When reading, writing or data manipulation operations on a file are complete the file has to be closed so that it can be used for some other application. The function close()is used for this purpose and it terminates the connection between the stream and buffer. The general syntax is: void close (); Once this member function is called, the stream object can be used to open another file, and the file is available again to be opened by other process. eof() The function eof() returns true (non-zero value) if end-of-file is encountered while reading a file. Otherwise the function returns a false (zero) value. This function is generally used while reading from a file. Writing a text to a file The following program illustrates opening a file and writing a set of lines to the specified file. //storing strings of text on a text file #include <fstream.h> void main() { ofstream outfile; outfile.open (outfile.txt); outfile << This is my first file<<endl; outfile.close(); } Note: A file called outfile.txt with the specified text will be created. No output will appear on the monitor. The program first creates an object of ofstream. The open() function is called using this object and a file by name outfile.txt is created. To write into this file the insertion operator is used along with the object of ofstream. This is very similar to writing into standard output except for the fact that the output is now directed to the file instead of the monitor. The last statement outfile.close(); disconnects the file document from the output stream outfile.The following program accepts the input from the user and writes into a file. The program terminates when the user inputs the character 0.

Page 140

Unix, C & C++

#include <fstream.h> void main() { ofstream of; char c; of.open (abc.txt); cin>>c; while(c!= 0) { of << c; cin>>c; } of.close(); } The above program first accepts an input from the user. It checks if that character is not equal to zero. If it is not, it enters the while loop and writes that character into a file. This way, it accepts all the characters one by one and writes into the file until the user inputs a zero. Reading a text from a file The following program illustrates how to open a file, read its contents and display it on the screen. The program accepts a file name from the user. When the user supplies a file name, the program checks if such a file exists and the program exits if the file does not exist. The function fail() is used for this purpose and returns true if the file is not opened. //Reading the contents of a text file and printing it out #include <fstream.h> #include <iostream.h> #include <iomanip.h> #include <stdlib.h> void main() { ifstream infile; char fname1[20]; char ch; cout << "Enter the filename to be read \n"; cin >> fname1; infile.open(fname1); if (infile.fail()) {

Page 141

Unix, C & C++

cerr << "No such file exists \n"; exit(1); } while (!infile.eof()) { infile>>ch; cout<<ch; } infile.close(); } // end of program Output: Enter the filename to be read outfile.txt This is my first file The program uses an object of ifstream for opening the file, as the contents from the file are to be read. The program uses a while loop to check if all the contents of the file are read. The expression !infile.eof() will return true as long as the end of file is not reached. If the ! symbol is missed out the program will not read anything from the file. Thus the while loop ensures that all the characters till the end of the file are read. Inside the loop the object of ifstream is used along with the extraction operator to read the content of the file. This is again similar to cin except that the contents are now read from the file instead of keyboard. Once a character from the file is read it is printed on the monitor using the cout statement. Care should be taken to ensure that both these statements appear inside the loop as otherwise the output will not be proper. It is always not necessary to use the >> operator for reading from a file. A function called getline() can also be used for this purpose. The following program uses a getline() function for reading from a file. The function getline() copies the content of a file into a character array which is then printed. // reading a text file #include <iostream.h> #include <fstream.h> int main () { char buffer[256]; ifstream examplefile ("outfile.txt"); while (! examplefile.eof() ) { examplefile.getline (buffer,100); cout << buffer << endl; }

Page 142

Unix, C & C++

} Output: This is my first file Reading and Writing objects to a file C++ supports features for writing to and reading from the disk file objects directly. The binary input and output functions read() and write() are designed to handle the entire structure of an object as a single object, using the computers internal representation of data. These functions are included in the File streams. The function write() is a member function of ostream, also inherited by ofstream. The function read() is member function of istream and it is inherited by ifstream. Objects of class fstream have both the functions. Their prototypes are: write ( char * buffer, streamsize size ); read ( char * buffer, streamsize size ); where, buffer is the address of a memory block where read data are stored or where the data to be written are taken from. The size parameter is an integer value that specifies the number of characters to be read to/written from the buffer. a. write() The write() member function is used to save the stream of objects on a specified file. The following program segment depicts how to write objects belonging to a class into a file using the write() function. #include <fstream.h> class emp_info { private: char name[30]; int age; public: void input_data() { cout<< Enter the name : <<endl; cin>>name; cout<< Enter the age : <<endl; cin>>age; } void show_data() { Page 143

Unix, C & C++

cout<< Name :<<name<<endl; cout<< Age :<<age; } }; //end of class definition void main() { emp_info z; //object z of the base class emp_info fstream f; z.input_data(); f.open (emp.txt,ios::out); f.write ((char*) &z, sizeof(z)); f.close(); } // end of program Output: Enter the name: Ashish Enter the age: 20 Note: This information will be written into a file called emp.doc The program reads the already stored information from the file emp.doc. The information from the file is first read from the file and then the show_data() function is called to print the name and age of the employee. Care should be taken that information has to be printed on the monitor only after accepting the value for the instance variables from the file. Note that the function input_data() is never called in this case. a. read()

The read() member function is used to get data for a stream of objects from a specified file. The following program segment depicts how to read objects belonging to a class using the read() function. //reading an object from a file #include <fstream.h> class emp_info { private: char name[30]; int age; public: void input_data() { cout<< "Enter the name"<<endl; cin>>name; Page 144

Unix, C & C++

cout<< "Enter the age"<<endl; cin>>age; } void show_data() { cout<< "Name :"<<name<<endl; cout<< "Age :"<<age; } }; //end of class definition void main() { emp_info z; //object z of the base class emp_info fstream f; f.open ("emp.txt",ios::in); f.read ((char*) &z, sizeof(z)); z.show_data(); f.close(); } // end of program Output: Name: Ashish Age : 20 The program writes the object of class emp_info into a file called emp.doc. The class emp_info has two functions input_data() and show_data(). The input_data() function is first called to accept the name and age of the employee. Once these information are got they are written down into the file emp.doc. Care should be taken that information has to be written into the file only after accepting the value for the instance variables. 5.2.5.2 Random Access File

The knowledge of the logical location at which the current read or write operation occurs is of great importance in achieving faster access to information stored in a file. Thus a file in which any record can be accessed at random is called a Random Access file. C++ I/O system supports four functions for setting a file pointer to any desired position inside the file or gets the current file pointer. These functions allow the programmer to have control over the position at which the read or write operations take place. The seekp() and tellp() are member functions of class ofstream. The seekg() and tellg() are member functions of class ifstream. All these four are available in fstream. These functions can be used in manipulating the position of the stream pointers that point to the reading or writing locations within a stream.

Page 145

Unix, C & C++

tellg() and tellp() These two member functions accept no parameters and return an integer value representing the current position of get stream pointer (in case of tellg) or put stream pointer (in case of tellp). seekg() and seekp() This pair of functions serves respectively to change the position of stream pointers get and put. The syntax is as follows: seekg(offset, origin) seekp(offset,origin) Using this prototype, an offset from a concrete point determined by parameter direction can be specified. These functions move the associated files pointer to offset number of bytes from the specified origin, which must be one of the following three values: ios::beg beginning of file ios::cur current location ios::end end of the file The values of both stream pointers get and put are counted in different ways for text files than for binary files, since in text mode files, some modifications to the appearance of some special characters can occur. The following program uses the functions seekg() and tellg() to count the number of bytes. #include <iostream.h> #include <fstream.h> main () { long m; ifstream file (outfile.txt, ios::in); file.seekg (0, ios::end); m = file.tellg(); file.close(); cout << "size of " << outfile.txt; cout << " is " << (m) << " bytes.\n"; } Output: size of outfile.txt is 10 bytes. Imagine the file outfile.txt contains the following content Hi 12345 Initially the file is opened in read mode. The tellg() function returns the current position of the stream pointer which will obviously be the first position and hence will return 0. The statement Page 146

Unix, C & C++

file.seekg (0, ios::end); will move the pointer to the extreme end of the file and the tellg() function at that stage will return the current position of the pointer. This value will be a count of the actual number of characters stored in the file. The following program demonstrates the use of seekp() function in writing a set of characters at a specified location of the file. #include <fstream.h> void main() { char num[10]; fstream inout(new.txt, ios::out| ios::in); for (int i=0;i<10;i++) inout << i; inout.seekp(4); char var[5]; cout << Enter a string of 4 characters: ; cin >> var; inout <<var; inout.seekg(2); inout>>num; cout << num <<endl; } Output: Enter a string of 4 characters: good 23good89 The program creates a file called new.txt and writes into it all the numbers from 0 to 9 using a for loop. The statement, inout.seekp(4); positions the pointer at the 4th location (numbering of location starts from 0). The program then accepts a four letter string which is then written starting from that particular location. Hence the number 4567 gets replaced by good (the entered string). The file new.txt then contains the following content 0123good89 The program then starts reading the content of the file from location 2 which produces the output as: 23good89

Page 147

Unix, C & C++

Advantages of C++ stream classes The stream classes form a powerful set of classes. They can be modified, extended or expanded to incorporate user-defined data types or classes. They offer a rich set of error handling facilities. They are fully buffered, and thereby they reduce disk access.

They encapsulate their internal working from the user. The programmer need not specify the type of data to be input or output. It is determined automatically by the stream class. 5.2.6 Command line arguments

In C++ it is possible to accept command line arguments. To do so, one must first understand the full definition of int main (). It actually accepts two arguments, one is the number of command line arguments and the other is a listing of the command line arguments. It looks like this: int main(int argc, char* argv[]) The integer argc, is the Argument Count (hence argc). It is the number of arguments passed into the program from the command line, including the path and name of the program. The array of character pointers is the listing of all the arguments. argv[0] is entire path to the program including its name. After that, every element numbers less than argc are command line arguments. One can use each argv element just like a string or use argv as a two dimensional array. #include<iostream.h> void main(int argc,char* argv[]) { cout<<" Argc: " <<argc; for(int i=0;i<argc;i++) cout<<" Argv: " <<argv[i]; } Output :( when run in dos prompt) writefile 4 pop 45 67 Argc: 5 Argv: C:\BC5\BIN\WRITEFILE.EXE Argv: 4 Argv: pop Argv: 45 Argv: 67 Where writefile is the name of the file.

Page 148

Unix, C & C++

To read the command-line arguments the main() function must itself be given two arguments. The first argc represents the total number of command line arguments. The first command-line argument is always the pathname of the current program. The remaining command-line arguments are those typed by the user. 5.2.7 Basic UNIX Commands Unix defines a number of commands. Some of the basic commands are: date command It displays the current date and time of the UNIX operating system. Example $ date Thu Jun 19 15:29:19 IST 2002 who command This command tells which user is currently using the system. Example $ who student tty01 Aug 10 10:24 ls command ls is the program to list files in a directory.

Example
$ ls abc file xyz cd command This command is used to change from current directory to another directory.

Example
$ cd /bin

Page 149

Unix, C & C++

This command changes the current directory to /bin mkdir command This command is used for creating a new directory.

Example
$ mkdir Abc pwd command This command returns the present working directory of the user

Example
$ pwd /usr/student cp command This command is used for making a copy of a file

Example
$ cp s d This command copies the content in file s to a new file called d. The file s remains unchanged. mv command This command is used for renaming a file

Example
$ mv s d This command renames the file s to a new file called d. rm command This command is used for removing a file.

Example
$ rm s This command deletes the file s.

Page 150

Unix, C & C++

rmdir command This command is used for removing an empty directory.

Example
$ rmdir abc This command removes the directory abc. 5.2.8 Vi Editor

Information can be entered in file using cat command. One disadvantage in this is that if the content has to be modified, the entire file content has to be retyped. This disadvantage is overcome in the case of vi editor. vi stands for Visual. is an editor which has a command mode and a typing mode. To open a file using vi, the command vi is followed by the filename. To enter the text in it the mode has to be changed to insert command i. When ever the mode has to be changed, escape button has to be hit. One important aspect of vi is that it does not provide the original copy of the file when invoked. It provides a Editing Buffer. All changes are done to that copy in the buffer. The original file is replaced when the user quits vi. vi functions in three different modes. They are: Command Mode Insert Mode Ex escape Mode
vi

In the command mode, any key pressed by the user is assumed as commands of the editor. No text is displayed on the screen when any key is pressed. The insert mode helps to insert the text into the vi editor. This mode can be invoked by using any of the insert, open or append mode command. The ex escape mode is introduced to make the vi and the ex editors compatible. When any command is typed in this mode it is shown on the command line. The bottom line of the vi screen is called as the command line. Here messages are displayed and all commands entered in the ex escape mode are displayed. vi emits a beep sound if there is any error. The vi editor can be invoked by typing vi at the $ prompt. vi can be invoked with a filename. The syntax is $ vi filename Usage of General vi Commands The usage of general vi commands is as follows: a. Getting Started with vi

Page 151

Unix, C & C++

The editor can be invoked by typing vi at the $prompt. vi, when invoked without a file name, takes input from the standard input. It is always better to invoke vi along with a file name. The three most common ways of starting a vi session are: $ vi filename $ vi +n filename $ vi +/pattern filename The user can open file for editing, optionally at line n or at the first matching pattern. If no file is specified, vi opens with an empty buffer. Example $ vi new.txt $ vi +3 flowers The second line states that the new file flowers will be opened and places the cursor on the third line. Important keys to remember are as follows: Keys Enter Key Esc Key / ? : :s/X/Y/g :g/X/s//Y/g Description Executes commands in the ex escape mode and starts a new line in the insert mode. In the command mode it goes to the next line. Returns the vi editor to the command line Helps to search for a particular string within the file. The string along to search the / has to be entered on the status line Works the same way as / key Used when the user wants to specify a command in the ex escape mode Used when the user wants to replace every occurrence of the word or the character X with Y in the line where the cursor is positioned Used when the user wants to replace every occurrence of the word or the character X with Y in each line of the file

b. Movement of the Cursor All vi commands involve alphabets and the shift and control keys. Since vi is case sensitive, the user must make sure that the Caps lock is off. The cursor movements can be described as follows: Keys h or backspace l or space bar k or j or + Directions Left Right Up Down

Page 152

Unix, C & C++

However, before the user uses these commands, the user must check the command mode. c. vi. Keys w W e E b B ^ $ L G Some More Cursor Movements The users try to use more cursor movement commands in order to work faster in

Functions
Moves forward by a word. Assumes that punctuations are next words. Moves forward by a word and this identifies punctuations as a part of the word. Takes the cursor to the last character of the word. Takes the cursor to the last character of the word and ignores any punctuation. Moves backward by a word. Moves backward by a word and ignores any punctuation. Takes the cursor to the beginning of the line. Takes the cursor to the end of the line. Takes the cursor to the last line of the file. Works like the GOTO command. For e.g to go to the second line in the file the user can say 2G.

Some more examples of the above movements are: 2w (will move the cursor by two words) 4$ (end of the fourth line) 5b (move five words back) d. Screen Commands The table below lists few of the commands used to traverse the screen. Keys Ctrl + F

Functions

Moves forward by a screen. To have continuity the last two lines of the previous screen are displayed. Ctrl + B Moves backward by a screen. Here again two lines of the previous screen are displayed. Ctrl + D Moves the cursor half the screen forward. Ctrl + U Moves the cursor half the screen backward. Ctrl + L To clear any message that vi has displayed or to clear any system messages that appear on the screen. Ctrl + G Displays the status on the status line. Gives the name of the file that is edited, the number of lines in the file, the current line number and the percentage of file that precedes the cursor. e. Usage of some Editing

Page 153

Unix, C & C++

The various ways to insert, delete copy and move the text in the file are discussed in the following paragraphs. Text Insertion in vi In order to insert a text within the file, first the user must type in i to make sure that the user is in insert mode. The following commands perform the insertion function. Keys i/I o O a A g. f.

Functions
Invokes insertion mode. Text insertion is possible only after invoking the insert mode. The capital I invokes the insert mode and insertion takes place at the beginning Allows insertion by creating a blank line above the current line Allows insertion by creating a blank line below the current line Used for appending the text .Text is appended after the current position Used for appending the text. Text is appended at the end of the line.

Deleting text in vi

If the user wants to delete a character or a word or a line that the user typed, use the following delete commands. Keys dd ndd dw dW D x X nX

Functions
Deletes the line in which the cursor is positioned Deletes n Lines Deletes the word from the cursor position to the end of the word. It stops at any punctuation that appears in the word Deletes the word from the cursor position to the end of the word. It ignores any punctuations that appear with the word Deletes the line from the current cursor position to the end of the line Deletes current cursor position Deletes back one character Deletes previous n characters

h. The undo Command In case, the user deleted a word or a line by mistake and the user wants the same, then the undo command is used. To use the undo command, ensure to be in the command mode and then press u. i. Joining lines of Text

Suppose the user wants to join any two lines of the text, then the user can make use of the J command. To join any two lines, place the cursor at the end of the first line and then press the letter J.

Page 154

Unix, C & C++

j. Line numbering of Text

Shell scripts and C programs are written using the vi editor. The programs and coding may be very long. If the user wants to go to the fifth line of the Shell script or the C program, it is better to have the text numbered. vi offers the facility of numbering text. In order to utilize this facility, the user must ensure the command mode. Then press : to specify that the command is in the escape mode. As soon as the user presses colon, he is taken to the command line of the vi editor. Now type the command as given below: (Esc) : set number

Line numbers are then set and all the lines are arranged sequentially. If the user deletes a line, the line numbers are changed automatically. If the user does not want the numbering to be done, then the following command is given. (Esc) : set nonumber The users working mode can be identified by the set showmode command, which is executed like the set number command. (Esc) : set showmode k. Changing Text The following commands are used to change the text. Keys Cw Cc C P p Rx Rtext S Ns S u U l.

Functions
Change word Change Line Change text from current position to end of line Insert last deleted text after cursor Insert last deleted text before cursor Replace character with X Replace text beginning at cursor Substitute character Substitute n characters Substitute entire line Undo last changes Restore current line

Copy, Delete and Move the multiple lines

In order to make use of these facilities, the user must ensure the command mode. These multiple lines depend on three major commands. They are: Copy to the desired position Move to the desired position Page 155

Unix, C & C++

m. Delete desired number of line

Copy to the Desired Position The user can copy a single line or block of lines to the desired lines.

Example 1 Suppose the user wants to copy the second line in the file below the fifth line then, (Esc) : 2 co 5 Example 2 If the user wants to copy the first three lines below the seventh line, then do the following (Esc) : 1,3 co 7 n. Move to the Desired Position

The user can move the lines in a file to the desired position using the following commands. To move the third line of the file to the ninth line of the file, the command is as follows (Esc) : 3 mo 9 A range of lines can be moved to the desired position. Example If the user wants to move the fourth line and seventh line of a file to the end of the file, then (Esc) : 4 , 7 mo $ o. Delete desired number of lines

It is possible to delete multiple lines in a single command using the escape command. Example The user can delete the fifth line to the seventh line in a file, using the command (Esc) : 5,7 d

Page 156

Unix, C & C++

It is also possible to delete the specified lines from the current position or above the current position of the cursor using various notations like + and - respectively. These notations follow the . symbol which stands for the current cursor position. (Esc ): 5,7 d To delete the fourth line from the current cursor position, the command is: (Esc): +4 d If the user wants to delete the fifth line above the current position, then type (Esc) : -5 d p. Save and Exit Writing a file means saving the edited text and updating the files modification time. Keys Functions ZZ Quit vi, writing the file only if changes were made :x Same as ZZ :wq Write and quit file :w Write file :w file Save copy to file :w! Write file(overriding protection) :w! file Overwrite file with current buffer :w %.new Write current buffer named file as file.new :q Quit file :q! Quit file( discarding edits) Q Quit vi and invoke ex :vi Return to vi after Q commands :e file2 Edit file2 without leaving vi :n Edit next file :e ! Return to version of current file at time of last write :e# Edit alternate file % Current Filename # Alternate Filename Shell Programming

5.2.9

A shell is a program that acts as an interface between the kernel and the user. For example, when the user types in a program at the unix prompt, the shell searches the PATH for the occurrence of that program name, then the shell instructs the kernel to load the program, push the program parameters supplied at the command line onto the stack and finally make the instruction pointer point to the entry point of the program and then finally execute the program. Shell program is primarily used to automate routine systems administration duties. Shell Scripts

Page 157

Unix, C & C++

In DOS it is possible to group commands together in files, called batch files. This feature is available in Unix too and such files are called Shell Scripts. Executing a Shell Script By default, files created in Unix has no execute permission. So the file has to be granted executable permission and then execute the file. But without granting the permission the user can run the file using the sh command. Syntax for the sh command is: sh <filename> The sh command creates a new shell which takes the specified filename as a parameter and executes it. Upon the completion of the execution of the script, the shell dies and the user are returned to the login shell. Advanced Shell Programming Advanced shell programming makes use of loops apart from the preliminary commands. UNIX supports loops for executing a set of statements repeatedly and also selective control structures for selectively executing a set of statement. The if Construct This construct is used to do a set of commands based on a condition being true. If the condition is not true then another set of commands can be provided. The syntax of if statement is: if {condition} then commands else commands fi

Example
The example compares two strings, if the two strings are equal then the message The strings are equal are displayed else the message the strings are not equal is displayed.

Page 158

Unix, C & C++

echo "Enter 2 strings" read str1 read str2 if test $str1 = $str2 then echo "The strings are equal" else echo "The strings are not equal" fi Output: Enter 2 strings hello hello The strings are equal ifelif Unix also provides the if.elif construct for checking multiple conditions. The syntax for the if..elif statement is: if condition(s) then command(s) elif condition then command(s) else command(s) fi The if construct program is used to execute date and then display good morning, good afternoon or good evening.

Example
echo `date` hour=`date|cut -c12-13` echo $hour if [ $hour -gt 0 -a $hour -lt 12 ] then echo "Good Morning" elif [ $hour -gt 12 -a $hour -lt 14 ] then echo "Good Afternoon" else echo "Good Evening" fi Page 159

Unix, C & C++

Output: Tue Aug 13 17:08:43 IST 2002 17 Good Evening The case....esac construct This construct helps in execution of shell script based on the users choice. The syntax for case construct is: case value in choice1) commands;; choice2) commands;; esac In the above syntax choice1 and choice 2 are possible courses of action. The right parenthesis is used to identify the label names. If the value is taken as choice1 then the commands in choice1 is executed and so on.

Example
In this program, lower case alphabet is accepted as input and checked whether it is a vowel or not. echo "Enter a character" read a case $a in a) echo "It is a vowel";; e) echo "It is a vowel";; i) echo "It is a vowel";; o) echo "It is a vowel";; u) echo "It is a vowel";; *) echo "Not a vowel";; esac Output: $sh s38 Enter a character a It is a vowel $sh s38 Enter a character q Not a vowel The for Construct

Page 160

Unix, C & C++

This is used to perform same set of operations repeatedly on a list of values. The syntax for for statement is: for <variable> in value1 value2 value3 do commnd(s) done Any variable name can be assigned. The sequence of commands between do and done are executed for the list of values.

Example
The following program prints 5 stars 5 times. for i in 1 2 3 4 5 do echo "*****" done
Output:
***** ***** ***** ***** *****

The while Loop The statements within the while loop are executed repeatedly as long as the condition remains true The syntax for the while loop is: while control command do commandlist done Each time the shell attempts to execute the control command, if the exit status of control command is a Zero, that is, success, then the commands between do and done are executed.

Example
The following program is for printing the factorial of a number. echo "Enter a number" Page 161

Unix, C & C++

read n f=1 i=1 while test $i -le $n do f=`expr $f \* $i` i=`expr $i + 1` done echo " Factorial of $n is $f" Output: $sh s33 Enter a number 5 Factorial of 5 is 120 The until Loop The loop statement is similar to the while loop except that it continues as long as the control command fails. The syntax for until Loop is: until control command do command(s) done

Example
The following program prints numbers from 1 to 9. a=1 until [ $a -eq 10 ] do echo $a a=`expr $a + 1` done
Output:

1 2 3 4 5 6 7 Page 162

Unix, C & C++

8 9 The test command The if, while and until statement are often used in conjunction with the test command. This command can be used to test the values of variables. Some of the operators and options used with string tests are given as follows: s1=s2 True if string s1 and s2 are identical s1!=s2 True if the strings are not identical The exit Command The exit command is used to exit from the shell script ( to stop execution and return to the $ prompt) based on the result of a test command. The exit command can be used as follows: if test then else exit fi

Example
The following shell scripts checks if an argument string contains anything so that the script will stop executing if the argument string is empty. if test $# = 0 then echo Error no arguments entered exit fi The shift Command The maximum number for positional parameters can be $9. The user can use the argument $1 through $9 in the shell script at a time. Suppose if more than nine number of positional parameters, then the shift command is used. The shift command discards the first argument and renumbers the rest. The following example uses shift command to display a pyramid of the command line argument. Example The following program has to be executed with command line argument as 1 2 3 4 5. for n in 1 2 3 4 5 do Page 163

Unix, C & C++

i=1 while [ $i le $n ] do echo n $1 i=`expr $i + 1` done echo shift done Output: 1 22 333 4444 55555

5.3

Revision Points

Inheritance The technique of building new classes from the existing classes is called inheritance. Single Inheritance Derivation of a class from only one base class is called single inheritance. Multiple Inheritance Derivation of a class from several (two or more) base classes is called multiple inheritance. Pointers A pointer is an entity, which contains a memory address. this pointer Using this pointer, any member function can find out the address of the object of which it is a member. It can also be used to access the data in the object it points to. Dynamic Binding It is a process in which function calls are resolved at runtime. Static Binding It is a process in which the identifiers are associated with the physical address during the process of compilation and linkage. Virtual Function

Page 164

Unix, C & C++

A Virtual Function is a function, which does not exist but nevertheless appears real to some parts of the program

5.4

Intext Questions
1. What does inheritance mean in C++? 2. Describe the syntax of multiple inheritance. When is the inheritance used? 3. What is virtual Base class? 4. When the class is made virtual? 5. Explain any five basic UNIX commands. 6. Explain this pointer with an example. 7. Explain pure virtual function with an example. 8. Explain command line argument with an example. 9. Write a note on reading and writing text to a file 10. Write a note on stream class hierarchy

5.5

Summary
Inheritance is the mechanism that allows a class A to inherit properties of another class B. The class from which a new class inherits is called the Super Class and the newly created class is called Derived Class. A new class can inherit the members of a base class in public, protected or private modes. Single inheritance is the mechanism by which a class inherits the members of only one class. Multiple inheritance is the mechanism by which a class inherits the members of more than one class. Pointer is a variable that can hold the address of another variable. Operators used in Pointers are & and *. & means Address Of. * means Value at. A pointer can point to an object created by a class. The arrow operator (->)is used to access the member of that class. This is called pointer to objects.

Page 165

Unix, C & C++

this Pointer contains the address of the current object through which the function is being invoked. Dynamic Binding/Late Binding is a process in which function calls are resolved at runtime. Static Binding/Early Binding is a process in which the identifiers are associated with the physical address during the process of compilation and linkage. A Virtual Function is a function, which does not exist but nevertheless appears real to some parts of the program. A Virtual Functions is declared as virtual in base class with the keyword virtual and redefined in the derived class. An Abstract Class is a class which has at least one pure virtual function. An Abstract class cannot be instantiated. A Pure Virtual Function is a function declared in a base class that has no definition relative to the base class. The declaration of pure virtual function has an assignment-to-zero notation. A stream is a sequence of characters and is connected to a device or a file. To send/receive data to/from an external file the file must be connected to a stream. C++ supports both input and output with files through the following classes: ofstream: File class for writing operations (derived from ostream) ifstream: File class for reading operations (derived from istream) fstream: File class for both reading and writing operations (derived from iostream)

Object can be written into a file using the functions read() and write(). A random access file helps in accessing a particular record. Date command displays the current date and time. who command tells which user is currently using the system. ls is the program to list files in a directory. cd command is used to change from current directory to another directory. vi is an editor which has a command mode and a typing mode. A shell is a program that acts as an interface between the kernel and the user.

5.6

Terminal Exercises
Page 166

Unix, C & C++

1. Inheritance helps in making a general class into a more specific class? (True/False). 2. A base class is never used to create objects? (True/ False). 3. What is the open() command? 4. Write a note on shell programming. 5. Write a note on different loops supported by UNIX.

5.7

Supplementary Materials
1. Schildt, C++: The Complete Reference, Third Edition, TMH, 2000. 2. Sumitabha Dass, Unix Concepts and Applications, Second Edition, TMH, 1998 3. E.Balagurusamy, C++, Second Edition, TMH, 2001.

5.8

Assignment
1. Define class person (A person has a name, address, telno, email, DOB etc). Extend that class to define a classes called Official, Student; Staff each of them having specific properties. Implement virtual functions for getting details and calculating the performance. 2. Write a program that creates a file called Info.txt to write a string into it. 3. Write a program that reads the content of a file that has the following content. Reading the information from the file 4. Write a program that writes an object of a class into a file and reads the same. 5. Write a shell program to display an output as follows 1 12 123 1234 12345 6. Write a shell program to print the greater of two numbers.

5.9

Suggested Reading/Reference Books/Set Books

Page 167

Unix, C & C++

1. B.W.Kernighan, D.M.Ritchie, The Programming Language, PHI, 1988. 2. http://www.unix.org 3. http://www.unixworld.com/unixworld 4. http://www.yahoo.com/Computers_and_Internet/Operating_Systems/Unix 5. http://www.att.com/isc/lib/unix.html

5.10 Learning Activities

Collect Research reports and information on UNIX operating System from the internet.

5.11 Keywords
Inheritance Virtual function File Write () Date ls mkdir cp rmdir Pointer Abstract class read () Shell who cd pwd mv rm

Page 168