C++ Basics to Advanced

Conquering C++ This is the first part of C++ (basics of programming and OOP)

Contents - PART I Basic C++ 1.) Introduction • • •

a.) Evolution of Programming Languages

•

b.) Binary System & Memories c.) Terms used in programming

•

2.) Simple C++ Programming • • •

• •

6.) More Data Types

Your very first C++ program Compilers and how to run a program Data Types of variables o Integer o Floating Types o Double o Character o Boolean type o Data type range o Determining the range o More on Binary numbers Simple C++ programs Identifiers,Keywords and File Nomenclature,Constants,Comments

• •

• •

Workshop (for chapters 4, 5 and 6) • •

• • • • • •

Arithmetic operator, Escape Sequences Assignment operator, Type Conversion Arithmetic Assignment operators, Relational operators Logical Operators, Unary operator Sizeof operator, Ternary (conditional) operator Operator Precedence and Associativity, Comma Operator, Bitwise Operator

Workshop (for chapters 1, 2 and 3) • •

Test Yourself More questions (extra programs)

Test Yourself-II More Questions (extra programs)

7.) Pointers • •

3.) Operators

Scope of variables, Storage Classes (auto, static, extern, register) Type Qualifiers (const and volatile), Variable Initialization, Arrays Character Arrays Multi Dimensional Arrays, Initializing Multi Dimensional Arrays, Passing Arrays to functions Structures, Nesting of Structures Enumerated Data Types, Unions, Passing structures to functions

• • • • • • • • •

Address of operator, Declaration and use of pointer Arithmetic operation on pointers, Pointers and Arrays Pass by value, Pass by reference (C and C++ style) and reference variables More on references Returning pointers from functions Memory Allocation (new and delete) and Memory Heap Pointers to functions, Pointer Declarations Pointers to Structures, Pointer to Pointer (multiple indirection) Pointer to constants and constant pointers, Void pointers Pointers to characters, Pointers Demystified (2-D arrays and pointers) Passing multidimensional arrays to functions, Functions with varying arguments

4.) Controlling Program Flow •

•

•

Loops (Iterations) o For loop and its variations o While, Do-while loop Decision statement o If...elseif..., Nested If, Conditional Operator o Switch Case Loop Control Statements o Break, Continue, Goto, Return

•

• •

•

• • •

•

• •

5.) Functions •

8.) Classes and Objects

Declaration, call and definition, Parameters and arguments Default Arguments, Returning values from a function, Returning void, The int main( ) function An illustration of int main( ) Types of functions, Using Library functions (rand, srand and time), Function overloading, An example using functions Recursion (calling oneself!), Inline Functions

• •

•

•

Object Oriented Programming Concept and OOP Languages Class with example Constructors, Constructor with Parameters, Overloaded Constructors, Default Constructors and Arrays of Objects Scope Resolution Operator, Destructor, Objects and Functions (passing and returning objects), Initialializing an object using an object A Practical Use of Classes Data Encapsulation...Who are we hiding data from? More objects and classes, Private member functions (helper functions) Friend Function and Friend Classes, Static Class Members, Constant Objects (and the 'mutable' qualifier) Copy Constructor, this pointer, pointer to objects, objects in memory Initializer list, explicit keyword, declaration and definition, return value optimization

Workshop (for chapters 7 and 8) • •

Test Yourself-III More Questions (extra programs)

If you are done with the basics go on to

Advanced C++ (PART - II)

3

Programming Languages

The earlier first section was Binary numbers. Some people said that I ought to reduce the math in this tutorial and I felt that perhaps I should start off differently. And so I've altered the sequence of sections in this first unit.

Recap of important computer concepts: When we talk of computers, we refer to ‘hardware’ and ‘software’. All the physical components like monitor, keyboard, mouse, modem, printer etc. fall under the hardware category. We need computers to do something useful for us but computers aren’t smart enough to know what we want them to do (at least not yet!). We need to explicitly tell the computer our requirements in the form of instructions. A set of instructions for doing something useful forms a ‘program’. And we refer to these programs as software (i.e. unlike hardware, software is something that we can’t touch and feel). Major hardware parts in a computer: 1.

Input and Output devices: Computer can receive input from input devices (like a keyboard, mouse or a scanner). Output devices are used by the computer to send out information to the user; example: monitor, printer, plotter etc.

2.

Arithmetic and Logical Unit (ALU): As the name implies this unit is responsible for all arithmetic calculations. It is part of the central processing unit.

3.

Memory: When our computer wants to work on some information, it will require some place where it can store data; where it can store the instructions; where it can store intermediate results of operations etc. Memory serves this purpose and there are different types of memory (for different requirements): Primary memory: This memory can be quickly accessed by the computer (in technical jargon we say

that this memory has low access time; i.e. time taken to access data in primary memory is less). Generally, instructions and data needed by the computer immediately for processing are placed in primary memory. Data in primary memory is not permanent. Each time we restart the computer, the memory would get refreshed. Secondary memory/ storage: This is the place where we store all our data. It’s a long-term storage device (like a hard-disk). Access times are higher but secondary memory is cheaper than primary memory.

Introduction

4 4.

CPU (Central Processing Unit): We’ve seen computer parts to get input, store information, display output and also to perform

calculations. But there needs to be someone at a higher level to control the individual units; someone to decide when to capture the input, when to send output information to the monitor etc. The CPU takes up this responsibility and is termed the ‘brain’ of the computer. The CPU is also called the processor (a microprocessor chip).

The language computers understand: We have a lot of languages in this world but all computers can understand only binary language. The vocabulary is very simple and small; it consists of only 2 things: 0 and 1. This is all that a computer understands. (Humans are comfortable with the decimal system - consisting of the numbers 0 to 9). We’ll look at the binary system later in this chapter. Remember: A computer finally needs everything in binary language (instructions and data).

Programming Languages: Programs are written to tell the computer to do something useful for us. It might be as simple a task as adding two numbers or as complex as transferring data between 2 computers in a network. There are several reasons why we need programs. Imagine searching through a stack of papers to search for some telephone bill. Imagine a company maintaining its accounts (expenses and income on a day-to-day basis) - if this was done using the traditional file and paper method, someone would have to keep entering all the details in sheets of paper and then stack them into files. If, in future, someone wants to find out when a particular product was sold they would have to manually read through each

Introduction

5 and every paper in each and every file. Computers can be programmed to perform such tasks and they will do it faster. Basically, the computer is very good in performing repetitive tasks. One point to note: man created computers and man programs computers to perform certain tasks. A program is a set of instructions that can be executed by the computer. The computer will obediently follow whatever the programmer instructs it to do (as long as it understands the instructions). The downside to this is that the computer does not have any special intelligence; it is only as intelligent as it is programmed to be. For instance, a robot can be programmed to walk. If it is not programmed to detect obstacles, the robot will simply bang into obstacles because it does not have the intelligence to recognize and avoid obstacles. If the programmer provides such provisions, then the robot will be able to handle such scenarios. With many software programs already existing, you may wonder why do we need more software; why not just buy and use what already exists? Software is usually not custom designed for the requirements of a particular company and you may not even have software for your own special requirement. For example, dentists never used to have any software specifically for their use but now you can see a range of dental software (the dentist can maintain details of each of his patients’ tooth in the computer). Programs needn’t be as complicated as dental software; you may want to have a little software to calculate your CGPA or to calculate your rank in class. To perform such tasks a programmer has to write a program (or a set of instructions). These instructions are written in a specific programming language and the programmer can chose to write the instruction in any one of the available languages.

Evolution of Programming Languages: Any programming language can be categorized into one of the following categories: •

High Level

•

Middle Level

•

Low Level (machine and assembly languages)

Middle level languages are sometimes clubbed together under the category of high-level languages. Machine Level Languages: A computer has a processor and if we want the computer to do something then we need to direct instructions at the processor. The problem is that computers can understand only binary language (i.e. the language which comprises of only 1s and 0s). All instructions to the processor should be in binary and so a programmer can write programs using a series of 1s and 0s. Every

Introduction

6 processor will understand only some instructions (this depends on how the processor was designed). An instruction to increment a variable might be: 110110100011101 Imagine having 100 such instructions in a program! The advantage is that no conversion (or translation) is needed because the computer can understand the 1s and 0s. This is called machine level language and this was used at the time computers came into existence. The drawbacks are quite clear. By using machine language writing programs is very tedious and also prone to error (even if one bit is wrong, the entire program functionality could get altered). Trying to identify the error will also be a very tedious job (imagine reading a series of 1’s and 0’s trying to locate the mistake). Assembly Languages: Since it is very difficult for us to write instructions in binary language, assembly languages were developed. Instead of using a set of 1s and 0s for a particular instruction, the programmer could use some short abbreviations (called ‘mnemonics’) to write the program (for example: ADD is a mnemonic to add two numbers). Every processor has an instruction set that describes the various commands that the processor can understand. A normal instruction set will have instructions like JMP (jump), ADD (for addition) and so on. A programmer will write the program using these instructions and an assembler will convert the mnemonics into binary form so that the processor can understand it. The problem is that assembly level languages are specific to each processor. For example the 8085 (the simplest microprocessor) has an instruction set different from the 8086 microprocessor. Thus you would have to rewrite the program for each microprocessor. Another problem with assembly level programming is that the programmer needs to know details about the processor’s architecture such as the internal registers where values can be stored, how many internal registers are available for use etc. Low level languages are very close to the hardware but difficult for writing programs. High Level Languages: Writing larger programs in assembly language is quite difficult and hence, high-level languages were developed (like BASIC). These languages were not close to the actual computer hardware but were very close to the English language. They tried to simplify the process of programming. In these languages the programmer needn’t worry about internal registers and processor architecture; instructions could be typed in almost normal English. The English-like instructions had to be converted to machine language using a compiler. One simple example of an English like command in COBOL is:

Introduction

7 ADD incentive TO basic GIVING salary. The instruction is quite self-explanatory (Add ‘incentive’ and ‘basic’ and store the result in ‘salary’). COBOL is also a high-level language. As programs grew larger (for example: maintaining a record of all employees, accounts maintenance etc.), even high level languages had certain drawbacks. These languages are also referred to as unstructured form of programming. The reason they are unstructured is because when a large program is written, it becomes very difficult to analyze the program at a later date (by someone else or even by the original programmer himself). There are many reasons for this; one is the use of statements like GOTO in high-level languages. In any program some tasks will either be performed repetitively or the programmer might want the program to execute a different set of instructions if some condition is satisfied. For example in a division program, in case the denominator is 0 then the program should not divide the two numbers; instead it should display an error message. Only if the denominator is not 0 should the program divide the two numbers. This kind of programming is referred to as program flow control. In a larger program there could be various other possibilities and all this was dealt with by using the GOTO statement. If you’ve used BASIC you will be aware that for every instruction that you type, you have to specify a line number (example 10,20,30 and so on). GOTO will be followed by some line number (indicating the instruction that has to be executed next. Ex: 1020 GOTO 50 means that now you want the program flow to go to line number 50). The problem with this is that in a large program it will become very difficult for anyone to understand the program logic. Imagine reading through 100 lines and then finding one GOTO statement to the 200th line. Then on the 205th line there could be another GOTO statement directing you to the 150th line. This should make it clear as to what is meant by the term ‘unstructured’. This is a major problem with high level languages. Another fact is that high level languages are very far away from the actual hardware. Examples of high-level languages are BASIC, Fortran (Formula Translation), COBOL (Common Business Oriented Language) and LIST (List processing). Thus to take advantage of high level and low level languages, middle level languages like C and C++ were developed. They were easy to use and tried to retain the advantages of low level languages (i.e. being closer to the architecture).

Introduction

8

C and C++ Dennis Ritchie developed C and it was quite popular. An interesting feature in C is the use of functions. The programmer could write a function for checking whether a number is odd or even and store it in a separate file. In the program, whenever it is needed to check for even numbers, the programmer could simply call that function instead of rewriting the whole code. Usually a set of commonly used functions would be stored in a separate file and that file can be included in the current project by simply using the #include syntax. Thus the current program will be able to access all functions available in ‘filename’. Programs written in C were more structured compared to high level languages and another feature was the ability to create your own data types like structures. For instance if you want to create an address book program, you will need to store information like name and telephone number. The name is a string of characters while the telephone number is an integer number. Using structures you can combine both into one unit. Similarly there are many more advantages of using C. Though C seemed to be ideal, it was not effective when the programs became even more complex (or larger). One of the problems was the use of many functions (developed by various users) which led to a clash of variable names. Though C is much more efficient than BASIC, a new concept called Object Oriented Programming seemed better than C. OOP was the basis of C++ (which was initially called ‘C with classes’). C++ was developed by Bjarne Strastroup. In object oriented programming, the programmer can solve problems by breaking them down into real-life objects (it presented the programmer with an opportunity to mirror real life). What is an object? This topic is dealt with extensively in the chapter on ‘Objects and Classes’ but a brief introduction is provided here. Consider the category of cars. All cars have some common features (for example all cars have four wheels, an engine, some body colour, seats etc.). Are all cars the same? Of course not. A Fiat and a Ford aren’t the same but they are called as cars in general. In this example cars will form a class and Ford (or Fiat) will be an object.

Introduction

9 For those people who know C programming, it would be useful to know the differences between C and C++. Basically C++ includes everything present in C but the use of some C features is deprecated in C++. •

C does not have classes and objects (C does not support OOP)

•

Structures in C cannot have functions.

•

C does not have namespaces (namespaces are used to avoid name collisions).

•

The I/O functions are entirely different in C and C++ (ex: printf( ), scanf( ) etc. are part of the C language).

•

You cannot overload a function in C (i.e. you cannot have 2 functions with the same name in C).

•

Better dynamic memory management operators are available in C++.

•

C does not have reference variables (in C++ reference variables are used in functions).

•

In C constants are defined as macros (in C++ we can make use of ‘const’ to declare a constant).

•

Inline functions are not available in C.

Let’s recap the evolution of programming languages: initially programs were written in terms of 1s and 0s (machine language). The drawback was that the process was very tedious and highly error-prone. Assembly language was developed to write programs easily (short abbreviations were used instead of 1s and 0s). To make it even simpler for programmers, high level languages were developed (instructions were more similar to regular English). As the complexity of programs increased, these languages were found to be inadequate (because they were unstructured). C was developed but even that was not capable of dealing with complex or larger programs. This led to the development of C++. Note: Sometimes languages are divided into low level and high level only. In such a classification, C/C++ will come under high level languages.

Introduction

10 Why do you need to learn C++? There are many people who ask the question, "why should I learn C++? What use is it in my field?" It is a well-known fact that computers are used in all areas today. Programming is useful wherever computers are used because it provides you the flexibility of creating a program that suits your requirements. Even research work can be simulated on your computer if you have programming knowledge. Construction and programming may appear to be miles apart but even a civil engineer could use C++ programming. Consider the case of constructing a physical structure (like a pillar) in which the civil engineer has to decide on the diameter of the rods and the number of rods to be used. There are 2 variables in this case: 1. The number of rods needed (let’s denote it as ‘n’) and 2. The diameter of each rod (let’s call it as ‘d’) The civil engineer might have to make a decision like: "Is it cost-effective for me to have 10 rods of 5cm diameter or is it better to have 8 rods of 6cm diameter?" This is just one of the simple questions he may have in his mind. There are a few related questions: "What is the best combination of number of rods, their diameters and will that combination be able to handle the maximum stress?" Usually equations are developed for each of the factors involved. It would be much easier if the civil engineer could simply run a program and find out what is the best combination instead of manually trying out random values and arriving at a solution. This is where programming knowledge would benefit the engineer. Any person can write a good program if he has adequate knowledge about the domain (domain refers to the area for which the software is developed. In this case it is construction). Since the civil engineer has the best domain knowledge he would be able to write a program to suit his requirements if he knew programming. Programming is applicable to almost every field- banking (for maintaining all account details as well as the transactions), educational institutions (for maintaining a database of the students), supermarkets (used for billing), libraries (to locate and search for books), medicine, electrical engineering (programs have been developed for simulating circuits) etc.

Introduction

11

Binary Numbering System

The following 2 sections on binary numbering system and memory are optional but recommended. If you’ve taken a course in electronics you probably already know about this and can use the material provided here as a refresher. Having knowledge of the binary system and computer memory will help in understanding some features in programming.

The heart of the computer is the microprocessor, which is also referred to as the processor. The microprocessor is the main part of the computer’s CPU (central processing unit). A processor consists of millions of electronic switches; a switch can be either in ON or OFF state. Thus there are only two distinct states possible in these devices. In our realworld calculations we make use of the decimal system (which has 10 distinct states/numbers: 0 to 9). Counting up to ten is easy for humans but would be quite difficult for computers. It is easier to create a device capable of sensing 2 states than one capable of sensing 10 states (this also helps reduce on errors). Computers make use of the binary system (i.e. they store data in binary format and also perform calculations in binary format). The binary system (binary meaning two) has just two numbers: 1 and 0 (which correspond to the ON and OFF state respectively – this is analogous to a switch which can either be in ON state or in OFF state). When we have different systems (binary, decimal etc.), there ought to be a way of converting data from one system to the other. In the decimal system the number 247 stands for 7*100 + 4*101 + 2*102 (add it up and the result will be 247; i.e. in each place we can have one of the 10 digits and to find the actual place value we have to multiply the digit by the corresponding power of 10). For example: 247 = (2 x 102) + (4 x 101) + (7 x 100) = 200 + 40 + 7 1258 = (1 x 103) + (2 x 102) + (5 x 101) + (8 x 100) = 1000 + 200 + 50 + 8 Note: In C++ and most other computer languages, * is used as the multiplication operator. The same concept holds good for a binary number but since only two states are possible, they should be multiplied by powers of 2. Remember: A binary digit is called a bit.

Introduction

12 So, what is the value of 1101? Multiply each position by its corresponding power of 2 (but remember, you have to start from 20 and not from 21). The value for 1101 is 13 as illustrated in the figure below:

An alternate method to obtain the value is illustrated below (but the underlying concept is the same as above):

It is easy to obtain the values which are written above each bit (27=128, 26=64 and so on). Write these values on top and then write the binary number within the squares. To find the equivalent decimal value, add up the values above the square (if the number in the square is 1). If a number is denoted as 1101, then this stands for the lower (or last) four bits of the binary number (the upper bits are set to 0). Hence 1101 will come under the values 8, 4, 2 and 1. Now, wherever there is a 1, just add the value above it (8+4+1=13). Thus 13 is the decimal equivalent of 1101 (in binary format). To distinguish between decimal and binary we usually represent the system used (decimal or binary) by subscripting the base of the system (10 is the base for the decimal system while 2 is the base for the binary system). Hence (13)10 = (1101)2

Introduction

13 Hence (13)10 = (1101)2

Computers store information in the form of bits and 8 bits make a byte. But memory capacity is expressed as multiples of 210 bytes (which is equal to 1024 bytes). 1024 bytes is called a Kilobyte. You may wonder why it is 1024 and not 1000 bytes. The answer lies in the binary system. Keeping uniformity with the binary system, 210=1024 and not 1000 (the idea is to maintain conformity with the binary system). Beware: The bit in position 7 in fig 1.1 is actually the 8th bit of the number (the numbering of bit starts from 0 and not 1). The bit in the highest position is called as the most significant bit. In an 8 bit number, the 7th bit position is called the most significant bit (MSB) and the 0th bit is known as the least significant bit (or LSB). This is because the MSB in this case has a value of 128 (28) while the LSB has a value of just 1.

Introduction

14

Computer Memory We know that computers can operate only on bits (0s and 1s). Thus any data that has to be processed by the computer should be converted into 0s and 1s. Let us suppose that we want to create a text file containing a single word “Hello”. This file has to be stored physically in the computer’s memory so that we can read the file anytime in the future. For the time being forget about the file-storage part. Let’s just concentrate on how the word “hello” is stored in the computer’s memory. Computers can only store binary information; so how will the computer know which number corresponds to which alphabet? Obviously we cannot map a single bit to a character. So instead of bits we’ll consider a byte (8 bits). Now we can represent 256 characters. To perform map a character to a byte we’ll need to use some coding mechanism. For this purpose the ASCII (American Standard Code for Information Interchange) is used. In this coding system, every alphabet has an equivalent decimal value. When the computer uses ASCII, it cannot directly use the decimal value and it will convert this into an 8-bit binary number (in other words, into a byte) and store it in memory. The following table shows part of the ASCII code.

Character A B a b

Equivalent decimal value 65 66 97 98

Binary value 0100 0001 0100 0010 0110 0001 0110 0010

In this way each character is mapped to a numeric value. If we type the word hello, then it is converted into bytes (5 bytes- one for each character) based on the ASCII chart and is stored in memory. So ‘hello’ occupies 5 bytes or 40 bits in memory. Note: It is very important to know the binary system if you want to use the bitwise operators available in C++. The concept of memory is useful while learning pointers. A question arises, “where are the individual bits stored in memory?” Each individual bit is stored in an electronic device (the electronic device is technically called a flip-flop; which is something like a switch). A single flip-flop can store one bit. Consider the fig. below:

Introduction

15

As mentioned earlier we deal in terms of bytes rather than bits. The figure shows a 4-byte memory (which means it can hold 32 bits – each cell can store one bit). All information is stored in memory and the computer needs some method to access this data (i.e. there should be some way of distinguishing between the different memory locations). Memory addresses serve this purpose. Each bit can be individually accessed and has a unique memory address. To access the first byte, the computer will attempt to read the byte stored at memory address 1. If memories didn’t have addresses then the computer would not know from where it has to read data (or where it has to store data). An analogy to memory address is the postal address system used in real-life. A city will have a number of houses and each house has a unique address. Just imagine the situation if we didn’t have any postal address (we wouldn’t be able to locate any house in the city!). One difference is that a memory address can house only bits and nothing else. Memory address representations are not as simple as shown above. In the above case we’ve considered a memory that has capacity to store just 4 bytes. Memories usually contain kilobytes or gigabytes of space. As the amount of memory available increases, so does the size of the address (the address number might be in the range of millions). Thus instead of using the decimal system for addresses, the hexadecimal numbering system is used. Hexa means 16 and the distinct numbers in this system are 0 to 9 followed by A, B, C, D, E and F where A= 10 in decimal, B= 11 in decimal and F= 15 in decimal. Counting in hexadecimal system will be 0…9, A, B…F, 10,11,12,13…19,1A, 1B, 1C…and so on. It is quite clear that 10 in hexadecimal does not equal 10 in decimal. Instead, (0F)16 = (15)10, (10)16 = (16)10 and (11)16 = (17)10 Four bits form a ‘nibble’. Eight bits form a ‘byte’ and four bytes of memory are known as a ‘word’. There is some significance attached to a ‘word’ which we shall deal with later.

Introduction

16 Another term related to memory is ‘register’. A register consists of a set of flip-flops (flip-flops are electronic devices that can store one bit) for storing information. An 8-bit register can store 8 bits. Every processor has a set of internal registers (i.e. these registers are present within the processor and not in an external device like a hard disk). These registers (which are limited in number depending on the processor) are used by the processor for performing its calculations and computations. They usually contain the data which the processor is currently using. The size of the register (i.e. whether the registers will be 16-bit, 32-bit or 64-bit registers also depends on the processor). The common computers today use 32-bit registers (or 4-byte registers). The size of a register determines the ‘word-size’ of a computer. A computer is more comfortable (and prefers) working with data that is of the word-size (if the word-size is 4 bytes then the computer will be efficient in computations involving blocks of 4 byte data). You’ll understand this when we get into data types in the subsequent chapters. The different types of memory are: 1. Secondary storage (for example the hard disk, floppy disks, magnetic disks, CD-ROM) where one can store information for long periods of time (i.e. data is retained in memory irrespective of whether the system is running or not). 2. The RAM (random access memory) is used by the computer to store data needed by programs that are currently running. RAM is used for the main (primary) memory of the computer (all programs which are executed need to be present in the main memory). The RAM will lose whatever is stored in memory once the computer is switched off. 3.

ROM (read only memory): This contains instructions for booting up the system and performing other start-up operations. We cannot write to this memory.

4.

The internal registers within the processor- these are used by the computer for performing its internal operations. The compiler will decide what has to be stored in which register when it converts our high-level code into low-level language. As such we won’t be able to use these registers in our C++ code (unless we write assembly code).

Remember: Secondary storage (also called auxiliary memory) is not directly accessible by the CPU. But RAM is directly accessible (thus secondary memory is much slower than the primary memory). For a program to execute it needs to be present in the main memory. Which memory has lowest access time (or which memory can the CPU access quickly)? The internal registers can be accessed quickly and the secondary storage devices take much longer to access. Computers also make use of a cache-memory. Cache memory is a highspeed memory which stores recently accessed data (cache access is faster than main memory access).

Introduction

17

Related concept: In general cache means storing frequently accessed data temporarily in a place where it can be accessed quickly. Web browsers tend to cache web pages you visit frequently on the hard disk. Generally when we type in a website address, the browser needs to query the website and request for the page; which is a time consuming process. When the browser displays this webpage, it internally caches (stores a copy) this webpage on our hard disk also. The next time we time the same website address, the browser will directly read out from the hard disk rather than query the website (reading from hard disk is faster than accessing a web server). Remember: Computers store information using the binary system, addresses are represented in the hexadecimal system and in real-life we use the decimal system. A 3-bit number can be used to form 8 different combinations (including the 000 combination).

Introduction

Binary

Decimal Equivalent

000

0

001

1

010

2

011

3

100

4

101

5

110

6

111

7

18 If 3 bits are used then the maximum possible decimal number that can be represented is 7 (not 8 because the first number is 0). Similarly if an 8-bit number can be used to represent up to (2^8) different values (0 to 255 in the decimal system). A binary number can be either signed or unsigned. When a number is unsigned (we don’t bother about the sign), it means that the number is always positive. If a number is signed, then it could be positive or negative. +33 is a signed number (with a positive sign). In real life, we can use + or – to indicate whether a number is positive or negative but in computers only 1s and 0s can be used. Every decimal number has a binary equivalent. The binary equivalent for the decimal number 8 is 00001000. If this is a signed number then +8 would be written as 00001000 and –8 would be denoted by 10001000. Notice the difference between the two. The 7th bit (or the most significant bit) is set to 1 to indicate that the number is negative. Assume the number 127. For +127 you will write: 01111111 For –127 you will write: 11111111 For 255 you will write: ? Well, the value for 255 cannot be written using a signed 8-bit number (because the 7th bit is reserved for the sign). If the unsigned representation was used then 255 can be represented as 11111111 (in this case the MSB signifies a value and is not concerned about the sign of the number). What is the point to note here? By using a signed representation the maximum value that can be represented is reduced. An 8 bit unsigned binary number can be used to represent values from 0 to 255 (11111111 will mean 255). On the other hand, if the 8 bit binary number is a signed number then it can represent from –127 to +127 only (again a total of 255 values but the maximum value that can be represented is only 127). Beware: Signed representation in binary format will be explained in detail later. Computers store negative numbers in 2s complement rather than storing them directly as shown above. Remember: In signed numbers the MSB (in the binary representation) is used to indicate the sign of the number.

Introduction

19

Terms used in C++ •

Compiler : Before providing a technical explanation a compiler in layman’s language is a

program which will read through the C++ program code (code refers to the program written by the programmer) line by line. The compiler will read each and every character that has been typed in the program code. After reading the entire code, the compiler will convert the code into machine level format (i.e. 0s and 1s). The compiler is very dedicated and hard working since it will meticulously read each and every character. Technically speaking, the microprocessor in a computer can understand only binary numbers (only 0s and 1s). It is not possible for us to write programs in binary numbers. Compilers will convert the coding for a program into machine understandable form (i.e. it will convert the instructions we type into machine understandable form). The instructions we type (in something similar to English), is known as the source code. The compiler converts the source code into the object code (which the microprocessor understands and we cannot understand). There is a detailed discussion on this topic in the chapter “Advanced Topics”. If you are new to programming you might wonder as to where you should type your C++ program? First of all you should have a C++ compiler. There are many compilers available for free on the Net and they can be downloaded from the Net. After downloading the compiler, create a new C++ source file and type the C++ code in the compiler. Later on in this book, we shall see how to run a C++ program in the compiler. A few compilers available on the Net are : 1. 2. 3. 4.

Borland C++ compiler : www.borland.com/bcppbuilder/freecompiler/ Bloodshed Dev C++ compiler : www.bloodshed.net/devcpp.html DJGPP C++ compiler For Linux/Unix the GNU C++ compiler is available in standard installations of the operating system.

Introduction

20 Most compilers nowadays provide an Integrated Development Environment (IDE), i.e. they have an editor, a compiler, a linker and some extra tools (like a debugger). In schools and colleges the most commonly used compiler is Turbo C++. Most of the programs written in this book are compatible with Turbo C++. It is better to use Visual C++ because advanced features like namespaces and exception handling are not available in older versions of Turbo C++. All compilers will support the basic features of C++. If you are using Linux/Unix then you will be having the GNU C++ compiler in your Linux distribution CD (this compiler is freeware but it doesn’t have a graphical user interface- it can only be used from the command line; refer to the Appendix section).

•

Keywords :

Keyword is a word that the compiler already knows, i.e. when the compiler sees a keyword somewhere in the program it knows what to do automatically. For example, when the compiler encounters the keyword ‘int’, it knows that ‘int’ stands for an integer. Or if the compiler reads a ‘break’, then it knows that it should break out of the current loop.

•

Variable and Constant :

As the name suggests, a variable is something whose value can be changed throughout the program. It is not fixed. On the other hand, a constant is one whose value remains the same (constant) throughout the program.

•

Operators and Operands:

Operator is something that performs operation on a variable. For example + is an operator that performs the addition operation. The terms on which the operator operates are known as the operands. In the expression x+y x and y are known as the operands and + is the operator.

Introduction

21 •

Expression:

Expression performs an operation and consists of operators and operands (or variables). a>b This is an expression in which a and b are the operands. > is the operator.

•

Binary and Unary:

Binary means ‘two’ and ‘unary’ means one. A binary operator operates on two operands (or two values) whereas a unary operator operates on just one operand.

•

Definition and Declaration :

In C++ these two terms are used frequently. Declaration of a variable means telling the compiler that this variable is an integer, or this variable is a character. A declaration will inform the compiler about the type of a variable. Defining a variable means allocation of memory space by the compiler for that particular variable. In the case of variables, a single statement performs both declaration and definition. For example: the statement int x; declares and defines ‘x’ as an integer. Remember that declaration is just declaring the type of something (telling the compiler what data type it belongs to) but definition means allotting space to it. It may seem as if both are one and the same; in many cases they are but in a few places they are not (these cases will be dealt with later).

•

Initialization :

Initialization refers to the first (initial) assignment of a value to a variable. x = 50; This initializes the value of x to 50. Always remember that the value to the right of the equal sign will be assigned (or stored) to the value on the left of the equal sign. For example: a = b; This means that value of b is assigned to a.

Introduction

22 •

Parentheses, braces, angle and square brackets :

There are different type of brackets: • • • •

Parentheses are just the normal brackets ( ). Braces are { }. Angular brackets are < >. Square brackets are [ ].

All of these brackets are used in C++ but each one is used for different purposes.

•

Character:

Characters include alphabets, numbers and other special symbols as well (like *, /, - etc…). Usually one tends to think of characters as only alphabets; but remember a character could be anything (an alphabet, a number, a special symbol on your keyboard or even a blank white space is a character).

•

Syntax : Every language has its own ‘syntax’. By the term syntax we refer to the

structure of a language and use of correct language. English has its own set of rules while French has slightly different rules. The vocabularies of both the languages are also different. Programming is also another language (that’s it is called programming language). Just like any other language it has its own set of rules that must be complied with. This is known as the syntax. Only if the programmer adheres to the syntax will the compiler understand the instructions.

•

Errors: This is a very common term in programming languages. In fact it is very

common to hear someone say, "Syntax Error". Error means a mistake and syntax error means that there is a mistake in the syntax. The compiler reads the entire program before execution. While reading the program, if the compiler discovers that it can’t understand

Introduction

23 some instruction it will display an error message. Till the error is cleared, the program cannot be executed. The compiler will give a syntax error if the syntax has not been adhered to properly. Errors generated by the compiler are known as compile-time errors. There are other types of errors as well. The compiler is not intelligent to detect all types of errors. For instance if the programmer make a logical error, the compiler will never know it. Suppose a program is written for adding two numbers and in the coding, instead of the + operator, the – operator has been used. The compiler will not recognize any error during compilation and the program will execute (but the programmer will not get the desired output). This is a logical error and as a programmer you have to be very careful while coding. The compiler is not brilliant enough to know what is in the programmer’s mind!

•

Executable file and linkers:

Executing refers to the process of running a program. We’ve talked about object file, but can we execute object files directly? The compiler produces an object code but this object code generally depends on some other external files. For example: if you are using complex mathematical functions, you might make use of functions which have been defined by some other programmer. That programmer would have created a library which you can include in your source code (instead of creating those functions in your program). A library is a collection of object files. Thus your program will actually depend on the other object files for some of the complex mathematical functions which you’ve used. Someone now has to link up all these object files to produce an executable file. This work is done by the ‘linker’. Most modern compilers have a linker included in them. Linkers are discussed in detail later. Remember: Each C++ source code needs to be compiled separately to produce an object code (ten source codes mean that we’ll have ten object codes). Finally the linker has to combine these ten object codes to produce one single executable module. •

Debugging:

is the process of troubleshooting a program (of course it’s done when the program doesn’t work up to your expectation!). Debugging is the process of identifying bugs in the code. A bug is a programming term for an ‘error’.

Introduction

24

Some extra details: An interesting point (about Kilo, Mega etc.): You might have read that 1Kilobyte = 1024 bytes and perhaps you thought about it as well, “Shouldn’t 1Kilobyte = 1000 bytes?” Let’s start with our familiar decimal system. In the decimal system, 1 Kilo unit = 1000 units. For example: • • •

1 Kilometer = 1000 meters = 103 meters 1 Kilogram = 1000 grams = 103 meters 1 Megawatt = 1000 Kilowatts = 1000000 watts = 106 watts

This is fine as far as the decimal system is concerned. Here the base used is 10 and we express everything in powers of 10. Computers speak in binary language and the base used here is 2. Let’s extend the concept of ‘kilo’ to the binary system. Can we represent the value 1000 as a power of 2? Let’s try: Power 20 21 22 23 24 25 26 27 28 29 210

Value 0 2 4 8 16 32 64 128 256 512 1024

Oops! We’ve just exceeded 1000 in 210. In the binary system, the closest we come to 1000 is 1024. Thus 1 Kilobyte = 1024 bytes (but for rough calculations we assume it as 1000 bytes).

Introduction

25

Recap of the First Unit: ¤

Computers only understand binary language (1s and 0s).

¤

8 bits form a byte.

¤

The different types of storage are: internal CPU registers, RAM, ROM and secondary storage.

¤

RAM is used as main memory and data is present only as long as the computer is switched on.

¤

Main memory is directly accessible by the computer whereas secondary memory is not.

¤

During execution programs should be present in the main memory.

¤

Word-size of a machine depends on the size of the processor’s internal registers.

¤

Machine level language is written in 1s and 0s.

¤

Assembly level languages make use of mnemonics (mnemonics are abbreviated English words used to represent instructions).

¤

High level languages like BASIC are in simple English but they are far away from the real hardware of the system.

¤

C has the advantages of both high level and low level languages. But it doesn’t support Object Oriented Programming (OOP).

¤ ¤

¤

C++ is actually C with classes (i.e. it supports OOP). A compiler is required to convert the source code (i.e. the instructions we type in English) into the object code (i.e. the machine language which the computer understands). 1 kilobyte = 1024 bytes (and not 1000 bytes).

Introduction

Your very first C++ Program

26

All the example programs in this book have been tested in Turbo C++ compiler (the programs were also tested in Visual C++ 6.0). They should run on other C++ compilers as well. Let us start with a basic C++ program. This will give you an idea about the general structure of a C++ program. Let’s write a program in which the user can enter a character and the program will display the character that was typed: // My first C++ program # include int main( ) { char letter; cout << "Enter any letter" ; cin >>letter; cout << "The letter you entered is : " <
Explanation for the above program: z

// My first C++ program: The first line in the above program forms the ‘comments’. In C++, any line that is typed after the two slashes ( // ) is known as comments. The compiler does not read comments. Comments can be used anywhere in a program and you can write anything that you want in the comments. Comments are useful when a programmer (or someone else) reads the source code in the future. Proper comments will make it easier for anyone to understand the program logic. When you write a very long program, you will appreciate the use of comments.

z

# include , it will physically include the iostream header file in your source code (i.e. the entire file called iostream.h file will be pasted in your source code). This is one of the standard header files which you’ll use in almost all of your C++ programs.

z

int main( ) : Every C++ program has to have one ‘main’ function. Functions will be explained later. Data Types & Variables

Remember that the compiler will execute whatever comes within the ‘main’ function. Hence the instructions that have to be executed should be written within the ‘main’ function. Just as the name implies, ‘main’ is the main part of the C++ program and this is the entry point for a C++ program.

27

z

{ : Functions are defined within a block of code. Everything within the opening and closing braces is considered a block of code. ‘main’ is a function and hence we define this function within braces. This is as good as telling the compiler, “The ‘main’ function starts here”.

z

char letter; : ‘letter’ is the name of a variable. Instead of the name ‘letter’ we could also use any other name. ‘char’ defines ‘letter’ as a character variable. Therefore, the variable ‘letter’ will accept the value of only one character.

z

cout << "Enter any letter" ; : This is followed by the << operator (known as the insertion operator). Following this operator, anything typed within double quotes will be displayed on the screen. Remember that cout and << go together. ‘cout’ is known to the compiler already (since it is defined in the iostream header file which has been included). So when the compiler comes across cout<<, it knows what to do.

z

cin >>letter;: cin is the opposite of cout. cin>> is used to obtain the value for a variable from the user. (>> is known as the extraction operator). Input is usually obtained from the keyboard.

z

return 0; : This statement tells the compiler that the ‘main’ function returns zero to the operating system (return values will be discussed in the chapter on functions).

z

}: The closing brace is used to tell the compiler that ‘this is the end of the function’. In our case, it is the end of the ‘main’ function and this indicates the end of the program as well.

You might have noticed in the above program that every statement is terminated with a semi-colon (;). That is exactly the use of the semi-colon. It is used to tell the compiler that one instruction line is over. If you don’t put semi-colons in your program, you will get errors while compiling. A variable is used for temporary storage of some data in a program. In the above example, ‘letter’ was a variable. Every variable belongs to a particular type (referred to as data type). The different data types in C++ are discussed later. In the above program: char letter; declares ‘letter’ as a character variable (a character is one of the basic data types in C++). When the compiler encounters this statement, it will allocate some memory space for this variable (i.e. any value which is assigned to the variable ‘letter’ will be stored in this allocated memory location). When the required memory space has been allocated we say that the variable has been defined (in this case a single statement will declare and define the variable ‘letter’).

Some points to remember: When we want to display something on the screen we will code it as: cout<>variable-name; Data Types & Variables

Beware of the direction of the >> and << operators. In the statement cout<
28

information flows from the variable into ‘cout’ (which means it goes to the monitor display). When we say cin>>variable; information (the value of the variable) flows from ‘cin’ (which would be the keyboard) into the variable (i.e. the value is stored in the variable). Information will flow in the direction of the arrows (<< or >>). ‘cout’ is linked to the standard display device (i.e. the monitor) while ‘cin’ is linked to the standard input device (i.e. the keyboard). Hence, you can’t use cout>>variable; This will cause an error while compiling. ‘cout’ and ‘cin’ are already pre-defined and so you can use them directly in your programs. 'iostream.h’ is a header file that is used to perform basic input and output operation (or general I/O like using ‘cin’ and ‘cout’). Remember: C++ is a case-sensitive language, which means that the compiler will not consider ‘letter’, ‘LETTER’ and ‘Letter’ as the same. Data Types & Variables

How to run your first program in the29 compiler? Saving and compiling the program: There are many C++ compilers available in the market. Some of them are freeware (meaning that they are free to use) while others have to be paid for. Turbo C++ compiler might be the simplest to use (but it is not freeware). Simply choose "New File" and type out the program coding. Suppose you are using some other compiler, click on File and choose "New". Some compilers may have the option of creating a C++ source file while other compilers may require a new project to be created. Whatever the method you will ultimately come to the step of creating a C++ source file. After typing the code in the compiler, save the file by giving it some name. The "Save As" option will appear under the "File" menu. Give a name (for example: first). Now the file is saved as first.cpp. All C++ source files are saved in *.cpp format. Just like *.doc represents a Word document file, *.cpp denotes a C++ (C Plus Plus) source file. In the compiler program there will be an option called ‘Compile’ in the menu bar. Select the compile option and the compiler will do its work. It will compile the program (or in other words, it will read whatever has been typed) and in case there are any errors, the compiler will point out the line where the error was detected. Check whether the program has been typed exactly as given earlier. Even if a semi-colon is missing, it will lead to errors. If the compiler says no errors (or if the message "compiled successfully" appears), then you can go to the next stage: building the *.exe file. *.exe file extension stands for executable files. A *.cpp file cannot be run directly on the computer. This has to be converted into a *.exe file and to do so select the "Make or Build exe" option in the compiler. The file ‘first.exe’ will be created. Now the program can be executed from the DOS prompt by typing ‘first’. But instead of running the program every time from DOS, it will be convenient to run the program from the compiler itself and check the output. In the compiler there will be another option called "Run". Just click on this and the program will run from the compiler itself (you needn’t switch back and forth between DOS and the compiler screen). The figure should give you a rough idea as to how the executable file is created from the C++ source code.

Data Types & Variables

30

The source code is the program that you type. Source code is converted into object code by the compiler. The linker will link your object code with other object codes. This process of creating a C++ program is discussed in the last chapter.

Modification that might be needed in first.cpp (depending on your compiler): A little problem might be encountered while running your program from the compiler (this problem will exist in Turbo C++ compiler). While running the program from the DOS prompt, this problem will not occur. What’s the problem? When first.cpp is executed from the compiler the program will ask the user to enter a character. Once a character has been entered, the program will return to the compiler screen. You won't see your output! It might appear as if there is some problem with the program. What happens is that the program displays the character on the screen, immediately terminates the program and returns to the compiler screen. This happens so fast that you can’t see the output being displayed. Data Types & Variables

Modify your program as shown below (if you are using Turbo C++):

31

// Your first program modified: first.cpp # include # include int main( ) { char letter; cout<< "Enter any letter" ; cin>>letter; cout<< "The letter you entered is : " <
Another header file called conio.h has been added. The function getch( ) is used at the end of the program. getch ( ) is defined in the conio.h header file. getch( ) stands for ‘Get Character’. When getch ( ) is executed, the program will wait till the user types a character (any character). Only after a character is typed will the program move to the next instruction. In the above program, there is no statement other than return 0; after getch ( ). Hence program flow is as follows: The program asks the user to enter a letter. The user enters a letter. Then the program displays the typed letter on the screen. The program will not quit at this point since there is a statement getch ( ). It will wait till the user types another character. When the user presses a character the program will quit. Type the above program, save and run it from the compiler. Some compilers have named the function getch( ) as _getch( ). This function also requires the conio.h header. Remember: conio.h is not available with all compilers and getch( ) function is not a standard C++ function. Some compilers provide it but most do not. In other compilers if a similar problem is encountered while displaying the result try using getchar( ); instead of getch( ); getchar( ) function doesn’t require the conio.h header file. If the compiler does not recognize getchar( ), then instead of adding any of the in-built functions, just add another line as follows: cin>>letter; at the end of the program just before return 0; Data Types & Variables

The program flow will be the same as described earlier.

32

The latest compilers, like VC++ (Microsoft Visual C++ compiler) do not have any of the above problems even if the program is run from the compiler. VC++ will always ask the user to press a character to terminate the program. Another alternative is to use a function called ‘system’, which is defined, in the header file: stdlib.h. z

system("PAUSE");

can be used to pause the program (i.e. execution of the program will continue only when the user presses a key). z

system("CLS");

can be used to clear the display screen. To use these two functions you have to type #include header file in your source code.&The system( ) function actually executes a DOS command. (Try giving the commands Data Types Variables ‘cls’ and ‘pause’ in your DOS prompt).

Data Types

33

The following topics are covered in this section: z

Introduction

z

Integer

z

Floating Type

z

Double

z

Character

z

Boolean

z

Data Type Ranges and determining the ranges

z

More on Binary Numbers

Every piece of data has to belong to some basic category. Consider a simple example in real life: every number has to be of a particular type. The number 5 is a natural number (or it can be called as a whole number). 6.5 is a real number (it has a decimal point). Similarly, in programming we have what are called as data types. When a variable is declared, the programmer has to specify which data type it belongs to. Only then will the compiler know how many bytes it should allocate for that particular variable. Or in other words, each data type occupies a different memory size and if a variable is declared as belonging to one particular data type it cannot be assigned a different data type value. In simpler terms, suppose the variable ‘x’ is declared such that it can hold only whole numbers; then it cannot (and should not) be assigned some alphabet. There are two categories of data types: fundamental data types and user-defined data types. The second category of data types will be dealt with later. The fundamental (or built-in or primitive) data types are: z z z z z

Integer Floating Point Character Double Bool

The first three data types: integer, floating point and character are used frequently.

Integer (int): An integer can contain only digits (numbers) from 0 to 9. Examples of integers are: z z z z

0 10 345 6789

Data Types & Variables

z z

-23 -600

34

It includes positive and negative numbers but the numbers have to be whole numbers. It does accept the decimal point. Hence the following numbers are not integer data types: z z z

3.5 4.8 0.23

These numbers come under the second category (floating point type) and not under integers. If the program has to accept such values from the user do not declare the variable as an integer. If a variable is declared as an integer and the user enters a value of 2.3, the program will assign 2 as the value for that integer variable. Similarly, if the user enters 3.2, the program will assign 3 to the integer variable. Remember: Once a variable is declared as an integer, it will only store whole numbers (if the user types a value with the decimal point, the program will ignore everything that is typed after the decimal point). How to declare a variable as belonging to the type integer? The syntax is: int variable-name; Each data type occupies a certain amount of memory space. An integer will occupy 2 bytes of memory (which means 16 bits). From this it is possible to calculate the maximum and minimum values that an integer can store. 2^16 = 65536 (hence 65536 different combinations of 16 bits are possible). Divide this by 2 because integers (by default) range from negative to positive values. We have a 0 in between and so subtract one from this to get 32,767. Hence an integer can take values from –32,768 up to +32,767 (a total of 65536 different values). A natural question springs to mind, "What would happen if a value greater than 32,767 is entered?" Since this value cannot be accommodated within the allocated two bytes, the program will alter the value. It’s not exactly altering the value; it will basically change your value into something different. The user might enter 123456 as the integer value but the program will store it as –7623 or something like that. Whenever you use variables ensure that you have declared them as belonging to the correct data type. This restriction on maximum range might seem to be a problem. In C++ ‘qualifiers’ can be used to vary the range of fundamental data types. Qualifiers are only supplements to the basic data types and they cannot be used separately on their own. They work only with a basic (or fundamental) data type. The 4 qualifiers available in C++ are: 1. 2. 3. 4.

Short Long Signed Unsigned

Signed and unsigned integers were discussed in the first chapter. When an integer is specified as signed, then automatically the most significant bit of the number is used as a sign bit (to denote the sign of the number). Hence it can be used if the programmer needs positive and negative number values for the variable. By declaring a variable as an integer, by default you can specify both positive and negative values. By default an integer is a signed integer. In other words, int variable-name; is the same as signed int variable-name; In the second form, ‘signed’ is the qualifier and it is used to explicitly state that the variable is a signed integer. For an unsigned integer the syntax will be: unsigned int variable-name;

Data Types & Variables

An unsigned integer can hold a value up to 65,535 (a signed integer can hold only up to 32,767). Of course, in an unsigned integer you 35 cannot assign a negative value. The range is from 0 to 65,535. To go beyond 65,535 and make use of both positive and negative values as well, the qualifier long should be used. long int variable-name; Long integers occupy 4 bytes of memory (32 bits). Remember, long int actually means signed long int (you can give positive and negative values). If you specify unsigned long int variable-name; you can only assign positive values to the variable. Thus, two qualifiers can be used together with a basic data type. What about the ‘short’ qualifier? Short integer is the same as a signed integer. It occupies two bytes and has the same range of positive and negative values as the normal integer case. int x; is usually the same as short int x; Compilers (depending on the operating system) will assume ‘int’ as a ‘long int’ or a ‘short int’. VC++ (since it works in the Windows OS) will default to ‘long int’ if you specify a variable as type ‘int’ (i.e. it will allocate 4 bytes to an ‘int’ variable). Turbo C++ (which is a DOS based compiler) will default to ‘short int’ when you specify a variable as type ‘int’. Thus the statement: int var; will allocate ‘var’ 4 bytes if you are using VC++ but the same statement will allocate 2 bytes if you are using Turbo C++ compiler. Programmers sometimes prefer to explicitly state what type of integer they want to use by making use of the ‘short’ and ‘long’ qualifiers. ‘short int’ always occupies only 2 bytes (irrespective of whether the OS is Windows or DOS) while a ‘long int’ always occupies 4 bytes. Two qualifiers can be used together, but do not try using: short long int variable-name; This will cause a compile-time error. So be careful with what qualifiers you use. And remember that the default for int is equivalent to short signed integer.

Floating Types (float): Floating type data include integers as well as numbers with a decimal point. It can also have an exponent. Exponent means 10 to the power of some integer value (whole number). 20000 = 2 x 10^4 = 2e4 = 2E4. If you specify decimal numbers, floating point data type will store up to a precision of 6 digits after the decimal point. Suppose 0.1234567 is assigned to a floating-point variable, the actual value stored would be 0.123457 (it will round up to the sixth digit after the decimal place). Valid floating-point numbers are: z z z z

0.1276 1.23 1.0 10.2

Data Types & Variables

z

2e5 (this will be typed in your code as 2e5)

36

Do not use an exponent with a decimal point. For example: 2e2.2 is an invalid floating point because the exponent has to be an integer. Floating point numbers use 4 bytes of memory and has a much greater range than integers because of the use of exponents. They can have values up to 10^38 (in positive and negative direction). The same qualifiers used for an integer can be applied to floating point numbers as well. To declare a floating variable, the syntax is: float variable-name;

Double (double): This is similar to the floating-point data type but it has an even greater range extending up to 10308. The syntax to declare a variable of type double is: double variable-name; Beware: Visual C++ (VC++) usually uses its default as ‘double’ instead of ‘float’. Suppose we type: float x=31.54; you will get a warning message saying that a ‘double’ (i.e. 31.54) is being converted into a floating point. It is just to warn you that you are using a ‘float’ and not a ‘double’. (Even if there are warnings, there won’t be any problem in running your program).

Character (char): A character uses just one byte of memory. It can store any character present on the keyboard (includes alphabets and numbers). It can take numbers from 0 to 9 only. The following are valid characters: z z z z z z z

A B 3 a : ‘ /

If the number 13 is entered as the value for a character, the program will only store 1 (i.e it will store the first character that it encounters and will discard the rest). A character is stored in one byte (as a binary number). Thus whatever the user enters is converted into a binary number using some character set to perform this conversion. Mostly all computers make use of the ASCII (American Standard Code for Information Interchange). For example, according to the ASCII coding, the letter ‘A’ has a decimal value of 65 and the letter ‘a’ has a value of 97. There is another form of coding called the EBCDIC (Extended Binary Coded Decimal Information Code) which was developed by IBM and used in IBM computers. However, ASCII remains the most widely used code in all computers. The table at the end of the book gives a listing of the ASCII values and their equivalent characters. The syntax to declare a variable which can hold a character is: char variable-name;

Boolean Type (bool) Data Types & Variables

This data type will only accept two values: true or false. In C++, ‘true’ and ‘false’ are keywords. Actually a value of true corresponds 37 to 1 (or a non-zero value) and a value of false corresponds to 0.

#include int main( ) { bool check; check = true; cout<
//output will be 1 (since ‘check’ is true)

Remember: The size of data types given above is a general case. Data type sizes depend on the operating system. So it may vary from system to system.

Data Type Ranges Bytes Name

(Compiler dependent)

Description

Range (depends on number of bytes)

char

1

Character or 8 bit integer.

signed: -128 to 127 unsigned: 0 to 255

bool

1

Boolean type. It takes only two values.

true or false

short

2

16 bit integer.

long

4

int

2/4

float

4

double

8

32 bit integer. Integer. Length depends on the size of a ‘word’ used by the Operating system. In MSDOS a word is 2 bytes and so an integer is also 2 bytes. Floating point number. double precision floating point number.

signed: -32768 to 32767 unsigned: 0 to 65535 signed:-2147483648 to 2147483647

Depends on whether 2/4 bytes.

3.4e + / - 38 (7 digits) 1.7e + / - 308

Remember: ‘short int’ always occupies only 2 bytes (irrespective of whether the OS is Windows or DOS) while a ‘long int’ always occupies 4 bytes. Determining the range: You might be wondering why the ranges are from -128 to 127 or from -32768 to 32767? Why not from –128 to 128? We’ll take the case of signed characters to understand the range. A character occupies one byte (8 bits). In a signed character the MSB (i.e. the 7th bit is used to denote the sign; if the MSB is 1 then the number is negative else it is positive). The binary number: 0111 1111 represents +127 in decimal value (we’ve seen about conversion from binary to decimal numbers in the first chapter). The number 0000 0000 represents 0 in decimal. But what about 1000 0000? Since the MSB denotes a negative number, does this stand for –0? Since there is no point in having a –0 and a +0, computers will take 1000 0000 as –128. 0000 0000 is taken to be zero. Thus in the negative side we have a least value of –128 possible while in the positive side we can have a maximum of only +127.

Data Types & Variables

Another point to note is that negative numbers in computers are usually stored in 2’s complement format. For example: 1000 0001 38 actually stands for –1 but if this number is stored in 2’s complement format then it stands for –127. Similarly 1000 0010 would appear to be –2 but is actually –126. To understand 2’s complement you should know about 1’s complement. Let us say we have a signed binary number: 1000 0001. The 1’s complement of this number is 1111 1110 (i.e. to find the 1’s complement of a binary number just change the 1s to 0s and 0s to 1s but do not change the sign bit). To find the 2’s complement just add 1 to the 1’s complement. Hence the 2’s complement of 1000 0001 is 1111 1111 (or –127). In the same way the 2’s complement of 1111 1111 (-127) is 1000 0001 (or – 1). Thus the computer instead of storing 1111 1111 (for –127) will store the 2’s complement of the number (i.e. it will store 1000 0001). Remember: When converting a number to its 2’s complement leave it’s sign bit unchanged. And numbers are stored in 2’s complement format only if they are negative. Positive numbers are stored in the normal format.

More on Binary Numbers: Everything in the computer is stored in binary format. Even if we ask the computer to store an octal number or a hexadecimal number in a variable, it will still be stored in binary format (we’ll see this later) because computers only understand 0s and 1s. How does a computer perform calculations? Yes, it has to do it in binary format. Let’s take an example of binary addition: 0

1

1

0

1

0

1

0

(106)10

0

0

1

1

0

1

0

0

(52)10

----------------------------------------------------------------1

0

0

1

1

1

1

0

First of all, what 2 decimal numbers are we adding? Convert them to decimal and you’ll get: 106 and 52. When the computer has to add 106 and 52, it would in effect be adding the 2 binary numbers as shown above. Binary arithmetic is simple: 0+0=0 1+0=1 0+1=1 1 + 1 = 0 and a carry of 1

Use this and try out the addition of 106 and 52. Voila! You’ll get the answer of 158. Proceeding further, we need to investigate as to how negative numbers are really stored in computers. We discussed earlier that if +10 is represented as 0000 1010 then -10 would be represented as 1000 1010 (since the MSB is considered as the sign bit). Right? Let’s check it out. Data Types & Variables

39

If we add -10 to 10 then we should get the answer as zero. 0

0

0

0

1

0

1

0

1

0

0

0

1

0

1

0

----------------------------------------------------------------1

0

0

1

0

1

0

0

And the answer is? -20. So, where did we go wrong? One question you might have is why did we add the sign bit also? The computer isn’t smart enough (or rather it doesn’t have the circuitry) to separate the sign bit from the rest of the number. The 2 numbers that you want to add, are fed as input to an adder circuit which will blindly add up both the numbers and give the result. To overcome this problem, we can make use of 2s complement. For example: 1000 0001 actually stands for –1 but if this number is stored in 2’s complement format then it stands for –127. Similarly 1000 0010 would appear to be –2 but is actually –126. To understand 2’s complement you should know about 1’s complement. Let us say we have a signed binary number: 1

0

0

0

0

0

0

1

1

1

0

The 1’s complement of this number is 1

1

1

1

1

To find the 1’s complement of a binary number just change the 1s to 0s and 0s to 1s but do not change the sign bit. Next, to find the 2’s complement just add 1 to the 1’s complement. 1

1

1

1

1

1

1

0 1

----------------------------------------------------------------1

1

1

1

1

1

1

1

Hence the 2’s complement of 1000 0001 is 1111 1111 (or –127). In the same way the 2’s complement of 1111 1111 (-127) is 1000 0001 (or –1). Thus the computer instead of storing 1111 1111 (for –127) will store the 2’s complement of the number (i.e. it will store 1000 0001). Why? Let’s go back to our initial problem of adding +10 and -10. Now let’s assume that the computer stores -10 in 2’s complement format. The addition will now be: Data Types & Variables

0

0

0

0

1

0

1

0

(+10)

1

1

1

1

0

1

1

0

(-10)

40

----------------------------------------------------------------0

0

0

0

0

0

0

0

Voila! The answer is 0. But you may ask ‘what about the carry of 1?’. Well, since it is an extra bit, it overflows (which means it is lost and we needn’t worry about it). I’m not going to get into more details of 2’s complement since this should be sufficient for learning C++. To learn more on this subject, you can check out books on digital systems or computer system architecture. Note: When you perform binary addition, 1 + 1 is equal to 0 and a carry of 1 (because in the binary system we only have 2 states: 1 and 0; so we can’t have 1 + 1 = 2 in binary). Remember: When converting a number to its 2’s complement its sign bit is unchanged. Numbers are stored in 2’s complement format only if they are negative. Positive numbers are stored in the normal format. Data Types & Variables

Go back to the Contents Page

Copyright © 2004 Sethu Subramanian All rights reserved.

Simple C++ Program

41

A few simple programs are explained in this section to help you get a feel of C++. First, let’s write a program to calculate the area of a circle. The variables needed in this program are the radius of the circle (which can be obtained as input from the user) and the constant ‘pi’ (whose value can be provided in the code itself). // To Calculate the Area of a Circle # include int main( ) { float PI = 3.14; // variables can be initialized during declaration int rad; cout<< "Enter the radius" ; cin>>rad; cout<< "Area of the circle is "<< PI * rad * rad; return 0; } The preprocessor has only one directive and it will include the iostream.h header file into the source code. The compiler will start reading the code from the main ( ) function onwards. Remember: Whatever is typed within the main ( ) function will be executed. The main ( ) function is used as the entry point for a C++ program. PI is a variable name and is declared as a float quantity (because the value of PI has a decimal point). At the point of declaration, PI is initialized to a value of 3.14. This means that whenever PI is used in the program, the compiler will use 3.14 instead of PI. The line: cout<<"Enter the radius"; will cause Enter the radius to be displayed on the screen. This is because "Enter the radius" is typed within double quotes following ‘cout’ and the insertion operator. Anything between double quotes, along with cout<< will be displayed on the screen just as it appears within the double quote. The value entered by the user will be stored in the variable ‘rad’. Then the statement "Area of the circle is " will be displayed on the screen. The compiler will calculate the value of ‘PI * rad * rad’ and display it at the end (* is the multiplication operator in C++). The output for the above program is: Enter the radius 9 Data Types & Variables

Area of the circle is 254.14

42

Bold indicates that the user entered the value. In this case 9 was entered as the radius. Suppose we type cout<< "rad"; the output will be just the word rad The value of the variable ‘rad’ will not be displayed. Remember: When you want to display some variable’s value on the screen, DO NOT ENCLOSE IT IN DOUBLE QUOTES; just mention the name of the variable after the insertion operator.

Initializing variables: It is a good idea to initialize variables at the time of declaration. Even if you are unsure of the value you can still initialize it to 0. If you are wondering why, just consider the example below: #include int main( ) { int correct, choice; cout<<"\nEnter your guess of the lucky number: "; cin>>choice; if (choice= =correct) { cout<<"\nCongrags. You are correct!"; } else { cout<<"\nSorry. Wrong guess"; } cout<
The problem is that in the program we haven’t assigned a value to the variable ‘correct’ and neither have we 43 initialized it. Thus this variable has an unknown value (also called garbage value). There are 2 ways to initialize variables: int correct = 25; or int correct(25); The second form is called functional notation and we generally don’t use this to initialize in-built data types (like integers, characters, double etc.). This form is used to initialize user defined data types (which we’ll discuss in the chapter on Classes).

Another example program: //Can you guess what this program is for and how it works? #include int main( ) { char check; int i; cout<<"Enter the character that you want to convert to ASCII : "; cin>>check; i = check; cout<<"The ASCII value for "<
as an integer, the number will be displayed as it is (without going through the ASCII coding process).

44

Try it: Write a program that will do the reverse process (i.e. type a number and the program has to display the corresponding character). Data Types & Variables

45

Identifiers, File Nomenclature, Keywords, Constants, Comments The following topics are covered in this section: Identifiers File Nomenclature Keywords Constants Comments

Identifiers: Identifiers are very important in C++ and are used in all programs. What is an identifier? In the previous program ‘check’ was declared as a character variable. The identifier in this case is ‘check’. Basically identifiers are names that are given to variables, constants or functions. In the previous program there are two identifiers: ‘check’ and ‘i’. C++ permits the use of a huge variety of names for identifiers like: test Test int_test var1 var123 c_b_f _var Almost any name you can think of can be used as an identifier but there are some restrictions. An identifier should not start with a number. The first character of an identifier should be an alphabet or an underscore ( _ ). After the first character, numbers can be used in the identifier. Remember the following: Never start an identifier with anything other than a letter or an underscore. It is better to use a letter than starting with underscores. Do not use keywords as identifiers (ex: do not name an identifier as int). Uppercase and Lowercase identifiers are different (Check is different from check). Be careful when using characters that look similar to each other. For example ‘1’ (the number one) and ‘l’ (the lowercase alphabet L) look alike. Use names that are easy to understand (if you are storing the salary of a person, name the variable as ‘salary’ instead of declaring it as ‘x’. Do not use very long names. Do not name many variables with similar names (avoid using identifiers like: count, counter, counting etc.).

Data Types & Variables

46

Keywords: Keywords are reserved words in C++ programming. They should not be used as identifiers and all keywords should be in lower case. The 63 keywords are tabulated below. Asm

Auto

bool

break

case

Catch

char

Class

Const

const_cast

continue

default

Delete

do

Double

Dynamic_cast

else

enum

explicit

Export

extern

False

Float

For

friend

goto

If

inline

Int

Long

mutable

namespace

new

Operator

private

Protected

Public

register

reinterpret_cast

return

Short

signed

Sizeof

Static

static_cast

struct

switch

Template

this

Throw

True

Try

typedef

typeid

typename

union

Unsigned

Using

virtual

void

volatile

wchar_t

while

File Naming Convention: A few points regarding file nomenclature are: In MSDOS a filename cannot have more than 8 characters whereas in Windows there is no such restriction. Use meaningful names (depending on what the program performs). Avoid using underscores in the file names. Be careful when using characters that look similar to each other. For example ‘1’ (the number one) and ‘l’ (the lowercase alphabet L) look alike.

Data Types & Variables

47 File Type

Extension used

C++ source file

*.cpp

C++/C header file

*.h

C source file

*.c

Executable file

*.exe

Object Code

*.obj

Text file

*.txt

Word document

*.doc

Image/graphics file

*.jpg/ *.gif/ *.bmp

Constants: Constants are used in expressions and their values cannot be changed. They are used in the program code without using any variable name to refer to them. For example consider the statements: int x = 5; float y = 3.33; In this, 5 is an integer constant and 3.33 is a floating type constant. You cannot change 5 or 3.33 but you can assign these values to variables (the variables in the above code fragment are ‘x’ and ‘y’). Constants can be classified based on their data type as follows: Numeric type constants (includes integers, floating-point etc.) Character Constants String Constants Numeric Constants: Numeric constants consist of a series of digits. Integer constants can be written in different number systems: hexadecimal (base 16), octal (base 8) or in decimal (base 10). A decimal integer constant is any normal whole number (can consist of digits from 0 to 9):

Data Types & Variables

48 2,34, 100, 900, 1456 etc. An octal integer constant can contain digits from 0 to 7 only and it should start with a zero (so that the computer will know it is an octal number). For example: 023, 0567, 0214 etc. A hexadecimal integer constant should start with 0x or 0X and can consist of digits from 0 to 9 and A to F (uppercase and lowercase letters are allowed). For example: 0x10, 0x1FF etc. Floating point constants will have the decimal point in the number. Character and String Constants: Character constants are single characters enclosed within two single quotes (or between two apostrophes). For example: ‘a’ ‘b’ ‘x’ ‘1’ ‘A’ ‘*’ A single character enclosed within single quotes is a character constant. All character constants will have an integer value (determined from the ASCII table). A C++ statement: char ch = ‘B’; will assign the character constant ‘B’ to the character variable ch. String constants consist of a series of characters enclosed within double quotes. For example: "hello" "This is a string" "x" Even "x" is a string because it is enclosed in double quotes. "x" is different from ‘x’ (this is a character constant). The reason is because "x" actually consists of ‘x’ and ‘\0’ (the null character which will be

Data Types & Variables

49 explained later). Constants are also called as ‘literal’. You might come across the terms character literal, integer literal, string literal etc. Beware: The constants described in this section are different from variables using the ‘const’ keyword (this is discussed in Unit 6).

Comments: Comments are not meant for the compiler to read. They are meant to make the program easier to understand for humans who might read the coding later. It is a good practice to write comments (even for small programs). What should be written in the comments? First of all, a couple of lines about the aim of the program should be mentioned. You should also mention the name of the programmer and the date when the program has been modified. Comments should be updated every time you modify the code. As the program gets larger, it is advisable to write comments for the various functions that are used in the program. For instance, if a function is used to calculate the sum of numbers, then this could be mentioned in the comments. Basically you are permitted to write anything within comments because it will not affect the program. There are two methods used to denote comments: Single line commenting (//) Multiple line commenting (/*…..*/) For single line comments use double slashes (//) followed by the comments (but it should be on the same line as the double slash). Example: //this is a single line comment Multiple line commenting permits you to write line after line of comments. It will be as follows: /* Multiple line commenting… …this is also part of the comment… ……comment continued…… */ Everything in between /* and */ will be commented. By using multiple line commenting the programmer needn’t use double slashes for each and every line.

Recap:

Data Types & Variables

50 The file iostream.h provides the general basic input and output functions. ‘cout’ is used to display data on the screen while ‘cin’ is used to obtain inputs from the user. Every variable/function in C++ has to have a name. This name is called an identifier. Keywords are specially reserved words in C++. They cannot be used as identifiers. There are two data types in C++: fundamental and user-defined. Variables are named memory locations (their name is provided by the programmer) where values can be stored and changed frequently in the program. Constants are usually used to assign values to the variables. All data types have different sizes and are used for specific purposes. The type of a variable determines what it can store. Comments are written for easy understanding of the program (they are not processed by the compiler).

Data Types & Variables

51

C++ Operators - I The following topics are covered in this section: • •

Arithmetic Operators Escape Sequences

1. Arithmetic Operators These operators are used to perform basic mathematical operations like addition, subtraction, division and multiplication. Operator Symbol

Operation performed

+

Addition

-

Subtraction

*

Multiplication

/

Division

%

Modulo operator (Remainder after division)

The modulo operator is not used to calculate the percentage. It is used to find the remainder after integer division. For example: 6 % 4 = 2 (because dividing 6 by 4 produces a remainder of 2). The modulo operator can operate only on integers. Since the modulo operator is used to determine the remainder after division, it is also called the remainder operator. Arithmetic operators are binary operators since they need two quantities (or operands) to perform an operation.

Operators - I

52 #include int main( ) { int num1, num2; cout<<"Enter the two numbers : "; cin>>num1>>num2; cout<<"The product is : "<>num1>>num2; This is a method of obtaining multiple inputs using a single statement. The above statement is equivalent to writing: cin>>num1; cin>>num2; The two numbers, when entered by the user, can be separated by a space or by a new-line (i.e. the first number is typed and then after pressing the ‘enter’ key the second number is typed). When you run the program you would get the following on your screen: Enter the two numbers : 8 4 The product is : 32The sum is : 12The difference is : 4The quotient is : 2The remainder is : 0 Something is not right in this output; the results are correct but the display is on a single line. To display the output in an organized manner, the program should print each output on a new line. For this purpose of formatting the output C++ provides us with ‘escape sequence’.

Operators - I

53

Escape Sequences/ Backslash Character Constants If you remember, whatever you type within double quotes following cout<<, will be printed as it is on the screen. There is a problem in case you want to print a new line, or you want to use tabs (because whatever you type within double quotes will be displayed directly on the screen). To solve this problem, escape sequences were developed. Just as the name implies, these escape sequence characters are used to escape from the normal sequence of events. An escape sequence always begins with a backslash ( \ ). For a new line, the escape sequence is \n (n for new line). If you want to push the tab setting then \t should be used (t for tab). The modified program for doing simple arithmetic operations is as follows: #include int main( ) { int num1, num2; cout<<"Enter the two numbers : "; cin>>num1>>num2; cout<<"\n The product is : "<
There are a few other useful escape sequence characters as well: Operators - I

54 Escape Sequence

Meaning

\n

new line

\t

horizontal tab

\a

bell sound

\\

Backslash

\?

question mark (?)

\"

double quotation

\’

Apostrophe

\0

Null character (used in strings)

Though escape sequences consist of 2 characters they represent only a single character (for example: \? represents the question mark character). Escape sequences are character constants and are denoted as ‘\\’, ‘\?’, ‘\0’ etc. Beware: ‘\0’ is not equivalent to zero. ‘\0’ represents a null character (used in strings). Try it: Use the above escape sequences in a C++ program to see their effects. The \a escape sequence will literally make a sound of a bell. Remember: Escape sequences always start with a backslash ( \ ) and have to be followed by valid characters (like n, a, t etc…). If you happen to use some other character (like w), the compiler will display a warning message (the program will run and usually the compiler will ignore the character or display the character on screen). Coming back to the program with arithmetic operators; what would be the output if 5 and 2 are entered as the two numbers? What will the quotient and remainder be? The result will give a quotient of 2 and a remainder of 1. But isn’t 5/2 = 2.5? The answer to this lies in the declaration of the variables ‘num1’ and ‘num2’. Since these two variables are declared as integers, all the results of arithmetic operations will also be in the integer format. Suppose ‘num1’ and ‘num2’ are declared as floating point data type, then the result of division would be 2.5 instead of 2. In this case, what do you think will be the remainder? Will it be zero always? Remember: The modulo (%) operator can operate only on two integers and not on any other data type. If the remainder operator is used on floating point numbers, the compiler will produce an error message. The other arithmetic operators can be used on integers as well as floating-point numbers.

Operators - I

55

C++ Operators - II The following topics are covered in this section: • •

Assignment Operators Type Conversion

2. Assignment Operators The assignment operator assigns the value on its right-hand side to whatever is present on the left-hand side. The ‘equal to’ symbol ( = ) is the C++ assignment operator. For example, the statement x = 2; assigns the value on the right-hand side of the ‘equal to’ sign to the term on the left (i.e. the value 2 is assigned to the variable x). The term which appears on the left-hand side of the assignment operator (usually a variable) is called the ‘target’. You will always assign a value to some variable but not to a constant. 2 = x;

//Error

is a wrong statement because you cannot assign the value of x to 2 (2 is an integer constant and you cannot change its value). The value on the right side of the assignment operator can be an expression as shown below (or a function that returns a value): x = num1 + num2; y = 5*6; Compilers often use the terminology ‘lvalue’ (or Lvalue) and ‘rvalue’ especially in error messages. The ‘lvalue’ refers to the operand on the left-hand side of the assignment operator while the ‘rvalue’ refers to the operand on the right-hand side of the assignment operator. The lvalue can be a variable or a pointer but it should not be a constant. The rvalue can be a constant, variable, an expression or a function call. Beware: Lvalue can be used as rvalue (i.e. on the right-hand side of an assignment) but rvalue cannot be used as Lvalue.

Operators

56 C++ permits multiple assignments (i.e. more than one variable can be assigned a value using one statement). For example let x, y and z be integers, then x = y = z = 3; is an example of multiple assignment. The process of assignment will be from right to left; 3 is assigned to ‘z’ and the value of ‘z’ (which is now 3) is assigned to ‘y’ and y’s value is assigned to ‘z’. The above multiple assignment is equivalent to the following set of statements: z = 3; y = z; x = y; and all the three variables x,y and z are assigned the value of 3. Is this valid? x = y+1 = 3; This sort of a statement is not valid in C++. You cannot use arithmetic operators in between multiple assignments (the compiler will not know how to solve this statement).

Type Conversion Each data type has a different range because of the different sizes that they occupy. A character is allotted 1 byte while an integer might be allotted 2/4 bytes. What will happen if we assign an integer to a character or a double to an integer? Assigning a variable of one data type to a variable of another data type is known as type conversion. When assigning between numeric types, whatever is on the right hand side of the assignment will be assigned to the variable on the left. If a variable of a smaller type is assigned to a variable of a larger type, no information will be lost on conversion (because a smaller type can be accommodated into a larger type). For example a character (which occupies only 1 byte) can be converted into an integer without any loss of information (because an integer occupies more bytes). However if you attempt to assign an integer to a character you will lose the higher order bits of the integer (only the lower 8 bits of the integer will be retained in the character). Let us assume that an integer occupies two bytes and a character occupies one byte. unsigned int a=510; unsigned char x; x=a;

Operators

57

As can be seen from the figure, the upper 8 bits are lost due to the type conversion and the value of the character will be only 254. The following program illustrates a few type conversions: #include int main( ) { char ch; double db; float f; short int i; db=55e4; ch = i = f = db; cout<
Operators

58

C++ Operators - III The following topics are covered in this section: • •

Assignment Arithmetic Operators Relational Operators

3. Assignment Arithmetic Operators/Shorthand Operator (+ =, - =, * =, / =) Assignment arithmetic operator is a combination of an arithmetic operator and the assignment operator. Consider the example: X + = 3; The above statement is the same as: X = X+3; i.e. the value of X is incremented (or increased) by 3 and the new incremented value is assigned to X. So if X had a value of 2 before this expression, then X will be 5 after this expression is executed. Operator

Operation performed

a+=b

a=a+b

a-=b

a=a–b

a*=b

a=a*b

a/=b

a=a/b

a%=b

a=a%b

Operators

59

4. Relational Operators ( < , > , = = , ! = , >= , <= ) Relational operators are also binary operators (since they operate on two operands). They are used for comparing two values and the result of the comparison is either true (value 1) or false (value 0). Some examples are given below: 5>4 will return a value of True (1) 2>3 will return a value of False (0) In programs that you write, comparisons will usually be made between one variable and a constant or between two variables. For example: x>y z>10 > means ‘greater than’ while >= stands for ‘greater than or equal to’. x>=y will yield a true value even if x = y whereas x>y will yield a value of false when x = y. Be clear as to what relation you want to test when using these operators. Suppose you want to test whether two variables are equal, you have to make use of the equality operator. The equality operator is denoted by = = (double equal to signs). Remember: Many beginners in programming use the equality operator and assignment operator interchangeably. The assignment operator is a single ‘equal to’ sign and it is meant only for assigning values to variables. The equality operator (a double ‘equal to’ sign) is used to check whether two values are equal. Relational Operator

Operation Performed

Result of Operation

x>y

Is x greater than y?

True/False

x
Is x less than y?

True/False

x>=y

Is x greater than or equal to y?

True/False

x<=y

Is x less than or equal to y?

True/False

x==y

Is x equal to y?

True/False

x!=y

Is x not equal to y?

True/False

Operators

60 We’ll write a simple program for comparing two numbers and displaying the appropriate result. #include int main( ) { float num1, num2; cout<<"Enter the two numbers : "; cin>>num1>>num2; if (num1>num2) { cout<<"The number "<
Operators

61 num1= = num2 within the ‘if’ condition, the following mistake is made: if (num1 = num2) // Logical Error { cout<<"The number "<
Operators

62 In the following program, we have coded to display the result of num>5. Do you think it is valid?

#include int main ( ) { int num; cout<< "Enter the number"; cin>>num; cout<<(num>5); //Legal? return 0; }

Always remember that the result of a comparison yields a value of TRUE (1) or FALSE (0). Hence the above program is perfectly correct. In case you enter a value that is greater than 5 you will get the output as 1 else you will get 0. 0 is considered as false and all other values are considered to be true.

Operators

63

C++ Operators - IV The following topics are covered in this section: • •

Logical Operators Unary Operators

5. Logical Operators - AND ( && ) OR ( || ) NOT (!) These operators are used to combine two or more expressions. The way in which they combine the expression differs depending on the operation used. They are used when we need to test multiple conditions. For example you may write a program that has to check whether the marks scored by a student is greater than 70 and less than 80. If it is so then you will want the program to display a ‘B’ grade. To check whether the average mark is greater than 70 you have to use one expression and to check whether the average is less than 80 you should use another expression. Thus in simple English your statement will be: If (average mark is greater than 70 AND average mark is less than 80) Print "B grade" AND: it combines two conditional expressions and evaluates to true only if both the conditions are true. First Condition

Second condition

Result of AND operation

False

False

False

False

True

False

True

False

False

True

True

True

If the first condition and the second condition are both true then the result of the AND operation will also be true. Example:

Operators

64 // To check whether the given number is even # include int main ( ) { int num; cout<< "Enter the number"; cin>>num; if ( (num!=0) && ((num%2)= =0) ) // Two conditions have to be true { cout<<"\n Even Number"; } return 0; } In this program we need to check for two conditions (the number entered should not be zero and the number when divided by 2 should not produce a remainder). Only if both these conditions are satisfied should the program display that the number is even. The AND operator is used to combine the two conditions that are to be tested and if both are true then the message is displayed. OR: operator combines two conditions and evaluates to true if any one of the conditions is fulfilled (i.e. only one of the conditions need to be true). It is designated by using two parallel bars/pipes ( | | ). First Condition

Second condition

Result of OR operation

False

False

False

False

True

True

True

False

True

True

True

True

The ‘AND’ and ‘OR’ operators can be used on a sequence of conditions (i.e. at a time you can check for multiple conditions). For example the following code is legal: if ( (x>y) && (y>5) && (z>y) && (x>4) ) { //body of the ‘if’ condition… }

Operators

65 In this case only if all the four conditions are true will the body of the ‘if condition’ be executed. NOT: NOT is a unary operator. Unlike ‘AND’ and ‘OR’, NOT operates only on one operand. The logical value of the operand is reversed. If the operand is true, then after the NOT operation it will be become false. You might be thinking that the NOT operator can operate only on 1 and 0. Actually, any number greater than 0 will be considered as a true value. Hence the following would give: • • •

!5 will give 0 !0 will produce 1 !1 is equal to 0. Condition

Result of NOT operation

False

True

True

False

Basically, any number other than zero is considered as true. ‘Not’ of any number (other than 0) will give you FALSE (or zero). Check out the following program that illustrates the NOT operator.

#include int main ( ) { int num, result; cout<< "Enter the number"; cin>>num; result = (!num); cout<
Operators

66

6. Unary Operators (NOT operator !, increment operator ++, decrement operator --) Unary operators operate on only one operand, which could be a constant or a variable. We’ve already discussed about the NOT operator. Another simple unary operator is the unary minus operator. This will act on only one operand and will change the sign of the number it operates on. For example: • •

-(5) = -5 -(-5) = +5

The ++ and – operator are very important if you are taking a course in C++ (teachers usually love this topic and they are bound to ask some questions on unary operators). ++ is known as the increment operator and it can be used in two ways. •

As a prefix : i.e. when the operator precedes the variable (as in ++ i, where i is the integer variable)

If we write: i1 = 10; i2 = ++ i1; This is the same as: i1 = 10; i1 = i1 + 1; i2 = i1; At the end of these steps the value of both i1 and i2 will be 11. When used as a prefix, the variable is first incremented and later assigned. •

As a suffix: i.e. when the variable precedes the operator (as in i ++).

If we write: i1 = 10; i2 = i1 ++ ; This is the same as writing: i1 = 10; i2 = i1; i1 = i1 + 1;

Operators

67 At the end of these steps the value of i2 will be 10 and that of i1 will be 11. When used as a postfix, the variable value is first assigned and later incremented. The decrement operator works in the same way. The only difference is that it decreases the value of the operand by one. Again the decrement operator also can be used in two ways: as a prefix or as a suffix (or postfix). Suppose we have the following coding in a program, what will be the value of ‘sum’ at the end of each statement? int sum=5; cout<
//‘sum’ is 5 // ‘sum’ is 5. Only in the next reference to ‘sum’ will //‘sum’ is now 6

Thus in the case of the postfix operator the value is assigned first and increment is carried out in the next step. If you make use of the prefix operator then: int sum=5; cout<<++sum; cout<<" "<
//‘sum’ is 5 // ‘sum’ is immediately 6 //‘sum’ is 6

Remember: When used as a prefix ( ++i ) compiler will first increment and then assign. When used as a suffix, assignment is done first and then incrementing is performed. Beware: The ++ and – operators cannot be used on expressions (i.e. ++ (y + 1); is an incorrect statement and will lead to a compiler error).

Operators

68

More on Operators (V) The following topics are covered in this section: • • • • • •

Sizeof Operator Conditional Operator Operator Precedence Associativity Comma Operators Bitwise Operators

SizeOf Operator (sizeof) This is again another unary operator. Just as the name implies, this operator returns the length (in bytes) of the variable that is mentioned in the parentheses. For example the size of a character is 1 (i.e. 1 byte). // Using sizeof operator #include int main ( ) { int a; cout<
Conditional Operator (?:) The conditional operator is a ternary operator (i.e. it operates on 3 operands at a time). We’ll take a closer look at it in the next chapter. For the time being just remember that it needs three operands and it is denoted by: ? :

Operators

69

Operator Precedence When a statement has more than one operator, the operator precedence determines as to which operator is given priority. For example if you have a * and a +, the compiler has to decide whether it will multiply and add or add and multiply. This will depend on the operator precedence. The parentheses have the highest precedence. For instance if you write: (5+3)*5 the result will be (8)*5 or 40. If you write the same without using parentheses as 5+3*5 the result will be 20 (because * has a greater priority than +). The order for operator precedence is listed below (starting from the highest priority): Parentheses ( ) Unary Operators ! Unary minus Multiplication * Division / Modulo % Addition + Subtraction Relational Operators < <= > >= Equality operator == Inequality operator != Logical Operator && || Conditional operator ?: Assignment = Arithmetic assignment *=, /= , %= , += , -=

Operators

70 Beware: It is better to write long expressions using parentheses otherwise it could lead to a lot of confusion and also to potential logical errors.

Associativity If two operators have a different priority level then their execution order depends on the operator precedence. What will happen if two operators have the same priority level? When 2 operators in an expression have the same priority, the expression is evaluated using their associativity. Consider the statement: net = basic + allowance – tax; Both + and – have the same priority level. Almost all of the operators except the assignment (and arithmetic assignment) operators have associativity from left to right. The assignment operator has associativity from right to left. Since the + and – binary operators have an associativity of left to right the expression for ‘net’ is the same as: net = (basic + allowance) – tax; When you perform multiple assignments: x = y = 0; the associativity of the assignment operator (=) is taken into account and thus the order of evaluation will be: y = 0 (which will give ‘y’ a value of 0) followed by x = y (which will assign 0 to ‘x’).

Operators

71

Comma Operator The comma operator can accept two expressions on either side of the comma. When executed, the left side expression is first evaluated followed by the right side expression. Ultimately it is the expression on the right side that will be the value of the entire expression. int x,y; cout<<(x = 1, y = 5);

// 5 will be displayed

First the ‘x’ will be assigned 1 and then ‘y’ is assigned a value of 5. The comma operator is equivalent to saying "do this task and do this also". In this case the compiler will do: x = 1 and then y = 5 The rightmost expression is y=5 and hence the value of the entire expression (x=1,y=5) is 5. Be careful while assigning the value of a comma separated expression to a variable. The comma operator has lower operator precedence than the assignment operator. If we type: y = (x = 1 , x = 5 , x + 10); x will have a value of 5 while y will be 15. If we type: y = x = 1, x = 5 , x+10; the value of ‘y’ will be 1 and that of ‘x’ will be 5. This is because the compiler will perform the following operations: y = x = 1; x = 5; x + 10;

// y and x are set to 1 //x value is 5 //the value of the entire comma separated expression is 15

The comma operator will be used usually in ‘for’ loops.

Operators

72

Bitwise Operator: The bitwise operators available in C++ are tabulated below: Bitwise Operator Symbol

Function

&

AND individual bits

|

OR individual bits

^

EXOR individual bits

~

NOT of individual bits (or complement operator)

>>

Right-shift operator

<<

Left-shift operator

These operators will operate on individual bits of the operand (i.e. on the binary representation of data). These operators are dealt with in detail in Chapter 13. Remember: Do not confuse the && and & operators or the || and | operators (logical operators are entirely different from bitwise operators).

Recap • • • • • • • • • • •

Arithmetic operators are used to perform mathematical operations. The modulo/remainder operator is applicable only on integer operands. Escape sequences are character constants that are used to format the output displayed on the screen. = is the assignment operator and the Rvalue is assigned to the target (or the Lvalue). Information will not be lost when converting from a smaller data type to a larger data type. Shorthand operators are a combination of one of the arithmetic operators and the assignment operator. Relational operators are used to compare two values or expressions. They will return a value of true or false. Logical operators are used to combine two or more expressions. The operator precedence determines which operator has a higher priority. When 2 operators have the same priority the expression is evaluated based on their associativity. Bitwise operators are used to operate on individual bits.

Operators

73

The basics (chapters 1 to 3) 1.Q) What do you think is the output??? 2.Q) The following coding: int main( ) { int a=3,b; b=a++ + a++; cout<>x;cout<<"You entered:"<>x; cout<<"You entered:"<
Q.) What are tokens? What’s lexical analysis? What is the output of: int i=5,j=2; cout<
80 a, b, c are identifiers and +, = are the operators. A question arises, how does the compiler decide how long a token is? How does the compiler know when to consider one character for a token and when to consider more? To simplify this situation, the compiler tries to extract the largest possible chunk in a statement to form a token (in other words it’ll try to extract the largest token while scanning from left to right). In our statement: a=b+c; the compiler cannot consider a= as a single token (because it knows that = is the assignment operator). So it picks ‘a’ as a symbol and so on. This might not seem to be a significant point but it’ll help us tackle the second question: int i=5,j=2; cout<
81 Note: In the previous question the following was termed illegal: k = i+++++j; In this case, the compiler would break up the statement as: k = (i++)++ + j; Upto k = i++ everything is fine, but after that it can’t form a legal token and thus produces a compile time error. It will form: (i++)++ which is not valid. It is better to avoid coding statements like i---j even though they produce the desired result (such code is neither pleasing to the eye nor the mind!).

Q.) Deduce the output in both of the following cases: a.)

int x=5; if ( (x= =5) || (x=7) ) { cout<<"True"; } cout<
What do you think is the value of ‘x’? A.) Since ‘x’ is 5, the first condition is satisfied. When we use an OR operator, the program will not evaluate the second condition if the first is true. Thus the value of ‘x’ will be 5 and the output will be: True5 b.)

int x=5; if ( (x= =5) && (x=7) ) { cout<<"True"; } cout<
What do you think is the value of ‘x’? A.) Since ‘x’ is 5, the first condition is satisfied. When we use an AND operator, the program will evaluate the second condition if the first is true. In the second condition we have assigned a value of 7 to x. Thus the value of ‘x’ will become 7 and the program will output: True7

82 Q.) Will the following program (not having an iostream.h) compile and execute? Explain with reasons. int main( ) { return 0; } A.) iostream.h is needed when we use cin, cout, <<, >> and similar objects (which we use in most of our programs). Otherwise you can do without iostream.h and the above program will compile and execute successfully.

Interview/Viva/ Test questions (along with the logical questions solved earlier): 1. 2. 3. 4. 5. 6. 7.

What is the difference between a compiler and an interpreter? Why does 1Kb = 1024 bytes and not 1000? Distinguish between machine language, assembly language and middle level languages? How do the post increment and pre increment operator function? Are they the same? How many bits are present in a nibble, a byte and a word? Why do we need to give iostream.h? Is the statement: int x; a declaration or a definition?

Other Questions and Programs: Q.) What is an interpreter? Interpreters are programs which will interpret the source code line-by-line and execute them. Compilers, on the other hand, read through the entire source code and convert it into an object code (they do not execute the code). The UNIX/Linux shell is a command interpreter (it executes your instructions on a line-by-line basis). The DOS command.com is an interpreter. Interpreters do not produce object code (which means that each time you run a program in an interpreter, the interpreter will repeatedly check the syntax etc. before executing the code). There are some languages which are called interpreted languages (i.e. these languages are always interpreted). C/C++ is not an interpreted language. Q.) What is a linker and a loader? Generally when writing a program, you will make use of different libraries and other source files. On compiling each source file we obtain an object code. All the object codes need to be put together to form an executable (because one code might call a function written in another code and only the linker will be able to resolve this). This is the basic function of a linker.

83 A loader is generally a program which loads the program (the executable) into main memory. All our programs and applications reside on a secondary storage device (hard disk) but the processor requires programs to be present in the main memory (RAM)- access time for main memory is much lower than secondary storage (i.e the CPU can access main memory quicker than secondary memory). The loader takes the program from secondary and loads it into main memory. You will be clear about a linker when we discuss about multiple file programming.

Q.) Distinguish between machine language, assembly language and middle level languages? Q.) Why do we need compilers? Q.) What is the difference between a constant and a variable?

Q.) Write a C++ program to input the name and age of the user and then display a sentence on the screen along with these two data. Q.) Write a program to convert a given amount from US dollars into Indian Rupees (assume the conversion rate as USD 1 = Rs.45). Also display a statement. Q.) Write a program that will calculate the compound and simple interest on a principal amount for a given number of years (also obtain the rate of interest from the user). Q.) Write a program to help a shopkeeper calculate the percentage profit he makes when he sells an item (obtain the buying price and selling price as inputs from the shopkeeper). Q.) Write a program to solve quadratic equations of the form: ax2 + bx + c = 0 Obtain the values of a, b and c from the user and find out the values for x.

84

For Loops in Depth

The following topics are covered in this section: • • • • •

Introduction For Loop Statement More of For loops Body of For loops Nesting For loops

Statement and Expression A statement in C++ refers to a part of the code that is terminated in a semicolon. It is the smallest part of the program that can be executed. For example: sum = a + b; is a statement. A C++ program will consist of a set of statements. An expression is a grouping of variables, constants, function calls and operators (arithmetic, logical, relational) to return a value. In the above example, a + b is an expression. While dealing with control mechanisms you will come across blocks of instructions. A block of instruction refers to a set of statements grouped together within a block. The block is identified by using the curly braces ‘{‘ to start the block and ‘}’ to end of the block. Program flow and control: What is program flow? Whenever we write a program we have to decide on the sequence of operations that the program has to perform. Generally this is represented in the form of an algorithm. Writing algorithms for simple programs might seem trivial but when you write complex programs, the algorithm helps reduce programming errors. Let’s take a look at a simple algorithm to calculate the average weight of 3 persons: Step 1: Start the program. Step 2: Obtain the weight of all 3 persons (in weight1, weight2, weight3). Step 3: Calculate the average weight as average = (weight1 + weight2 + weight3)/3 Step 4: Display the result

Program Control Flow

85 Step 5: Stop the program By looking at the algorithm a programmer can easily write the entire program. When you have a complex program, if you have written an algorithm then you can eliminate potential logical errors in this stage itself. In the algorithm we define the way in which the program control should flow. First the program should get the 3 inputs from the user, then it should calculate the value for average and finally it should display the result. Thus we can say that the program flow has been clearly defined. But program flow needn’t always be so simple. You might need to take some decisions and alter program flow. Control refers to that part of the program which is currently being executed. Let’s write an algorithm to divide 2 numbers obtained from the user. Step 1: Start the program. Step 2: Obtain the 2 numbers (num and den) from the user. Step 3: Check if den is zero. If it is then go to step 4 else go to step 5. Step 4: Display “Denominator is zero. Cannot perform division”. Go to step 7. Step 5: Calculate the quotient by dividing num by den. Step 6: Display the result. Step 7: Stop the program. In this example, there are 2 routes the program can take. If the user enters the denominator as 0 then the error should be produced else normal division should be performed. The pictorial representation of an algorithm is called a flowchart.

Loops Suppose you want to add the numbers from 1 to 10, what would you do? Of course you could write a long statement that would calculate 1+2+3+4+…+10. What if 10 were changed to 100 or 1000? Whenever there are statements to be repeated you can make use of loops (in fact you should make use of loops). When using loops, some condition should be specified so that the loop will terminate (otherwise the set of statements within the loop will keep executing infinitely).

Program Control Flow

86

For loop statement For loop is used for performing a fixed number of iterations (or repetitions). The syntax is: for (initialize-variables; condition-to-test ; assign-new-values-to-variables) { //statements to be repeated (or the body of the loop) } The ‘for’ loop has three expressions that have to specified. Initialize variables: This expression is executed only once (when the program flow enters the loop for the first time). It is usually used to assign the loop variable an initial value. Condition to test: involves relational operators. It is executed each time before the body of the loop is executed. Only if the condition is true will the loop body be executed. If it is false then the loop is terminated and the control passes to the statement following the ‘for’ loop body. Assign new value to variable: It is executed at the end of every loop after the loop body. Usually it is used for assigning a new value to the loop variable. Example: // To find square of numbers from 1 to 10 #include int main( ) { int var; for (var = 1 ; var<=10; var++) { //beginning of ‘for block’ cout<< "Square of "<
In this program, ‘var’ is the loop variable. The loop variable controls the loop. We have initialized this variable to1. The condition that is to be tested before executing the loop each time is: Is ‘var’ less than or equal to 10 (i.e. var<=10)?

Program Control Flow

87 Thus each time var satisfies the above condition the loop body will be executed. ‘var’ is reinitialized with a value at the end of every loop using the expression: var++ (i.e. incrementing the value of var by 1 each time the body of the loop is executed). So, to put the program flow in sequence, it would be as follows: Initially ‘var’ is assigned a value of 1. The condition is tested. Since 1 is less than 10, the body of the loop is executed. In the body of the loop we display the square of var (in this case it is the square of 1). With this, the loop has completed one cycle. In programming terms this is called as ‘one iteration’. The variable ‘var’ is then assigned a new value depending on what is specified in the ‘for loop’. In this program we have written: var++ Thus ‘var’ is incremented by one. Now, the new ‘var’ value is 2. Again 2 is less than 10 and so the body is again executed with the ‘var’ value as 2. This will be the second iteration. This process is repeated until ‘var’ becomes 10. When ‘var’ is 10, the condition is again tested. Since 10 is equal to 10 the condition will return a true value (meaning that the condition is satisfied). The loop body is executed again. For the next iteration, ‘var’ is 11. But since 11 is greater than 10 the condition to test returns a false value and the loop body terminates. Program flow goes to the line after the ‘for loop’ body. In this case, it happens to be return 0 (which signals the end of the program). Beware: for (var = 1 ; var< =10; var++) //Will lead to an error { cout<< "Square of "<
Program Control Flow

88

More on ‘for’ Loops We've seen the usual ‘for loop’ but there are some interesting modifications to the ‘for loop’. The normal syntax for the ‘for loop’ is: for (initialize-variables; condition-to-test ; assign-new-values-to-variables) { //statements to be repeated (or the body of the loop) } Have you wondered what will happen if we don't specify one of the three parts of the ‘for loop’? #include int main( ) { int i = 2; for ( ; i<8 ; i++ ) loop variable! { cout<
// No initialization of

The ‘for loop’ does not have any initialization expression. Will it run? Yes it will because 'i' has been initialized outside the ‘for’ loop. This is perfectly valid and the output would be: 234567 But if you don't specify i = 2 and try to compile the program, the program would still run (but you won't know what value of ‘i’ has been assumed by the compiler). Thus the initialization expression can be left out in a ‘for’ loop if you have initialized the variable with a value before entering the ‘for loop’. Basically, it is not a must that we have to specify all the 3 parts in a ‘for’ loop. Check out the following program: #include int main( ) { int i; for ( i = 1; i != 2 ; i++ ) { cout<
Program Control Flow

89 What do you think the output will be? The output will be: 1 ‘i’ starts from 1, when it goes to the value 2 the condition i != 2 becomes false (because ‘i’ is now equal to 2). Whenever the condition becomes false the ‘for’ loop will immediately terminate. Suppose instead of for ( i = 1; i != 2 ; i++ ) we had coded as for ( i = 2; i != 2 ; i++ ) what will happen? Simple, the ‘for’ loop will be terminated instantaneously; in other words the program will not enter the ‘for’ loop even once because the condition becomes false in the first test itself. Another variation of the for loop is shown below: for ( ; ; ) { //body of loop will run infinitely without an end unless a break condition is used } This is called an infinite loop. If you're wondering why one would want an infinite loop; well, you can use it to create time delays or you could specify some condition within the loop to cause it to break out of the loop. Breaking out from a for loop (or an infinite for loop) can be accomplished by using a ‘break’ statement (this will be discussed later). So far we’ve seen ‘for loops’ using only one loop variable. But you can have ‘for loops’ with two loop variables as well. #include int main( ) { int x,y; for (x=1,y=1; x<10,y<5 ; x++,y++) { cout<<"\n"<
Program Control Flow

90 Here we’ve made use of two ‘for’ loop variables (x and y). Both are initialized to 1. There are two conditions specified: x<10, y<5 This actually means that x should be less than 10 and y should be less than 5. If both are satisfied then the loop body will be executed. If even one isn’t satisfied the loop will terminate. The output will be: 11 22 33 44 Remember: You have to make use of comma (,) to say that you want to initialize x to 1 and y to 1. It is a comma and not a semi-colon (many beginners use the comma and semi-colon interchangeably). Semi colon is used in the ‘for’ loop to separate each of the expressions (to separate the 3 parts of a ‘for’ statement: the initialize, test and re-initialize parts). You might wonder whether you could use more than two loop variables? The answer is yes. You can use more loop variables but usually you won’t need to use more than 2. Empty ‘for’ loops: If the ‘for’ loop has no body to execute then it is called an empty ‘for’ loop. For example: for (int j=0; j<100; j++); The ‘for’ loop has been terminated by the semi-colon. This ‘for’ loop has no body and it will simply keep incrementing the value of ‘j’ from 0 to 100. This can be used to produce any required delay (because the loop has to be repeated 100 times). Delays can be useful in I/O operations or even while displaying (if the output is appearing too fast).

Body of the ‘for’ loop The body of the ‘for’ loop is the statement that immediately follows the ‘for’ statement if the body of the loop hasn’t been enclosed within braces. For example: for ( j = 0; j<10; j++) cout<< "hi"; cout<< j ;

Program Control Flow

91 The compiler will only consider the statement: cout<< "hi"; as belonging to the ‘for’ loop body. Hence the above code fragment would print "hi" ten times and the value of ‘j’ will only be printed once. The above set of statements is equivalent to: for ( j = 0; j<10; j++) { cout<< "hi"; } cout<< j ; It is good programming practice to clearly specify the body of loops using braces (the same holds good for ‘while’ loops and ‘if’ statements).

Nesting ‘for’ Loops The term nesting is frequently used in programming languages. Nesting means one within the other. For example: when we say nesting of ‘for loops’ it means that there is one ‘for loop’ within the body of another ‘for loop’. for (…..;….;…..) { //body of 1st for loop (called the outer ‘for loop’) for (….; …..; …..) { //body of 2nd for loop (called the inner loop) } } You might wonder as to how the program executes in the case of two ‘for loops’. Let’s assume that the outer ‘for loop’ has a loop variable ‘j’ that takes values from 1 to 10 in increments of one. Let the second loop variable be ‘k’ assuming values from 1 to 20. Thus initially j=1, and the program will encounter the second ‘for loop’. Now k=1 and the body of the second (inner) loop is executed. Then k is incremented to 2 (while j is still at 1) and the inner loop is executed again. Next k=3 while j is still 1 and the inner loop is executed once more. When the ‘k’ value reaches 20, the inner loop terminates and only then will ‘j’ be incremented to 2. Again for a ‘j’ value of 2, the inner loop will be repeated 20 times (since k will take values from 1 to 20) and so on. How many iterations are performed totally? A total of 10 * 20 (=200) iterations are performed using these two ‘for loops’.

Program Control Flow

92

While Loop

The following topics are covered in this section: • •

While Loop Do...While Loop

While loop We saw that the ‘for’ loop has 3 parts in its syntax (initialization, testing and then re-initializing the loop variable). The ‘while’ loop has only one expression; the test condition. The ‘while’ loop keeps on repeating the loop body as long as the loop condition is true. The syntax is: while (test-condition) { // repeat the statements as long as condition is true } Before illustrating the ‘while’ loop using an example, you should know an important fact about relational operators and characters. You might recall that a character can hold a single character. We have seen comparison of numbers using relational operators but what about comparing characters? There are many instances when you will want to check whether the user entered a particular character. For example: you may want to check whether the user entered a y (for yes) or an n (for no). Depending on what was entered your program should continue on two different lines. If ‘letter’ is a character variable, we will obtain the input from the user using the statement: cin>>letter; If you want to check whether the user has entered a ‘y’ or an ‘n’ you can do the following: if (letter = = ‘y’) { //body of if statement ) You should not compare characters as shown below: if (letter = = y)

//WRONG

This method of comparing a character variable with a character constant is WRONG. It will yield an error. The character constant should always be enclosed in single quotes. Beware: Beginners often forget the single quotes while using character constants. Program Control Flow

93

//To find the square of a given number # include int main( ) { char reply; int num, square; cout<< "Do you want to find the square of a number(y/n)? "; cin>>reply; while (reply = = 'y') //No blank-space between the two equal signs. See note. { cout<<"\nEnter the number : "; cin>>num; square = num*num; cout<< "The square is : " <>reply; } return 0; } Note: A blank space has been left between the two ‘equal to’ symbols just to make it clear that there are two equal signs. Do not leave a space between the two = symbols when you write your program. At the start of the program, if the user types a ‘y’ the program will execute the loop body. At the end of the while loop, the program will prompt the user to enter the value for ‘reply’. If the user again types ‘y’, then the program will execute the while body a second time. Hence, at the end of each loop the program obtains the value for ‘reply’ and checks whether the test condition is true. As long as the test condition is true, the while loop is executed over and over again. The difference between the ‘while’ loop and the ‘for’ loop is that the ‘while’ loop does not have a fixed number of repetitions of the loop body. As long as condition is true it keeps executing the loop body. Usually the ‘while’ loop is used when the programmer is not sure about the number of iterations that need to be performed. The ‘for loop’ is used when the programmer knows how many iterations are to be performed. Of course, the use of both can be interchanged as well. In fact, a ‘for loop’ can be modeled into a ‘while loop’. The equivalent ‘while loop’ for a ‘for loop’ will be as below: Initialize a variable value; while (condition involving the variable) { //body of the loop //assign a new value to the loop variable; }

Program Control Flow

94 If we use the coding: while(1= = 1) { //body of loop } the while loop becomes an infinite loop (because 1 is always equal to 1).

Do…While loop The ‘do…while’ loop is a modification of the ‘while’ loop. If you noticed in the earlier program for the ‘while’ loop, initially we have to ask the user whether he/she wants to find the square of a number. Only if the user types a ‘y’ will the program enter into the ‘while’ loop. Hence in the program we have to ask the user twice whether he/she wants to square a number (once outside the loop and once inside the loop). The ‘do while’ loop, eliminates this repetition. When you make use of the ‘do-while’ loop, the body of the loop will be executed at least once. After the first iteration, if the loop condition holds true then the loop is repeated again. Thus the first iteration is compulsory in the ‘do…while’ loop. The program to find the square of a number can be re-written as follows: #include int main( ) { char reply; int num, square; do { cout<<"\nEnter the number : "; cin>>num; square = num*num; cout<< "The square is : " <>reply; }while (reply = = 'y'); return 0; } In this program, the body of the loop will be executed once for sure. After the first iteration, the user has the option of terminating the program or continuing to use the program for squaring another number. Beware: when using the ‘do…while’ loop, make sure that you put a semicolon at the end of the while statement: while (reply = = 'y');

Program Control Flow

95

Decision Statements (IF)

So far we have seen statements that help you in repeating a particular task as long as you desire. Another important form of program flow control is to be able to make a decision as to how you want the program to continue. Statements of this kind are referred to as decision statements (sometimes also called selection statements).

The following topics are covered in this section: • • •

If else Nested If Conditional Operator

If…Else If…else… ‘if-else’ is one of the decision statements available in C++. This enables the programmer to provide different paths for the program flow depending on certain conditions. For example: consider a program for dividing two numbers. Division by zero will lead to an error. To avoid this from happening, after obtaining the two numbers from the user the programmer will want to ensure that the denominator is not zero. Hence there needs to be two different program flow options. If the denominator is zero a message saying, "Division not possible" should be displayed. Otherwise the program should carry out the division and display the results. In simpler terms this can be stated as: If the denominator is zero, then display a message and do not divide else perform division and display the output. Syntax: if (condition) { //statements to be executed; } else { //statements to be executed; } The program flow is as follows: If the condition being tested within the ‘if’ statement is true, then the body of ‘if’ will be executed otherwise the body of ‘else’ will be executed. Thus the program takes a decision as to what it should do next.

Program Control Flow

96 You can also make use of the ‘if’ statement alone (‘else’ is not compulsory) or you can even make use of a series of ‘if...else’ statements as follows: if (condition1) { //body } else if (condition2) { //body } else { //body } Example: // To find the greater among two numbers #include int main( ) { int a, b; cout<< "Enter the two numbers you want to compare : "; cin>>a>>b; if (a = =b) { cout << "The two numbers are equal"; } else if (a>b) { cout <
Program Control Flow

97 the next ‘else if’ and ‘else’ statements because one condition has been satisfied. Program flow will then go to return 0; If the first ‘if’ condition is not satisfied, the program control will go to the following ‘else if’ statement: else if (a>b) Even if this is not satisfied then only will it go to the next statement, which is an ‘else’ statement. Since ‘a’ was not greater than ‘b’, and equality was also tested earlier the only possibility is that ‘b’ is greater than ‘a’. Thus if the first two conditions have failed then the program flow will go to the body of the ‘else’ block. Remember: Using the ‘if…else..if’ format, only one of the bodies will be executed (not all). If one condition is satisfied the rest of the ‘else..if…else’ is ignored. When we use the ‘if..else if’ construct, if one of the conditions is satisfied that corresponding body will be executed and the rest will be ignored. But what would happen if we use a series of ‘if’ statements alone? #include int main( ) { char letter; cout<<"\n Enter the alphabet 'a' or 'A': "; cin>>letter; if (letter= ='a') { cout<<"\n You entered an 'a'"; } if (letter= ='A') { cout<<"\n You entered an 'A'"; } return 0; } In the above program, the compiler will check for ‘a’ first and then it will check for ‘A’ also. Even if the first condition is satisfied, it will still check for the second ‘if’ condition. In such cases it would be better to use the following: if (letter= ='a') { cout<<"\n You entered an 'a'"; } else if (letter= ='A') { cout<<"\n You entered an 'A'"; }

Program Control Flow

98 Now if the user enters an ‘a’ then the program will not enter the ‘else if’ statement to check whether the letter is an ‘A’. Remember: It is better to make use of ‘if-else-if’ instead of a series of ‘if’ statements because in that way your program need not check all the conditions unnecessarily. And whenever you use a series of ‘if-else-if’ statements, test the condition that is most likely to be true first (so that the program need not waste time in checking more conditions).

Nested If You can have an ‘if’ statement within another ‘if’ statement. This is known as nested ‘if’. The program flow will enter into the inner ‘if’ condition only if the outer ‘if’ condition is satisfied. In general form nested ‘if’ will be of the form: if (condition1) { //code to be executed if condition1 is true if (condition2) { //code to be executed if condition2 is true } } There can be more than one ‘if’ condition (i.e. you can nest as many ‘if’ statements as you want). An example code fragment is given below (‘month’ and ‘year’ are integer variables whose values are obtained from the user): if (month= =2) { cout<< "The month is February"; if ( (year%4) = = 0) { cout<< "This month has 29 days."; } else { cout<< "This month has 28 days."; } } In the above code fragment, only if the variable ‘month’ is equal to 2 will the program enter into the ‘if’ block. Within this block it will print: The month is February

Program Control Flow

99 Then it will check as to whether the given year is a leap year or not. If it is a leap year then it will display that the month has 29 days else it will say the month has 28 days. Empty ‘if’ statement: We have seen the use of empty ‘for’ statements but empty ‘if’ statements might not be useful. In fact empty ‘if’ statements are usually logical error (because the programmer places the semi colon by mistake at the end of the ‘if’ statement). Example: if (num1
Conditional Operator (?:) The conditional operator is a ternary operator and this operator is an alternative to ‘if…else’ statements. The syntax is as follows: test-condition ? value1 : value2; The test condition will be evaluated and if it is true then ‘value1’ will be the value for the expression. If the condition is false then ‘value 2’ is the value for the entire expression. For example consider the coding: a=5; b=6; y = a>b?10:20;

Program Control Flow

100 The value of y will be 20 because ‘a’ is not greater than ‘b’. This sort of expression can be written using the ‘if’ statement as: a=5; b=6; if (a>=b) { y = 10; } else { y = 20; } Beware: It’s just that you could reduce the amount of coding by using the ternary operator. Be careful that you don’t confuse the logic while trying to reduce the length of the code!

Program Control Flow

101

Decision Statements (Switch Case)

There are many instances wherein you may want to test for a series of conditions one after the other. For example: Suppose you obtain the input of month from the user in as a number and you want to display the corresponding name of the month; what would you do? You could write a series of twelve ‘if….else if….else if…else if…’ statements. The ‘switch…case’ format provides a convenient alternative to using multiple ‘if-else’ statements when you are testing for a single variable alone. The switch statement successively tests the value of a variable against a list of integer or character constants. If a match is found then the statement associated to that particular case will be executed. First of all, before entering the switch case statement, we have to obtain the value of the switch variable from the user. The switch variable refers to the variable whose value you want to check. In the case of converting numbers into corresponding months, the switch variable will be the month number. Syntax: switch (variable/expression that evaluates to an integer) { case char/integer-constant : { //body } case char/integer-constant : { //body } }

Program Control Flow

102 For example: # include int main ( ) { int month; cout<< "Enter the month of the year: "; cin>>month; switch (month) // month is the switch variable { case 1 : // if month is 1 then the statements are executed { cout<<"The month is January"; break; } case 2 : { cout<<"The month is February"; break; } //write case statements for 3 to 10 just as shown above case 11 : { cout<<"The month is November"; break; } case 12 : { cout<<"The month is December"; break; } default : // If value of day is something other than 1 to 7 { cout<<"You entered an invalid number"; break; } } return 0; } As you can see, the compiler gets the value of the variable ‘month’ from the user. This is called the ‘switch variable.’ If the value of ‘month’ is 1, then the compiler performs what is specified under case 1. If the user enters 2, then the output will be February and so on. Since a year has only 12 months, if the user types 0 or 14 then the program should display that the user has typed the wrong number. The ‘default’ statement is used for this purpose. The ‘default’ statement

Program Control Flow

103 provides the program with an option to do something in case the switch variable does not match any of the case constants. In this program, ‘month’ is called the switch variable and the integer constants from 1 to 12 are called case constants (i.e. they are the values for which the switch variable is tested).

Break: It causes an exit from the switch construct (body). For instance, after printing that "The month is January" you don’t want the compiler to go into the other cases. Hence you ask it to break out of the ‘switch…case’ body. If there is no break for each case then the program will perform all the remaining cases as well. Try it: Remove all the break statements from the above program and execute your program. If you now type a value of 1, the program will print: The month is January The month is February …and so on… Beware: A mistake that beginners commit is that they tend to forget the ‘break’ statement. Always use ‘break’ after each case and also make sure that you have a ‘default’ option in your ‘switch…case’ body. The ‘default’ case is executed only if the user enters a value other than the case constants. It does not matter whether you place the default case at the starting of the switch-case body or at the end (but usually programmers prefer to place the default case at the end of the switch-case construct). Suppose you want to test the switch variable against a set of character constants then ensure that you enclose your case constants within single quotes. Suppose the switch variable ‘month’ is a character then the program would be: switch (month) { case 'a' : //‘a’ is within single quotes because it is a character constant { //body of the case break; } //the remaining cases } Beware: There can be an expression in the switch part but it should evaluate to an integer. The switch variable and the case constants should be integers (or characters). You should not use other data types.

Program Control Flow

104

Controlling flow within a loop statement We’ve seen a few ways of looping within a program. There are a few occasions when you might want to break out of a loop when some particular condition occurs. Or in other words you may not want to go through the all the iterations within a ‘for loop’. Or you may want to break out of the loop for just one particular value of the loop variable. C++ provides a mechanism to break from loops using the ‘break’ and ‘continue’ statements. These are also called as ‘jump statements’. The following topics are covered in

this section: • • • • • •

Break Continue Go To Return Apply what you've learnt Recap of the entire Unit

Break We’ve already seen the use of the ‘break’ statement in the ‘switch…case’ construct. A ‘break’ statement can also be used to terminate (or break out) from a loop (like the ‘for’ and ‘while’ loops). Suppose you are using nested loops, then a ‘break’ specified in the body of the inner loop will lead to breaking out from the inner loop alone. #include #include int main ( ) { int x, i; for (i = 0; i<15; i++) { x = rand( ); if (x>500) { cout<<"\n Iteration number "<
Program Control Flow

105 First of all, in the above program the library function rand( ) has been used. This function is defined in the header file stdlib.h. rand ( ) is used for generating random numbers. Can you find out what’s the logic of the above program? The ‘for’ loop is supposed to run 15 times. But within the ‘for’ loop we’ve specified a condition wherein if the random value generated exceeds 500 the program will break out of the ‘for’ loop. The output for the program will be: Iteration number 0 Random value is : 41 Iteration number 1 random value is : 18467 Exceeded 100 in iteration number 1 Breaking out from loop

Continue Sometimes you may not want to break out of a loop permanently. You may want to abort one particular iteration and then continue with the remaining iterations. For this purpose, the ‘continue’ statement is used. Let’s suppose that you have a ‘for’ loop with a loop variable named ‘j’ and you want the loop to run 10 times except for the value of j=5. In other words, you want the loop to run with all ‘j’ values except the value of 5. Hence, when the compiler enters the loop with the ‘j’ value of 5, the loop should terminate temporarily and then continue with the next ‘j’ value. Consider a simple example: int main ( ) { int j; for (j=1; j<8; j++) { if (j= =5) { continue; } cout<<"\n This is Round "<
Program Control Flow

106 This is Round 1 This is Round 2 This is Round 3 This is Round 4 This is Round 6 This is Round 7 Notice that "This is Round 5" is not displayed because that iteration was not performed. Remember: ‘Break’ is used to terminate permanently from a loop whereas ‘continue’ is used to terminate only a particular iteration.

Go To To use the ‘goto’ statement you should use ‘labels’. We’ll start with an example: #include int main ( ) { int i; i = 1; LOOP : if (i<10) { cout<
Program Control Flow

107 Check out the following code, which makes use of the goto statement: #include int main( ) { char ans; cout<<"Enter y/n : "; cin>>ans; if (ans=='n') { goto done; } int x=5; //ERROR done: cout<
Return The ‘return’ statement will be covered while discussing about functions. When using any looping technique within a function, the return statement can be used to break out from the loop and return control to the caller. We shall look at this later. For the time being just remember that the ‘return’ statement can be used to break out from a loop.

Program Control Flow

108

Apply the techniques Let’s write a program that covers most of the techniques that we’ve learnt. Problem: Write a program in C++ to obtain a date from the user. The user will enter the date in the format: dd/mm/yyyy. Our program should print the corresponding month and also the number of days in that particular month. The program should also inform the user as to whether the year is a leap year or not. For example if the user enters: 11 10 1980 then the display should be: October 11,1980.This month has 31 days. This is a leap year. Solution: 1. First obtain the inputs in three different variables (i.e. the day, month and year). 2. Write a ‘switch case’ statement to check for the month. 3. Within the case statements print the month and also set some other variable to the number of days present in that month. 4. Outside the ‘switch case’ block, print the date. 5. Using an ‘if’ condition check whether the year is divisible by 4 (which means it is a leap year). #include int main( ) { int d,m,y,days; cout<<"\nEnter the Date (DD MM YYYY): "; cin>>d>>m>>y; switch(m) //To print the month { case 1: cout<<"\nJanuary"; days=31; break; case 2: cout<<"\nFebruary"; break; case 3: cout<<"\nMarch"; days=31; break; //…write the remaining cases case 11: cout<<"\nNovember"; days=30; break; case 12:

Program Control Flow

109 cout<<"\nDecember"; days=31; break; default: cout<<"\nInvalid month"; return 0; //quit the program! break; } cout<<" "<
Program Control Flow

110

Recap • • • • • • • • •

A C++ statement is an executable line of coding and it is terminated in a semi-colon. For performing any repetitive task, looping techniques are used. The various looping options available are ‘for’, ‘while’ and ‘do-while’ loop. The ‘for’ loop is used when the number of iterations are known. The ‘do-while’ loop will execute the loop body once and only then will it check for the test condition. For taking decisions the programmer can use: ‘if-else’ statements, ‘switch-case’ statements. It is possible to break out from a loop using either the ‘break’ or ‘continue’ statements. The ‘goto’ statement is less frequently used in C++ programming. ‘break’ statement is used to terminate a loop while the ‘continue’ statement is used to terminate specific iterations. The loop statements as well as the decision statements can be nested.

Program Control Flow

111

Functions Intro

The following topics are covered in this section: • •

How to use functions Parameters and Arguments

What is a function? A function is a group of statements within a single unit. Basically, it is a block of executable statements grouped together which will be executed when the function is called. They are the building blocks of a program. You may wonder what’s the use of a function is? Or why not write the entire program within the main function itself? Suppose in your program you have to repeat a certain set of statements at different instances, it wouldn’t be a good idea to keep repeating the same statements throughout the entire program. It will be ideal to place these statements within a function and use a single statement to call the function wherever needed (this approach makes it simpler to understand the program logic). Functions provide means for breaking down a large program into smaller modules. Using functions will also help in debugging programs (identifying and correcting errors). The general syntax for a function declaration is: return-data-type function-name (parameters); The return data type specifies what sort of data the function will return to the calling process. For example if the return data type is ‘int’, then the function will return an integer value to the calling process. If the return data type is void, this means that the function does not return any value. What is a calling process? Every function has to be called by someone. A function will execute only when it is called. In C++, functions can be called by the main ( ) function or by some other function that you have defined. The main ( ) function is the part of your program that will execute and usually you will call the other functions from the main ( ) function. You may wonder, the main ( ) itself is a function, then who calls the main ( ) function? The main ( ) function is the main part of your program and it is called by the operating system (since your OS will run the program). There are three components for a function, namely: 1. Function Declaration or Prototyping 2. Function call and 3. Function definition.

Functions

112 Function Declaration (Prototyping): Declaration means informing the compiler that a function, with this name and which looks like this, will appear later on in the program. It is a statement that specifies the function name, parameter data types and return data type. Function declaration is always done before (and outside) the main ( ) function block. The syntax for declaring a function is: return-data-type function-name (data-type-of-parameters); Note that the function declaration should have a statement terminator. Function Definition: Once the compiler knows that you have declared a function, it then needs the definition for that function. The function definition contains the code to be executed whenever the function is called. The definition tells the compiler what it has to do when it encounters that function call. The first line of the function definition is the same as the declaration and is called the ‘declarator’ (it is also called the function header). Don’t confuse declaration with declarator. The function header is very similar, in appearance, to the function declaration (or prototype) except that it does not have the statement terminator. The function header must agree with the prototype (i.e. it must have the same function name and the same data types of parameters in the same order and the also the same return data-type). The general syntax of the three components of a function are as follows: // Function declaration return-data-type function-name (data type of parameter1,data type of parameter2) ; int main ( ) { function-name (arguments); //Function call within main( ) }

// Function definition (outside main( ) ) return-data-type function-name (arguments) // Declarator/ Header { // Function Code or Body of function } Parameters and arguments will be dealt with later in this chapter. Let us consider an example to illustrate the three basic components of a function.

Functions

113 // To add two numbers #include void add ( ); int main( ) { add( ); return 0; }

// Function Declaration

// Function Call

void add( ) { int num1,num2,sum; cout<< "Input the two numbers : "; cin>>num1; cin>>num2; sum = num1 + num2; cout<<"The sum is "<
// Function header // Body of the function

As you can see, we have first declared that there is a function named ‘add’ with the return data type as ‘void’ and with no parameters. When ‘void’ is used as the return data type it means that the function will not return anything to the caller. Remember: The compiler will always execute what you type in the main ( ) function. You can execute other functions by calling them from within the main ( ) function. We call the function add( ) from within the main ( ) function. When the compiler encounters the function call statement, it recollects that you had already declared a function by the same name and argument type. So it goes on reading your program assuming that you have defined the function later in the program. In the definition we have written a set of statements to find the sum of two numbers. The compiler will now know what to execute when it encounters the add ( ) function. After displaying the result (due to the presence of ‘cout’ in the ‘add’ function), the program flow will go back to the statement following the function call in the caller. In this case the caller is main ( ) and the next line is return 0;

Functions

114

There are some finer details that you should note. When a function calls another function, the caller does not terminate. Instead it waits for the called function to return back control. The caller sleeps till it receives control again. There is some overhead involved in this process because the program needs to store extra information to know exactly where to return to. The program also needs to keep track of variables used in the calling function because once control is returned back to the caller, these variables can be used. This might seem confusing but just remember that extra operations (overhead) is involved in calling functions. You’ll understand this better once you learn recursion. Coming back to our example, the function declaration will tell the compiler that a function by that name is coming up later on in the program. There is a way to avoid writing the function declaration; i.e. there is no need to declare the function. In the above program the function definition comes after the function call. If you do not want to declare the function, the function definition must come before (precede) the function call. Let us consider the same program to add two numbers using a function called add with no arguments. Example 2: // When function definition precedes function call #include void add( ) { int num1,num2,sum; cout<< "Input the two numbers : "; cin>>num1; cin>>num2; sum = num1 + num2; cout<<"The sum is "<
Functions

115 int main ( ) { add( ); return 0; } As you can see, in the above program there is only one small change. The function add ( ) hasn’t been declared because it has been defined before the function call. The compiler will initially itself read the function definition and hence it knows two things before entering the main ( ) function – it knows that a function with the name ‘add’ will come up later in the program and it also knows what to do when it encounters the add ( ) function (because we’ve already defined the function).

Parameters and Arguments Argument is a piece of data passed from the program to the function. Arguments allow a function to operate with different values. The variables used within the function to hold argument values are called parameters. The data type of parameters in the function declaration and data type of arguments in the function call should be the same. Consider the following program to explain arguments. Again consider the same program to add two given numbers but using function arguments. #include void add (int var1, int var2) // Parameters var1 and var2 { int var3; var3 = var1 + var2; cout<<"The sum of the two numbers is "<>num1; cin>>num2; add(num1,num2); //Arguments num1 and num2 return 0; } Two arguments have been passed to add ( ) from the main ( ) function. Observe the function ‘declarator/header’. The parameter specified is ‘int var1’ and ‘int var2’. This means that in the function named ‘add’, ‘var1’ and ‘var2’ are integers that are used within the body of the function. Within the function body we have declared a third integer called ‘var3’. var1 and var2 are added and stored in var3 using the statement :

Functions

116 var3=var1 + var2; Now the question might arise, what are the values for var1 and var2? In the main ( ) function the value for two integers ‘num1’ and ‘num2’ are obtained from the user. After obtaining the values, the following statement is encountered: add(num1,num2); This statement is the function call. Two arguments namely ‘num1’ and ‘num2’ are passed through this function call. Since the function was declared and defined as having two parameters (and since the data types of the parameters and the arguments are the same), the program will execute the code of the add ( ) function with the value of ‘var1’ being that of ‘num1’ and value of ‘var2’ being equal to ‘num2’. If the data types or number of arguments passed do not match with the parameters, the compiler will produce an error message. Effectively, var1=num1 and var2=num2. The body of the function ‘add’ is now executed with the values of ‘var1’ and ‘var2’. Thus the arguments are passed from the program (which is the main ( ) function) to the parameters of the function ‘add’. The variables used to hold the argument values are known as parameters. The function declarator in the function definition specifies both data type and name of parameters. In our example, the parameters were ‘num1’ and ‘num2’. Their data types were int (integer).

Remember: The values of ‘num1’ and ‘num2’ are passed to ‘var1’ and ‘var2’. The function is operating only on ‘var1’ and ‘var2’ (it does not operate on ‘num1’ and ‘num2’). If we had declared the add ( ) function in the program, it would have been as follows: void add (int, int); In the function declaration you don’t have to specify the parameter names (just specifying the data types of the parameter is sufficient). Remember: You pass arguments to parameters.

Functions

117

A closer look at Functions

The following topics are covered in this section: • • • • • •

Default Arguments Return Values Returning void int main and void main ( ) exit( ) using return to break out from loops

Default Arguments While using functions with parameters, you can specify default argument values (i.e. in case arguments are not passed to the function then the function will assign the default values to the parameters). #include void add (int var1=5, int var2=10) // default values 5 and 10 { o

int var3; var3 = var1 + var2; cout<
} int main( ) { o

add( ); add(1,2); add(1);

//default arguments 5 and 10 used // arguments are now 1 and 2 // arguments are 1 and 10 return 0;

} The output will be: The sum of the two numbers is 15 The sum of the two numbers is 3 The sum of the two numbers is 11

Functions

118 If the programmer specifies arguments then the default arguments are not used. Some points to remember are: •

If you are declaring a function, it is sufficient to specify the default arguments in the function declaration (function prototype) alone.

•

The default arguments should be the rightmost in the parameter list. You cannot use: void add (int var1=5, int var2)

•

Default arguments are used when the programmer feels that those values will be frequently passed to the function.

Return Values So far we have only seen functions with ‘void’ as the return data type. In this section you will learn about how to return values from functions. ‘void’ means that no value is returned by the function. Return value, as the name suggests, is used to return some value from the function to the caller process. When a function completes its execution it can return a single value to the caller. ‘return’ serves two purposes: • •

It gives back the program control to the caller. It can also return a value to the caller.

The syntax is: return variable-name; This statement is specified at the end of the function body before the closing brace. When a function returns a value, the data type of the return value must be specified in the function header as well as in the function declaration. Consider the following program that uses a function to return a value: // To add two numbers using return value #include int add (int , int); int main ( ) { int sum, var1, var2; cout<< "Enter the two numbers"; cin>>var1>>var2;

Functions

// Declaration

119 sum = add(var1,var2); //Function call cout<< "The sum of the two numbers is "<
// Function Definition

In the above program the statement of interest to us is sum = add(int num1, int num2); The right side of the equal sign is actually the function call. This is being assigned to a variable called ‘sum’. Hence, the function ‘add’ has to be executed and some value should be returned. This returned value is assigned to ‘sum’. In the function header instead of ‘void’ we have mentioned ‘int’ as the return data type. This means that the function ‘add’ will return (or give back) an integer quantity to the calling program (in this case the caller is the main ( ) function). Therefore, the sum of ‘num1’ and ‘num2’ will be returned to main ( ). You have to mention the return data type in the function declaration also. Remember: The data type specified in the function declaration should match the return data type in the function definition. Make sure that the data type of the variable you are returning to (in the above case this is the variable ‘sum’) also belongs to the same type as the return data. What would happen if you return a value from a function but don’t use it? Will it cause an error? What if you don’t assign the returned value to any variable? Is it a problem? It is entirely your choice as to whether you want to use a returned value. If you don’t assign the returned value to the variable then the compiler simply ignores the return value. It will not be stored anywhere unless you assign it to some variable.

Returning Void Once a function returns a value, the function will terminate and program flow will be transferred back to the caller. When a function has a return data type of ‘void’ we needn’t specify the return statement at the end of the function body. The function will terminate at the end of the function body (i.e. when it encounters the closing brace of the function body). If you would like to use a return value in for a function that has void as the return data type, then you can type: return;

Functions

120 No value is returned in this case to the caller but program flow is handed over back to the caller program when the ‘return;’ statement is encountered. The following program illustrates this concept of returning void from a function: #include void convert(int dollar) { if (dollar<0) { cout<<"\nCan't convert negative amount!"; return; } cout<<"\nThe equivalent money in Rupees is : "<<46*dollar; } int main( ) { int amount; cout<<"\nEnter the amount in dollars you want to convert: "; cin>>amount; convert(amount); return 0; } The output when you type a positive value is: Enter the amount in dollars you want to convert: 5 The equivalent money in Rupees is : 230 The output when you enter a negative value is: Enter the amount in dollars you want to convert: -1 Can't convert negative amount! As can be seen from the output in the second case, once the return statement is encountered the program will stop executing the function (thus it does not calculate the value of 46*dollar if the value of dollar is negative).

Functions

121

void main ( ) and int main ( ) The main( ) function can be written in one of two ways. Either you can use: void main ( ) or you can use: int main ( ) { //code return 0; } int main ( ) returns an integer value while void main ( ) doesn’t return anything. Consider the following program: # include int main ( ) {

int test; cout<<"Enter a value :"; cin>>test; if (test= =1) { cout<<"You typed 1"; return 1; } cout<<"This line is displayed if you typed a value other than 1"; return 0; } What do you think happens when the user types 1 as the value of ‘test’? Since ‘test’ is equal to 1, the compiler will go into the body of if. It will display "You typed 1" on the screen. Then the compiler will return a value of 1. Generally a return value of a nonzero number is used when errors are encountered. You can't use this return value anywhere else in your program (Why? Because the caller for the main ( ) function is your operating system). In other functions (functions other than ‘main’ ), you can make use of the return value. After returning the value, the program exits. This means that the compiler will not even read the remaining few lines and hence nothing else will display on the screen. The compiler will quit once any integer has been returned by the main ( ) function. If you type anything other than 1 for test, the compiler will skip the ‘if’ body, display the last statement and then return 0.

Functions

122

Better to use int main ( )? We could now delve one step further into the topic. Which one is better? Or which one should we use and why? Void is generally used to declare functions that do not return values. When you use int main ( ), the main function returns an integer to the operating system (since the OS is what calls the program and in turn the main function). Returning a value from main ( ) is like an exit function. The value is returned to the operating system and the program terminates. What will the OS do with your returned value? Actually, the OS never wants to know what you return. The program which started your program might need to know. In any OS, a program when running is called a "process". When booting up, the operating system starts the first process (called "init" in UNIX systems). Thereafter the first process starts other processes such as a shell (shell is just a program, which reads commands from the user and converts it to system calls). So when you write a program and execute it in the shell, the shell starts your program. So now, the shell is the parent process of your program (and your program is the child of the shell). Now, in the same way, suppose you want one of your programs to load another program to do a particular job and you want to know just whether the job was successful or not, then the OS gets the exit code of the child process and gives it to the parent process; just like returning from a function. So it is a standard to give the exit code as '0' for a success and any non-zero integer for an error. When programming in C/C++ you can give this exit code when you return from the main function. So you've to declare main as 'int main( )' to do that. If you declare it as 'void main( )' C++ wont allow you to set a value to be returned to your parent program. So the variable which should contain the return code will be filled by nothing, which means that memory can be in any state (unpredictable). Hence you have no control on what value your parent process gets when your child program exits. This is not just for UNIX, it holds good for MSDOS and Windows too. In the UNIXes the shell is usually 'sh' or 'bash'. In MSDOS the shell is called 'command.com'. In Windows the shell is 'explorer.exe'. Hence it's always better to use int main ( ) along with a return value at the end of the main ( ) function. A return value of zero indicates a normally terminated program. A non-zero value is used in case of errors. Of course this does not mean that a program written with void main ( ) won’t work; but it is better to avoid writing such programs.

A practical example over here (along with some basics of batch programming).

Functions

123

exit() There is a function called exit ( ) which can be used to terminate (or break out from) the program. The function is: void exit (int r); where ‘r’ is an integer value returned to the OS. Usually a value of 0 is used to indicate normal termination while a non-zero number is used in the case of abnormal termination (due to errors). Thus, the syntax (or function call) will be: exit (0); or exit (1); Instead of using integers we can also use two predefined macros: EXIT_SUCCESS (which is equivalent to 0) or EXIT_FAILURE (which is a non zero number). The exit ( ) function is declared in the stdlib.h library file. Hence you should type: #include in case you want to use this function.

Using ‘return’ to break out from loops The ‘return’ statement will return program flow control to the caller and this feature can be used to break out from loops. An example program is given below: #include int display( ) { int i; for (i=0;i<10;i++) { if (i!=5) { cout<<"\n"<
Functions

124 } } return 0; } int main( ) { display( ); cout<<"\n\nYou have returned to the main function."; return 0; } The output of the above program will be: 0 1 2 3 4 You have returned to the main function. As can be seen above, the return statement has acted like a ‘break’ statement to return control flow to the main ( ) function.

Functions

125

Example of int main()

If you feel lost with the theory, let’s try out something practical to prove the point. The example has been simplified to illustrate the use of int main( ). We’ll write a program ‘prog1’ in which we’ll ask the user to enter an integer. Depending on the value entered, we’ll set the return value of main( ). We’ll use this return code in DOS to conditionally execute another program called ‘prog2’. The programs are pretty simple and they would appear as: //prog1.cpp – This program asks the user for an input and returns a value of 0 or //5. #include int main( ) { int choice; cout<<"\nWelcome to prog1"; cout<<"\nEnter 1 to skip 2nd program:"; cin>>choice; if(choice==1) { return 5; } else { return 0; } } Our second program just displays a statement to indicate that we are executing the second program. //prog2.cpp – This program simply displays a statement on the screen #include int main( ) { cout<<"\nCongrags.You are in the second program!"; return 0; } Build the two executable files: prog1.exe and prog2.exe.

Functions

126 Note: If you are using VC++, the exe files will be created in a folder called “Debug” within your project. Turbo C++ will create the exe files in the same folder itself. So, now we have 2 programs but how do we conditionally execute the 2nd one depending on the return code of the first? The answer lies in batch programming (if you are using DOS) or in shell programming (if you are using Unix/Linux). We’ll deal with batch programming. This is basically the creation of *.bat files (so far we’ve been creating *.exe files). I won’t go into this topic deeply but I’ll cover a bit of it so that you can appreciate return codes from programs. Before starting to write a *.bat file, you can copy the 2 exe files we created (prog1.exe and prog2.exe) into the same folder (I’ve copied them into my C:\). I assume that you have used a bit of MS-DOS (at least you should be familiar with the command prompt, changing directories etc.). Command prompt: To get to this from Windows go to START->RUN and type “command” in the pop-up box. You’ll be taken to the DOS prompt (this is the place from where you can give commands to DOS). The prompt on my system is: C:\MYWIN\Desktop> Now type cd\ to go to C:\ C:\> Let’s create a batch file named combo.bat. To do this simply type: C:\>edit combo.bat You’ll be taken to an MS-DOS text editor (similar to Notepad in Windows). Type the following in the file, save it and return back to DOS. @ECHO OFF ECHO **** WELCOME TO BATCH PROGRAMMING **** ECHO Executing the prog1 prog1 IF errorlevel 5 GOTO end prog2 :end ECHO End of batch file

Functions

127 Perhaps everything seems weird? Remember: MS-DOS command.com is not case-sensitive (i.e. typing DIR or dir is the same). The first 3 lines of our batch file are used for the purpose of displaying something on the screen (equivalent to cout<< in C++). On the 4th line we say: prog1 This is equivalent to executing the program ‘prog1.exe’ on the command prompt. Batch files are used basically to execute a set of instructions/programs in a particular sequence. If every time you log into the system, you want to perform 10 commands, then each time you’ll have to keep typing the 10 commands on your prompt. You can save time (and also needn’t worry about remembering the sequence of commands) if you write those 10 command in a batch file. Now, each time you log into the system, you just need to type the name of the batch file and voila! (all your 10 commands will be executed faithfully). Coming back to our program, prog1 in the batch file will execute our first program. You’ll see the display: Welcome to prog1 Enter 1 to skip 2nd program: 1 Let’s assume the user types 1. According to our program: if(choice==1) { return 5;| } Now prog1 returns a value of 5 to the caller. The caller is our batch program combo.bat. The next line of the batch program checks for this return code. IF errorlevel 5 GOTO end The IF condition becomes true if the previous step had a return value of 5 or greater. In our case the previous step was the execution of ‘prog1’ and this returned a value of 5. Thus the condition is true and the combo.bat will go to the section labeled ‘end’. Here we just display a statement saying that it’s the end of the batch program (echo is used to display on the screen). If the user had entered some other value then the batch file would have executed prog2 since the return value would have been less than 5 (in our case it was 0) and so the IF condition would be false. The output if you entered 1 would be:

Functions

128 C:\>combo **** WELCOME TO BATCH PROGRAMMING **** Executing the prog1 Welcome to prog1 Enter 1 to skip 2nd program:1 End of batch file C:\> The output if you entered some other number would be: C:\>combo **** WELCOME TO BATCH PROGRAMMING **** Executing the prog1 Welcome to prog1 Enter 1 to skip 2nd program:3 Congrags.You are in the second program!End of batch file C:\> Just follow the above steps, create the batch file and try it out on your system. To execute batch files you don’t need to compile the file (i.e. combo.bat can be directly executed). This is because the command prompt is an interpreter (it executes commands one at a time and does not require compilation as we do for C++ programs). In Unix/Linux, this is called shell programming (and instead of batch files we call them shell scripts). In large applications, you would need to execute a series of programs everyday and these are written in shell scripts. The execution of programs would depend on the return code of the previous program (if the previous program failed because of some error then you might not want to continue execution of the remaining programs). By now you should have understood about the difference between void main( ) and int main( ). Note: If you are using Unix/Linux then refer to the Appendix for the above section.

Functions

129

A closer look at Functions

The following topics are covered in this section: • • •

Types of Functions Function Overloading Apply what you've learnt

Types of Functions There are two types of functions namely: 1. Library Functions • • •

The declaration of library function is in the header file specified at the beginning of the program. The definition is in a library file that is automatically linked to the program Declaration and definition are not required. We will only call the function. Example : rand( ), clrscr ( ), exit( ) etc.

2. User Defined Functions • • •

Declaration and definition are part of the source file (*.cpp file). Function definition and declaration have to be written by the programmer. Example of user defined functions is the add ( ) function that we used in the previous section.

There are many functions which are provided by the compiler. These functions that come with the compiler are called as library functions. The prototype for the library functions will be present in some header file. To use a library function, you only need to include the header file (where the function prototype exists) and should know the name of the function. It is common for programmers to write coding for functions and then use them later in some other program when needed. In fact in C programming, this was quite common. You can do the same in C++ as well. You could define a set of general-purpose functions in a header file and include the header file in the programs where you want to use those defined functions (by specifying a function call statement). But using functions in this way can lead to some problems, which will be discussed later (the main problem is when there is a clash of function names). In C++ we make use of ‘classes’ and reuse classes, rather than functions directly.

Functions

130 Using library functions: rand( ), srand ( ), time( ) There may be instances wherein you will want to generate numbers randomly. For example if you are simulating a game played with dice then you should be able to produce numbers between 1 to 6 randomly (corresponding to the 6 faces of a dice). Or if you want to simulate the tossing of a coin you should be able to retain the randomness of the event (i.e. these are events which you can’t predict. It could be a head or a tail). We can make use of the rand ( )library function to perform such tasks. The rand ( ) function is defined in the stdlib.h library. Let us write a program to toss a coin and ask the user for his/her choice. If the user’s choice and the result of the toss are the same then the user wins the game. #include #include int main( ) { int move; char choice; do { cout<<"Enter 1 for head and 0 for tail: "; cin>>move; if (rand( )%2= =move) { cout<<"You win."; } else { cout<<"You lose."; } cout<<"\n\nDo you want to play again? "; cin>>choice; }while(choice= ='y'); return 0; } The rand ( ) function will generate integers upto a maximum of 32767. But in the case of tossing a coin we have only two possibilities (a head or a tail). To scale down 32767 to two cases we divide the rand ( ) value by 2 and use the remainder (the remainder will either be 1 or 0). Thus we assume that 1 is head and 0 means tail in the above program. The output for the above program will be: Enter 1 for head and 0 for tail: 1 You win. Do you want to play again? y Enter 1 for head and 0 for tail: 1 You win. Do you want to play again? y

Functions

131 Enter 1 for head and 0 for tail: 1 You lose. Do you want to play again? n If you run the program again a second time the result will be: Enter 1 for head and 0 for tail: 1 You win. Do you want to play again? y Enter 1 for head and 0 for tail: 1 You win. Do you want to play again? y Enter 1 for head and 0 for tail: 1 You lose. As you might have noticed the sequence is the same (i.e. each time the program is run the same set of random numbers are produced). This is because the random number is generated in a sequence and unless you ask the computer to start the sequence from a different position it will always keep starting at the same place. We have another function called srand( ) than can be used to alter the start of the sequence. To do this just add the satement: srand( time(0) ); before the ‘do’ statement. The function time ( ) is defined in ‘time.h’ header file. The output will now be: Enter 1 for head and 0 for tail: 1 You win. Do you want to play again? y Enter 1 for head and 0 for tail: 1 You lose. If you run the program there is a good chance of getting a different result for the same inputs. This is because we are setting the random generator differently each time the program is run. The function time (0) will give the present system time in seconds. Each time you run this the time (0) value will be different. Suppose you want to simulate the throw of a dice then you should scale down the outcomes of the rand( ) function to 6. For this (instead of rand( )%2, you could use the statement: ( ( rand( ) % 6 ) + 1 ) We have to add 1 because rand ( )%6 will produce values between 0 and 5 but we need values from 1 to 6.

Functions

132

Function Overloading Can two functions have the same name? More than one function can have the same name but they should have different number of parameters or the types of the parameters should be different. This is known as function overloading. The name of a function along with its parameter data types forms the function signature. The signature helps differentiate between two functions. In function overloading the signatures of the functions with the same name will be different. In general, overloading is the process of assigning several meanings to a function (or an operator as in operator overloading, which we will discuss in a later chapter). Consider the example given below: // A PROGRAM TO ILLUSTRATE FUNCTION OVERLOADING void display( ); arguments void display (char); void display (char, int);

// Function declaration – This function has no // One argument // Two arguments

int main( ) { display ( ); display (‘=’); display (‘+’, 30); return 0; } void display( ) { cout<< "Hi!"; } void display (char ch) { cout <
Functions

133 the parameters of each of the three functions are different. Once it notices that they are different, the compiler will consider the three functions to be different. Whenever the ‘display’ function is called, the correct function will be called depending on the arguments that you have used. Remember: The return value of a function is not part of the function signature. Do not try to overload based on return values (this will produce a compile error). You may wonder why this is the case? The return value of a function need not be stored (i.e. even if a function returns a value you need not use that value in your program). If you used 2 functions called int add( ) and double add( ) and if you never assigned the return value to any variable the program will have no way of determining which function to call.

Apply what you’ve learnt Let’s write a C++ program to create a little mathematical program. The program should have a menu display providing the user with three options. There should be an option to generate the Fibonacci series, an option to find the factorial of a number and an option to exit the program. All of this has to be done using functions. (The entire program could be written within the main ( ) function without using functions but by using functions you will be able to create a clean and structured program. For performing each of the tasks we will write individual functions and you will find that it is much easier to follow the logic of the program by writing using functions). By the way, the Fibonacci series goes as follows: 1,1,2,3,5,8,13,21,34,55,89 and so on. (just add two numbers and you will get the next number in the series). The factorial of a number, say 5 is: 5*4*3*2*1 Factorial of 6 would be: 6*5*4*3*2*1 //A program using functions #include #include //to make use of the system("CLS"); function int menu( ); //provide a menu for the user void fibo( ); //function for generating fibonacci series void fact( ); // to find the factorial of a number

Functions

134 int main ( ) { int ch; while (1= =1) //an infinite loop which can be broken { system("CLS"); //to clear the screen before the menu is displayed ch=menu( ); switch (ch) { case 1: fibo( ); break; case 2: fact( ); break; case 3: cout<<"\n Program Terminated."; break; default: cout<<"\n Invalid choice."; break; } if (ch= =3) { break; //break from while loop } } return 0; } //All the function definitions below: int menu( ) { int choice; cout<<"\n\n\n Welcome to my Program"; cout<<"\n 1.) Generate a Fibonacci Series."; cout<<"\n 2.) Find the factorial of a number."; cout<<"\n 3.) Exit."; cout<<"\n\n Enter your choice : "; cin>>choice; return choice; } void fibo( ) {

Functions

135 int max, sum, a1, a2; cout<<"\n\nHow many terms do you want in the series? "; cin>>max; a1=1; a2=1; cout<<"1,1"; for (int i=2;i>num; for (i=num;i>0;i--) { result = result*i; } cout<<"\n\n The factorial of "<
Functions

136

A closer look at Functions

The following topics are covered in this section: • • • •

Recursion An elaborated example using recursion Inline Functions Recap

Recursion Recursion comes from the word ‘to recur’ which means happening repeatedly over and over again. Recursion is also referred to as circular definition. In programming we have recursive functions and they are functions that keep repeating themselves. How do they repeat themselves? Well, actually the function keeps calling itself till some condition is satisfied. It might seem really funny to think of a function calling itself but this is exactly what happens. The best example for recursion is to calculate factorials. In the last program we wrote a function to find the factorial of a number using the ‘for’ loop. We’ll now see how to do the same using recursion. Remember to read the program just like the compiler would read it; otherwise you’re bound to get confused. #include int fact(int n) { int result; if (n= =1) { return 1; } else { result = n * fact(n-1); return result; } } int main( ) { int num; cout<<"\nFor what function do you want to find the factorial : "; cin>>num; cout<<"\n\n The result is : "<
137 First of all, the function fact ( ) is the recursive function here. Why? Check out the function body and you’ll see that this function calls itself. The basic idea is that if you want to find the factorial of 3, the answer is actually equal to 3*factorial (2). The factorial of 2 will be: 2*factorial (1) and factorial of 1 will be 1. Let us interpret the logic of the program. For understanding purpose, let’s assume that we want to find the factorial of 4. •

Now num=4 and n=4. The compiler enters into the recursive function and calculates value of ‘result’.

•

result = 4* fact (3);

what does fact(3) mean? ‘fact’ is the same function and hence the function is being called with a different argument value. The value returned by the function is ‘result’ (which is 4*fact(3)). But there is another function called in this returned value. So the program tries to calculate fact(3). When calculating fact(3), it again calculates the value of ‘result’. Now, •

result=3*fact(2); This value is returned and your actual expression in the computer would be 4*3*fact(2). What next?

•

Calculate fact(2) and this leads to:

result=2*fact(1); •

The expression in the computer will now be 4*3*2*fact(1). The program calculates fact(1). When the value of ‘n’ is 1, we have specified an ‘if’ condition that says: return 1;

•

1 is returned for fact (1) and the entire expression becomes: 4*3*2*1 and the compiler produces the result by multiplying the numbers.

If you don’t give the ‘if’ condition the recursive nature will never stop and it will lead to problems. Remember: When using recursive functions make sure that there is a way for the function to stop itself from infinitely repeating itself. Can it repeat itself infinitely? You do not want a function to keep calling itself infinitely and this is why we should provide some means of breaking out from recursion. When using recursion there are chances for stack overflow. Stack is a special portion of memory where the computer stores temporary values. For example when a computer encounters a function call, it has to store the current location before going to the function. When the function is executed, the program will return back to the original position and continue the program execution. In recursive functions, there are chances for the stack getting used up quickly. That’s what is stack overflow.

Functions

138 Anyway, there isn’t much advantage of using recursion but there may be some cases where you feel that recursion might make the coding easier. A programmer usually uses recursion only if it mirrors the natural methodology or if the iteration method is complex. But be very careful while using recursion. The problem with recursion is that it involves a series of function calls and this can consume extra memory space. Remember: Any C++ function can be made recursive. What about main( )? It is also a C++ function but main ( ) is the one function which CANNOT be made recursive.

Recursion in string reversal It is important to understand how the stack works during recursion. The best example to illustrate this is the problem of reversing a given string. The problem would be easy to solve if we knew the length of the string beforehand. Or we could declare a huge array and hope that we don’t get a string longer than the array. Our problem is stated as follows: "Write a C++ program to reverse a string entered by the user. The string will be terminated when the user presses the Enter key. You should not restrict the input string length." To solve this let’s take a recursive approach: //********************************************************* //* Program to illustrate string reversal using recursion //********************************************************* #include using namespace std; void backwards( ) { char ch; ch=getchar( ); if (ch!='\n') { backwards( ); } cout<
Functions

*

139 trial lairt Though the code is really small it might seem confusing at first. First of all, the getchar( ) function will extract only one character at a time. If you want to retrieve 5 characters then you’d have to use getchar( ) 5 times (in our program we do this using recursion). To explain the working, let’s take an example of what happens when we run the program. The main( ) function calls the function backward( ). In this we have a local variable named ‘ch’. This is now allocated memory space in the stack. Let’s consider our stack as shown below (‘ch’ still doesn’t have a value):

The next line says: ch = getchar( ); On encountering this line the program waits till the user presses an Enter (getchar( ) will retrieve a character only when the user presses the Enter key). The user now types the word ‘trial’ and presses Enter. ‘ch’ will now have the value ‘t’ (1st letter of the input string).

Next line says: if (ch!='\n') { backwards( ); } Our ‘ch’ value is ‘t’. So the condition is true and backwards( ) is called again. What happens in this second call? Remember: When a function call occurs the compiler stores some information in memory so that it can return back to the caller. If function A calls B, then once B is completed the program flow should return to the exact point in function A and continue executing the rest of function A.

Functions

140 In our case the backward function is not complete (it will be complete when backward( ) returns control to the caller- in our case the caller is main( ) ). So, again we go through the same process. A character named ‘ch’ is declared in the function. Thus memory space is allocated for this variable in the stack. Remember: Each time a local function is called the variables created within that function are available only within that function. So now our stack will look as below:

Why is the second ‘ch’ on top of the first? A stack functions like that. Each time you add something new onto the stack, it will be added to the top of the pile (just like a stack of plates). The first ‘ch’ and second ‘ch’ are not the same. The top ‘ch’ corresponds to the variable created during the second call of backward( ) while the lower one corresponds to the variable created in the first call of backward( ). Let’s denote them as ch1 and ch2 (so that you don’t get confused as to which ch we are referring to). Again we have a getchar( ) function. This will now get the second letter of the input string (i.e. ‘r’). Now ‘ch’ has a value of ‘r’ and it is not equal to \n. The stack would like this:

Again the function backward( ) is called. This process goes on and you will finally reach the following stack structure:

Functions

141 This ‘ch’ will have a value of ‘\n’. The if condition will fail and we’ll enter the else loop which says: cout<
Inline Functions There may be instances when you want to repeat a process more than once in a program. You may think of going for the concept of functions. It’s fine as long as your function is a bit lengthy. Suppose there are only one or two lines you want to repeat? Is it worthwhile going for a function? When a program executes a function call, it has to save the present memory address and then go to a new memory address to access the function. After executing the function it has to return back to the memory address from where it branched off. All of this is referred to as ‘overhead’ and by branching (or jumping) from the main program to sub-routines involves a lot of overhead. This means it will take some time and will also use some memory space. If a function is very small, then it might not be advisable to make use of so much of overhead (i.e. there is no need for using another function). Instead, we can make use of the inline functions. Inline functions will simply substitute the function definition wherever there is a function call. This is more like substitution. Example:

Functions

142 // Convert Dollars to Rupees # include inline double dollartors (double d) // The function is inline. { return 47*d; // Inline functions usually contain only one/two body lines } int main ( ) { double dollar; cout << "How many dollars :"; cin>>dollar; cout<< "Rupees : "<
//Function call

As you can see above, the inline function is very similar to a normal function. One difference is that you have to mention the keyword ‘inline’ before the function name in the declaration. When the compiler comes to the function call, it knows that ‘dollartors’ is an inline function. So the compiler will insert the body of the function in place of the function call. The compiler will simply copy and paste the function body wherever there is a function call. After making the substitutions wherever the inline function has been called (in our program it is done in only one place), the program is executed. Thus when the program is executed, the amount of overhead involved is reduced since the equivalent coding will be: int main ( ) { double dollar; cout << "How many dollars :"; cin>>dollar; cout<< "Rupees : "<< 47*d; //Inline function body substituted return 0; } The advantage is that the program needn’t save its present memory address, go to the function’s memory address, execute the function and return back to the original address. Instead the function code is brought into the main program and it is executed just like a normal C++ statement. Thus processing time can be reduced significantly. Remember: It is useful to make a function inline if its body consists of just one or two lines.

Functions

Functions

143

Recap • • • • • • • • • • • •

A function is a group of statements written for a specific purpose and grouped within a single block. A function has to be declared if it is called before being defined. Arguments are passed to a function’s parameters. The data type of the arguments should match the data type of the parameters. If a function is declared as returning a value to the caller then it should return the corresponding data type value (unless it returns void). The return statement is used to return a value to the caller as well as give back program control to the caller. The main ( ) function returns value to the OS. Overloaded functions should have the same name but different parameters. Return data type cannot be used as a basis for function overloading. Inline functions are used when the body of the function is very small (one or two lines). Recursive functions are functions that call themselves. Some provision has to be provided for them to break out of recursivity. Recursive functions have more overheads and are generally not used.

144

More On Data Types and Variables

The following topics are covered in this section: • •

Scope of Variables Storage Classes

Scope of variables Scope refers to the region where something is valid or the region where something can exist. Variables in C++ have a defined scope, which depends on the way they are declared. There are three places where a variable can be declared: as local variables, formal parameters and global variables. Remember: In C we can declare variables only in the starting of the function. In C++, we can declare variables anywhere within the program.

Local Variables Variables declared within a function are called local variables (sometimes called automatic variables). These variables can be used only within the block (or function) in which they are declared. A block starts with an opening curly brace and ends in a closing curly brace. A local variable is created upon entry into the block and destroyed when the program exits that block. If you create a variable in the main ( ) function then it can be used only within the main ( ) function. That variable cannot be accessed by some other function that you may have created. For example: void test ( ) { int q; q = 2; } void test2 ( ) { int q; q = 5; }

// Start of block

// End of block // Start of another block

The two q's declared in the two functions (test and test2) have no relationship with each other. Each q is known only within its own block (since it is a local variable). The main advantage is that a local variable cannot be accidentally altered from outside the block.

More on data types & variables

145 Try it: Compile the following piece of code in your compiler and check the results int main( ) { int outer; { int inner; cout<<"enter the outer variable value : "; cin>>outer; } cout<<"\n Enter inner variable value : "; cin>>inner; return 0; } What do you think will happen? The above program will lead to a compile-time error. Variables are visible only within the block of code where they are declared (unless they are global variables). The coding enclosed within the two braces is called as a ‘block’ of code. Thus: { int inner; cout<<"enter the outer variable value : "; cin>>outer; } is a block of code within which we have declared an integer variable ‘inner’. This variable ‘inner’ is not visible outside of this block. Thus the statement: cin>>inner; will lead to an error because ‘inner’ is only known inside this block and not outside the block. Note the difference between the two codes given below: int main( ) { int i=5; { int i; i=6; } cout<
More on data types & variables

//This ‘i' is only visible within this block.

//Value will be 5 (NOT 6)

146 Compare this coding with the one below: int main( ) { int i=5; { i=6; } cout<
//Value of ‘i' is 6 (NOT 5)

What’s the difference between the two codes? In the first one we have declared a new integer ‘i' within the inner block. Now this inner variable is different from the outer block variable. In the second case, we are modifying the value of the outer block variable (in this case there is only one variable – the outer block variable). Remember: An inner block can access the variables that are present in the outer block. But the reverse is not possible.

Formal Parameters As we have seen, if a function is to use arguments then it must declare variables that will accept the values of the arguments. These variables are called parameters or formal parameters. For example: int remainder (int a, int b) ‘a’ and ‘b’. { return a % b; }

// In this function, the parameters are

They are actually similar to local variables and the parameters are visible only within the function block.

Global Variables These variables are known throughout the program. They can be used by any part of the program and are not limited in scope like local variables. They are declared outside the main ( ) function. #include int count; // count is a global variable void increment( ) { count=count+2; }

More on data types & variables

147 int main ( ) { count=1; • increment( ); //count is now 3 count=count+1; //count is now 4 } The above program is not complete but you can see that two functions (increment and main) can access the same variable ‘count’. count=1; The increment ( ) function increases the same count value by 2. Now count is 3 and finally the main ( ) function increases count by 1. The final count value is 4. This is a case of more than two variables accessing the same global variable. Remember: Global variables will take up more memory because the compiler has to always keep it in memory. Avoid using too many global variables. Use it only if the variable is going to be used by a number of functions. What would happen if a program uses an identifier as both local and global variable name? Consider the program below: #include int var=55; int main( ) { int var=20; name cout<<"\nGlobal variable value is : "<<::var; var=var+1; cout<<"\nLocal variable value is : "<
//Global variable

//Local variable with same

The output of the program will be: Global variable value is : 55 Local variable value is : 21 Within the main ( ) function whenever we refer to ‘var’, it will mean the local variable only. Suppose you want to call the global variable, then you have to make use of the scope resolution operator (::). This operator is explained later but for the time being just remember that ‘::var’ will refer to the global variable.

More on data types & variables

148 Beware: It is not good programming practice to use the same variable name for global and local varaibles (it can lead to a lot of confusions and programming errors).

Storage Classes Storage classes are qualifiers that you can use to tell the compiler how you want the variable to be stored in memory and how you want to access it. The four storage classes are: 1. 2. 3. 4.

Auto (automatic) Static Extern Register

These four terms are keywords in C++.

Auto All local variables are ‘auto’ by default (auto meaning automatic). Whenever you declare a variable in a function, it is already ‘auto’. You needn’t explicitly specify this qualifier. For example: int var; will be the same as: auto int var; Suppose we have a function named counter ( ) with a local variable ‘count’ void counter ( ) { int count=0; cout<
More on data types & variables

149

Static There may be occasions when you want to retain a particular variable’s value each time the function is called. When you use auto variables, you will lose the value of the variable. If you declare a variable as a static variable then it will retain its value. int counter( ) { static int count=0; count=count+1; return count; } int main( ) { for (int i=1;i<10;i++) { cout<
Extern variable Extern or external variable is useful in multiple file C++ programming. So far we have only seen single file programming (i.e. you write the entire program in one *.cpp file, compile and run it). As your program complexity increases you will find it better to divide your program into different files. In such instances, extern variables are useful. This will be dealt with in the topic of "Multiple File programming".

More on data types & variables

150

Register variable When you specify a variable as ‘register’ the compiler might place the variable in one of its hardware registers. The word ‘might’ is very important because you cannot be sure that the compiler has placed the variable in its register. Remember: In C programming you shouldn’t try to find the address of a register variable. Why do we need register variables? Placing a variable in the register will help in speeding up the computational processes that involve the register variable. Since the computer processor has only a fixed set of available hardware registers it cannot place all your variables in its registers. Depending on availability the compiler will decide whether to make a variable a register variable or not. Usually, variables are stored in the computer’s memory (as explained earlier, memory will have addresses for accessing the location and values are stored in these locations). But a register variable is stored in one of the registers of the CPU (the central processing unit). Every microprocessor has a set of internal registers available that it can use for its operations (and accessing these registers is faster than accessing external memory). The syntax is: register data-type variable-name; By the way, it isn’t a rule that only integers can be made register variables. Any data type variable can be made a register variable. Beware: Don’t expect that specifying all your variables as register type will speed up the program. There is a specific limit and beyond that the compiler will treat your register variables as normal variables. Though you can use it on any variable data type, the register variable might work effectively only in the case of an integer or a character. Use register variables for variables that are accessed frequently in your program.

More on data types & variables

151

More On Data Types and Variables The following topics are covered in this section: • • •

Type Qualifiers Arrays Apply what you've learnt

Type Qualifiers Variables can be given a qualifier (something that precedes their data type) to specify how they will behave in the program. The two qualifiers that can be used are: • •

const (constant) volatile

They are sometimes referred to as type-qualifiers (since they specify how the program can modify these variables).

Constants Constants are fixed and will never change (i.e. their value will never change). There might be occasions when the programmer will want to make use of variables whose value should never be modified within the program. When we use variables (As we have done so far in this book), we can change the value of the variable whenever we want to. But once a variable is declared to be a constant (using the keyword ‘const’), it’s value cannot be altered in the program. For example: const float PI=3.14; will make PI a constant with the value of 3.14. A constant should always be initialized with a value (you cannot simply declare const float PI; A value has to be assigned to it as well). By the way, what do you call ‘pi’ in the above example? Is it called a constant variable? Some people use the term ‘constant variable’ (perhaps as a way of distinguishing them from the constants that we saw in the second chapter). Actually this term is an oxymoron. It is advisable to use the term variable when you refer to something whose value can be changed while the term constant is used whenever the value cannot be altered. So ‘PI’ is a constant. Remember: Programmers usually use uppercase identifiers (example: PI, MAX etc.) for constants while lowercase identifiers (like x, marks, age etc.) are used for variables. There is another way to declare constants (this method was used in C programming). Instead of the ‘const’ keyword, we can make use of macros.

More on data types & variables

152 #include #define PI 3.14 int main( ) { cout<
//Macro definition

The output would be: 3.14 # indicates that the statement is a preprocessor directive. This topic will be explained in detail later in the book. In the above program PI is called a ‘macro’. Wherever the term PI is encountered, the number 3.14 will be substituted in its place. Remember: C++ is a case-sensitive language, which means that the compiler will not consider PI and ‘pi’ as one and the same. Beware: You shouldn’t use the equal to sign in the preprocessor directive statement and neither should you use the semicolon terminator at the end.

Volatile The volatile keyword is the opposite of ‘const’. The volatile keyword informs the compiler that the variable can be modified by methods that are unseen (or external). For instance, this external method could be an interrupt-related method. If we don’t specify the variable as volatile, then the compiler might end up denying modification of the variable by such an external method. To declare a variable as volatile, just precede the declaration by the keyword ‘volatile’. The syntax is: volatile data-type variable-name;

Variable Initialization Assigning values to a variable at the time of declaration is known as variable initialization. For example: int x = 10; double db=2e4;

More on data types & variables

153 If global or static variables are not initialized they are automatically set to zero. If a local variable is declared and not assigned any value then it will contain an unknown value (i.e. you can’t say for sure what is the value of the variable. This is sometimes termed as ‘garbage’ value). For example: int main( ) { int local; cout<
//value is unpredictable. It can have any

Remember: Local variables will contain an unknown value till they are assigned a value. There is another way to initialize variables (instead of using the = operator). The following initialization is also valid in C++: int count(5); This will initialize the variable ‘count’ to 5. It is the same as: int count=5;

Arrays If you want to use a variable you should declare the variable first. What if you need to obtain the marks of a student in 20 subjects? Should you make use of 20 variables? You could write the code as: int marks1, marks2, marks3…; This would make the process of declaring variables and obtaining inputs very tedious. Arrays provide an easier way of working with many variables, which are logically related. An array consists of a set of variables of the same data type. Each variable of an array is called its element and each of the elements can be accessed using subscript numbers (or index numbers). The difference between an array and a structure is that array consists of a set of variables of the same data type. A structure, on the other hand, can consist of different data types. You'll learn about structures later on.

The first step if you want to use an array is declaration of the array.

More on data types & variables

154 data-type variable-name [size-of-array]; For example: int marks[5]; This means that you have declared an array of integer type. The variable name for the array is ‘marks’ and size of the array is 5. Hence you have actually declared five integer elements namely: marks[0] , marks[1] , marks[2] , marks[3] and marks[4]. You may have a question at this point: What about marks[5]? The computer counts from zero onwards. The size of the array we declared is 5. So if you start counting from zero then the fifth element is marks[4] not marks[5].

If an integer occupies 2 bytes, then the ‘marks’ array declared above will occupy a total of 10 bytes continuously. Each individual element can store an integer value. The figure below illustrates this concept:

Remember: Start counting from zero. Many beginners do not pay attention to this important fact.

More on data types & variables

155 Some points about arrays: 1. Array is a collection of variables (of the same data type). 2. Each individual element is denoted by its index number. 3. Array elements are placed consecutively in memory (in other words array elements occupy contiguous memory locations; i.e. they are placed adjacent to one another). 4. The size of the array has to be specified while declaring the array (because the compiler has to allocate memory for the individual elements). Accessing a particular element: If you want to display the values of an array, you might think that this will work: cout<
More on data types & variables

More on data types & variables

Initializing an Array: Suppose you want to initialize the array element values at the beginning itself (during the declaration) then you could make use of a comma-separated list within braces as shown below: int marks[5] = {56, 75, 80, 59, 90}; This statement tells the compiler that the value of the first element of the array (or marks[0] ) is 56, the second element ( marks[1] ) is 75 and so on. The initialization of an array is equivalent to: marks[0]=56; marks[1]=75; marks[2]=80; marks[3]=59; marks[4]=90; While initializing an array the number of elements initialized must be equal to the size of the array. In the above example we have 5 elements and all 5 elements have been initialized in the statement: int marks[5] = {56, 75, 80, 59, 90}; Instead of this we could also initialize using the statement: int marks[ ] = {56, 75, 80, 59, 90}; The compiler will automatically set the size of the array as 5 (because 5 elements have been initialized). Remember: For the initialization you have to use curly braces and for the index numbers you have to use square brackets.

156

More on data types & variables

Memory usage for an array: If you have an array of 10 short integers, then the array will occupy a total of 2*10 bytes (20 bytes). An array of 10 long integers would occupy 4*10 bytes (40 bytes). double temp[5]; cout<
157

158

Apply what you’ve learnt Let’s write a program that utilizes the concept of arrays. We’ll write a program to arrange a set of given numbers in ascending order and display the result. The basic steps involved will be: Obtain the size of the array (i.e. how many numbers the user wants tosort, 2 numbers or 3 or 4 or 8 numbers etc.) Obtain the value of each element of the array. (Hint: make use of a for loop) Compare the values of each element with the others and sort the numbers. //To arrange a given set of numbers in ascending order and display the result #include int main ( ) { int test[20]; //we assume that the maximum limit is 20 numbers. int size,i,j; int temp; cout<<"How many numbers do you want to compare : "; cin>>size; cout<<"Enter the numbers you want to check : "; for(i = 0; i>test[ i ]; } for(i = 0; itest[j] ) { temp = test[ i ]; test[ i ] = test[ j ]; test[ j ] = temp; } } } cout<<"The numbers in ascending order are : "; for (i = 0; i
More on data types & variables

159

Character Arrays

You can have an array of any data type: integer, float, double etc. You can even have character arrays which can store strings. A string is an array of characters terminated by the null character (‘\0’). For example, if we store the word "hello" in a character array, the individual characters of "hello" will be stored and the last character of the array will be a null character (‘\0’). It is the null character that denotes the end of the string (this is very important when doing string operations –without the null character we will not be able to identify the end of the string in memory). The character data type can store only a single character but a character array can take in a consecutive series of characters depending on the size of the character array. Example: char word[6]={'h','e','l','l','o','\0'}; You have to provide space to accommodate the null character. You can also assign a string constant directly as below: char word[6]="Hello"; "Hello" is called a string constant and the compiler will automatically add the null character to the array.

The following declaration: char word[6]="Helloo"; //ERROR is incorrect and will produce a compile error because there is no space for adding the null character. But if you don’t specify the size of the array then it is acceptable: char word[ ]="Helloo"; In this case while compiling the compiler will set the size of the array and provide space for the null character also. Beware: You can assign a string literal to a character array only at the time of declaration. You cannot use:

More on data types & variables

160 word[6]="Helloo"; //WRONG Another Example: char name[10]; The above declaration declares an array of character type that can store 10 characters. The name of the array is ‘name’. // A program for getting the name of a person and displaying the name # include int main ( ) { char name[15]; cout<< "Enter your name : "; cin>> name; cout<< "Your name is "< int main ( ) { char name[20]; cout<<"Enter your full name : "; cin>>name; cout<<"You entered your full name as : "<
More on data types & variables

161 The Davis is left out. Why? After the word ‘John’ a blank space has been left. When a blank space is encountered in the input (John Davis), the program will not read the line further on. Hence only the word John is stored in the array name. So be careful. This isn't only for character arrays. This applies even when you want to get input for a number. If the user types 1 followed by a space and then 2, the value of the integer variable will be 1. You can try out variations in your compiler, so that you know exactly how this works. You might be wondering whether there is a way to store the blank spaces? Yes, there is but you shouldn’t make use of the cin method of obtaining input from the user. The cin will stop when it sees a blank space but there are other ways which will store the blank space (those methods will terminate when they encounter a new line; a new line means that the user pressed the ‘enter’ key). For the time being if you want to get the full name of a person just make use of two character arrays; one for the first name and one for the last name. If you are really keen on using a single character array for storing white spaces as well, then you could make use of the gets( ) function. int main( ) { char name[80]; cout<
More on data types & variables

162 Alternative Methods to store blank spaces and new line: The function gets( ) does not perform any array dimension check and hence it doesn’t restrict the user in the number of characters entered. The result is that your program will terminate due to some run-time errors if the array size is exceeded. To avoid this problem there is another alternative function that you can use. This function is a member function and can be called using ‘cin’. (You’ll learn more about objects and member functions later). The function is called get( ). #include int main( ) { char name[10]; cout<<"Enter the name: "; cin.get(name,10); cout<
More on data types & variables

163 See the example below: #include int main( ) { char name[80]; cout<<"Enter the name: "; cin.get(name,80,'*'); cout<
More on data types & variables

164

Arrays Continued The following topics are covered in this section: • • • •

Multi Dimension Arrays Initializing MultiDimensional Arrays Passing Arrays to functions Test yourself

Multidimensional Arrays So far we've only dealt with one-dimensional arrays. int marks[10]; is a one-dimensional array. It is called one-dimensional because it has only one value inside the square brackets. Or in other words, this array will have only a single row of elements. C++ has no limit on the number of dimensions. You can have 2 or 3 or more dimension arrays. Multidimensional arrays are actually arrays of arrays. But we shall take a look at two-dimensional arrays since they will be used frequently. Consider a two dimensional array as a tabular column with rows and columns. int marks[3][4]; declares a two dimensional array with 3 rows and 4 columns. Columns are vertical and rows are horizontal. marks[0][0] marks[0][1]

marks[0][2]

marks[0][3]

marks[1][0] marks[1][1]

marks[1][2]

marks[1][3]

marks[2][0] marks[2][1]

marks[2][2]

marks[2][3]

As you can see marks[0][0] is the first square. The compiler always starts from zero and not one. Hence there are three rows and four columns in the array ‘marks’ as shown in the table above. There are a total of 12 elements. The element in row 0 and column 0 can be referred to as the ‘0 x 0’ element. The element marks[0][1] will thus be called as ‘0 x 1’ element. Always remember that the row number comes first. This is not a universal method of referring to array elements. It is used here to make it easier to refer to the elements instead of using the element names. Obtaining inputs for multi-dimensional arrays: To get the values for an array you have two ways. You have to keep asking the user statement by statement to enter a value. Or you could take advantage of the ‘for’ loop (or any of the other looping mechanisms). We have already seen this in the sorting example involving a onedimension array. The method to obtain the values of elements of a 2 x 2 matrix is similar to that for a one-dimensional array: More on data types & variables

165 int i, j, a[2][2]; for (i = 0 ; i<2 ; i ++) { for (j = 0 ; j<2 ; j++) { cout<< "Enter the "<< i + 1<< " x "<< j + 1 <<"element of the matrix : "; cin>> a[ i ][ j ]; } } The outer ‘for’ loop starts with a value of 0. i = 0 Corresponding to i=0 we will have two values for j (0 and 1). Hence with this you can get the values for a[0][0] and a[0][1]. This corresponds to the first row of the matrix. For the second row, the ‘i’ loop will execute a second time with a value of 1. Hence you can get the values for a[1][0] and a[1][1]. In the cout statement we have mentioned ‘i + 1’ and ‘j + 1’. This is just for the purpose of display. Remember that the compiler will start numbering from zero. The first element for the compiler will be the 0 x 0 element. For the user it is better if you refer to the first element as 1 x 1 rather than referring to it as 0 x 0. Similarly, two ‘for’ loops can be used to display the values of a two-dimensional array.

Initializing multi-dimensional arrays: Initializing a 2-D array is similar to that of a 1-D array. int marks[2][3]={ 40,50,60, 70,80,90}; The above notation is used for readability. You might as well initialize the array as: int marks[2][3]={ 40,50,60, 70,80,90}; Thus if you use the following initialization (hoping that marks[0][2] will be 0): int marks[2][3]={ 40,50, 70,80,90}; the compiler will treat it as: int marks[2][3]={ 40,50,70,80,90};

More on data types & variables

166 and marks[0][2] will be 70 while marks[1][2] will be 0. Only trailing elements will be automatically initialized to 0. There is a better way to initialize multi-dimensional arrays. The following initialization: int marks[2][3]={ {40,50}, {70,80,90} }; actually produces the result we were looking for earlier. Now, marks[0][2] is zero. The additional pair of parentheses makes a big difference. Readability is improved further and now the compiler will set the trailing elements (which haven’t been initialized) in each row to 0. In our case, only the 3rd element of the first row is missing and hence this is initialized to zero. You might recollect that in one dimensional arrays we could specify: int a[] = {1,2,3}; and the compiler would translate this into: int a[3] = {1,2,3}; The question arises as to whether we can extend this to 2-D arrays as well: int marks[ ][ ]={ {40,50}, {70,80,90} }; This will give a compile-time error. The compiler wouldn’t know how many columns you want to specify for the array (you’ll understand this concept when we deal with pointers and 2-D arrays in the next chapter). But for the time being remember that you can forget the 1st dimension but shouldn’t leave out the subsequent ones. Let’s go one step further. What is a 3-D array? int a[5]; int ab[2][5]; int abc[3][2][5]; ‘ab’ is a 2-D array which consists of 2 one dimensional arrays (each of which can hold 5 elements). ‘abc’ is a 3-D array which consists of 3 two dimensional arrays (each of the 2-D arrays contains a 1-D array which can hold 5 elements). The concept can be extended to higher dimension arrays as well (but generally we wouldn’t use more than 3 dimensions).

More on data types & variables

167 How do we initialize a 3-D array? int abc[3][3][2]={ { {40,50}, {10,70}, {20,30} }, { {45,55}, {15,75}, {25,35} } }; The parentheses make the initialization pretty clear. Of course you can remove all the braces but the declaration wouldn’t be easy to understand. Again in the case of a 3-D arrays, you can drop the first dimension but should mention the other 2. The following declaration is legal: int abc[ ][3][2]={ { {40,50}, {10,70}, {20,30} }, { {45,55}, {15,75}, {25,35} } }; You’ll have to take care of the braces. In the above example: abc[0][0][0] = 40 abc[0][0][1] = 50 abc[0][1][0] = 10 abc[0][1][1] = 70 abc[0][2][0] = 20 abc[0][2][1] = 30 What happens in the following declaration? int abc[ ][3][2]={

{40,50}, {10,70}, {20,30},

More on data types & variables

168 {45,55}, {15,75}, {25,35}

};

All that we’ve done is removed the braces which were used to denote that the 1st dimension was 2. But the compiler isn’t smart enough to know what’s on our mind and now it would create the array as: int abc[5][3][2]. abc[0][0][0] = 40 abc[0][0][1] = 50 abc[0][1][0] = 0 abc[0][1][1] = 0 abc[0][2][0] = 0 abc[0][2][1] = 0 abc[1][0][0] = 10 abc[1][0][1] = 70 abc[1][1][0] = 0 abc[1][1][1] = 0 abc[1][2][0] = 0 abc[1][2][1] = 0

and so on.

Moral of the story is that you should do your best to make things explicit when dealing with computers rather than assume that the computer would think the way you’re thinking.

Passing an Array to a Function This topic is dealt with in depth when discussing about pointers. A simple method of passing arrays to functions is illustrated below: #include void disp(int a[ ] ) { for (int i=0;i<3;i++) { cout<
More on data types & variables

169 it will still work. We shall see more about arrays in the chapter on pointers (because arrays and pointers are closely related). Remember: The compiler will not allocate memory or create an array called a[5] when it is present in the function header. This is just to tell the compiler that an array with a maximum of 5 elements will be passed to the function. Of course you could specify it as a[2], because in effect only the address of the array will be passed. More about this in the section on pointers.

Test Yourself on Multi-Dimensional Arrays It is a very common program in schools and colleges. Most of the students tend to mug up the coding and reproduce it at the time of the examination. Of course most of them succeed in doing so (the brain is the best memory device in the world!) but some tend to forget one line of coding and end up with weird outputs. Never mug up programs. Understand the logic of the program and then try it yourself. After all, if your logic is correct then there is no chance that the computer will produce wrong results (it will be as good as you program it to be). Let’s write a program to add two matrices (matrices are two dimensional arrays used in mathematics). The various steps involved are: Ask the user for the order of the matrix (i.e. the number of rows and columns) To add 2 matrices, they should be of the same size. Get the input for each element of the matrix. First get elements of first matrix and then the second. Add the two matrices (i.e. add corresponding elements) and store the values in a third matrix. Display all 3 matrices. //To obtain two matrices and two find their sum #include #include //needed for using the manipulator setw ( ) int main( ) { int i , j , r1 , r2 , c1 , c2 , a[20][20] , b[20][20] , c[20][20]; cout<<"Enter the number of rows and columns of first matrix :"; cin>>r1>>c1; cout<<"Enter the number of rows and columns of second matrix :"; cin>>r2>>c2; // If the matrix orders are not equal then addition is not possible if ( (r1! = r2) || (c1!=c2) ) { cout<>a[ i ][ j ];

More on data types & variables

170 } } for (i = 0; i>b[ i ] [ j ]; } } cout<
More on data types & variables

171

Structures

The following topics are covered in this section: • •

Structures Nesting of Structures

Structures are user defined data types. Structures were used in C and they consist of different data types that are related logically in some way. In other words, a structure groups together different data types under one name. The data items that come under a structure are called structure elements or members (or fields). A structure basically puts different data types into one package. Even for structures you have a declaration and a definition. Declaration means telling the compiler what type a particular variable is. Definition means that the compiler allots memory space to the variable that was declared. In the case of structures, a structure declaration forms a template. When a structure variable is defined the compiler automatically allocates sufficient memory to accommodate all of its elements. You can define as many structure variables as you want. The structure syntax is: struct tag/structure-name { data-type variable-name; data-type variable-name; //more declarations } structure-variables;

// Structure definition

‘struct’ is a keyword and it has to be used to declare a structure. Following the keyword, we type the name of the structure (this is also known as the tag-name). Then we have an open brace, followed by the different data types that you want to put in the structure. Finally we add a closing brace and can give the names of the structure variables. This is known as the structure definition. First of all you should know the use of structures before proceeding further. Suppose you own a small shop. For every set of purchases by a customer, you give the customer a bill. This bill has the bill number and the total amount of purchase mentioned in it. The point to be noted is that, every bill will have a bill number and a particular amount mentioned in it.

More on data types & variables

172 Now suppose you want to keep a record of all the bills you have issued through your computer, you will have to store the following in your computer: the bill number and the amount for each bill issued. Bill numbers will be integers whereas the amount to be paid will be a float quantity. Hence, you have two different data types but they are logically related (since every bill will consist of the two data types). It is here that the concept of structures will be found useful. struct bill { int billnumber; float amount; } one,two; In the above example, we declare a structure by the name ‘bill’. This contains data items ‘billnumber’ (which is an integer) and ‘amount’ (which is a float quantity). The braces are closed and then we define the variables of the structure, i.e. ‘one’ and ‘two’. This means that ‘one’ and ‘two’ belong to the structure ‘bill’. Both ‘one’ and ‘two’ have their own individual ‘billnumber’ and ‘amount’. Therefore, you can give the bill number and amount for bill ‘one’. Similarly, you can also give the details for ‘two’. Remember that at the end of the structure declaration and definition, we have to terminate it using the statement terminator. ‘one’ and ‘two’ are known as structure variables. ‘billnumber’ and ‘amount’ are known as the structure elements. For normal built in data types we would declare a variable as: int x; Where x is the variable and int specifies the type of a variable. Similarly in structures, the variable is declared as belonging to the data type that you have created (which in turn is a combination of different built-in data types). struct bill { int billnumber; float amount; } one,two; Instead of this we can write it as follows: struct bill { int billnumber; float amount; };

More on data types & variables

173 // End of struct declaration–memory not allocated since struct variable not defined int main ( ) { bill one, two; return 0; }

//Structure variable definition

Both the methods are equivalent and are acceptable. Accessing and Initializing Structure Elements: Every structure variable that you define will have its own individual elements. So how do we access these individual elements of a structure? To access a particular structure element we make use of the dot operator. The syntax is: structure-variable . structure-element For example: one.billnumber is the syntax for accessing the bill number of structure variable one. Now that you know how to access a structure element you can initialize it as well. Initializing means giving a value to the element. Example: one.billnumber = 214; one.amount = 1032.25; Bill ‘one’ has a bill number 214 and the ‘amount’ of the bill is 1032.25 One structure variable can be assigned to another only when they are of the same structure type. two = one; is a valid statement because both ‘one’ and ‘two’ belong to the same structure ‘bill’. This statement assigns the values of one.billnumber and one.amount to two.billnumber and two.amount respectively.

More on data types & variables

174 An example using Structures concept: //Declaring the structure phonebook struct phonebook { char name[40]; char city[40]; int tel; }; int main( ) { phonebook a1; cout<<"Enter the name : "; cin>>a1.name; cout<<"Enter the city : "; cin>>a1.city; cout<<"Enter the telephone number : "; cin>>a1.tel; cout<<"\nThe size of the structure variable is : "<
More on data types & variables

175

Nesting of Structures Let us add one more entry column to our phonebook structure. This entry will be the birthday of the person. Birthday means that we should store the date, month and year of birth. To illustrate nesting we can group date, month and year into another structure. Check out the program below: //Another structure called ‘date’ struct date { int day; int month; int year; }; struct phonebook { char name[40]; char city[40]; int tel; date birthday; //birthday is a variable of the structure ‘date’ }; int main( ) {

struct phonebook a1; cout<<"Enter the name : "; cin>>a1.name; cout<<"Enter the city : "; cin>>a1.city; cout<<"Enter the telephone number : "; cin>>a1.tel; cout<<"Enter the date of birth (day, month and year) : "; cin>>a1.birthday.day>>a1.birthday.month>>a1.birthday.year; cout<<"\nThe size of the structure variable is : "<
More on data types & variables

176 The output of the program is: Enter the name : Mathew Enter the city : Delhi Enter the telephone number : 65478 Enter the date of birth (day, month and year) : 2 12 1980 The size of the structure variable is : 96 The entry made is:Mathew-Delhi-65478 Birthday is on : 2-12-1980 First of all have a look at the figure below:

Within the phonebook structure we make use of another structure (date). This is called as nesting of structures. date birthday; will declare a structure variable ‘birthday’ belonging to the structure ‘date’. Thus ‘date’ will have three member elements namely ‘day’, ‘month’ and ‘year’. Since ‘birthday’ comes under the ‘phonebook’ structure we can refer to the member ‘day’ by coding:

More on data types & variables

More on data types & variables

a1.birthday.day The rest of the program should be easy to follow. Now what do you think will be the size of ‘a1’. Size of a1 = 40 (char array) + 40 (char array) + 4 (integer) + size of date structure (which is 12 bytes). Therefore size of a1=96 bytes. We’ll take a look at two more data types that are less frequently used. It’s always better to know what are the various options available because there could be certain instances where they could prove useful.

177

178

Unions and more

The following topics are covered in this section: • • • •

Enumerated Types Union Passing Structures to Functions Recap

Enumerated Types To enumerate means to count. In C++ an enumerated data type permits you to assign different names to your integer values. The syntax is: enum enumeration-name{the various constants separated by a comma}; For example: enum day{mon,tue,wed,thu,fri,sat,sun}; will consider ‘mon’ as being equivalent to 0, ‘tue’ as 1, ‘wed’ as 2 and so on. mon = 0 tue = 1 wed = 2 thu = 3 fri = 4 sat = 5 sun = 6 If you want to start from zero onwards then you have to specify it: enum day{mon=1,tue,wed,thu,fri,sat,sun}; Now mon will be equal to the integer value of 1, tue will be 2 and so on. mon = 1 tue = 2 wed = 3 thu = 4 fri = 5

More on data types & variables

179 sat = 6 sun = 7 To create a variable of the enumerated type you simply need to write: day today, tomm; Or you could combine the enumeration definition and variable declaration into one statement as follows: enum day{mon,tue,wed,thu,fri,sat,sun} today, tomm; Whichever method you use the result is the same. ‘today’ and ‘tomm’ are variables of type ‘day’ which can take any one of the constant values (sun,mon,tue etc…). The integer values that you assign could also be negative integers. Is it possible for 2 enumeration constants to have the same value? Check this out: enum day{mon=2,tue,wed,thu=3,fri,sat,sun}; The values would be as below: mon = 2 tue = 3 wed = 4 thu = 3 fri = 4 sat = 5 sun = 6 It is very much possible to make two or more enumeration constants have the same integer value. You might wonder of what use is the enumeration type? Actually whatever you do with enumerated types is actually equal to working with integers. You can compare enumerated variables, you can increment them etc. The only advantage is that instead of using numbers you can use some useful names. This is especially useful in larger programs where you might want to indicate some particular state by using a name rather than a number. This would aid in understanding the program without any confusion. You could even consider the example that we’ve considered above; would it be better to refer to days of the week as ‘sun’, ‘mon’ etc…or would it be better to have integer values of 1,2,3 etc.? Remember: When you attempt to display any enumeration constant, the program will display only the corresponding integer value.

More on data types & variables

180

Union Unions are similar to structures in certain aspects. They also group together variables of different data types and individual members can be accessed using the dot operator. The difference is in the allocation of memory space. A structure will allocate the total space required for a structure variable but a union will allocate only the space required by one element (the element that occupies the maximum size). Suppose you have a union consisting of 4 variables (of different data types), then the union will allocate space only to the variable that requires the maximum memory space. For example: struct shirt { char size; int chest; }mine; will allocate a memory space of 5 bytes to the structure variable ‘mine’ (assuming 4 bytes for an integer and 1 byte for a character). The same thing could be re-written using unions as follows: union shirt { char size; int chest; }mine; Now, the union variable ‘mine’ will be allocated only 4 bytes (the compiler knows that a character will require one byte while an integer needs 4 bytes. Hence it allots ‘mine’ a total of only 4 bytes). Can you reason out what are the consequences of conserving memory space in this fashion? It means that when you use a union only one element will have a valid value at any instance. In the above example, we can have a valid value for either mine.size or for mine.chest Both the elements cannot have a valid value at the same time. You might be wondering what is meant by a valid value; just check out the example below: #include union shirt { char size; int chest; int height; }; int main( ) {

More on data types & variables

181 shirt mine; cout<<"\nSize of the union is : "<>mine.size; cout<<"\nThe size is : "<>mine.chest; cout<<"\nThe size is : "<>mine.height; cout<<"\nThe size is : "<
More on data types & variables

182

The above diagram should make it clear as to why ‘height’ and ‘chest’ values are always the same. Both are integers, both take up 4 bytes, both occupy the same area, so when the compiler reads the 4 byte integer it will display the same value in both cases. It is up to the programmer to ensure that he operates on the correct data. Again, the reason for the invalid character display should be clear: Once the integer value (for height or chest) is stored and you attempt to read the character value the compiler will read one byte out of the four bytes (which are used for the integer). The main use of unions is when you want to conserve memory space and when you are sure that at any instance you will not require the values for all the elements of a variable. For instance let us say that we have a stockpile of T-shirts in a factory. The computer could maintain a database about the sizes of each T-shirt. The size of T-shirts is either mentioned as small, large and medium or the size is specified in terms of the chest size. Thus every T-shirt will have only one of the two specifications (either a letter or a number). A union is ideal for this purpose.

Passing Structures to a Function If you want to pass an individual element of a structure to an element, you can simply use the dot operator and pass the element. If you want to pass an entire structure to a function, then simply pass the structure variable as an argument. Let’s see an example: struct phonebook { int pin; int tel; }; void disp(struct phonebook p) { More on data types & variables

183 cout<
Recap •

Scope of a variable refers to the region within which the variable exists.

•

A local variable exists only within the block where it is declared whereas a global variable is visible throughout the entire program. Automatic variables will not retain their values whereas static variables will retain their value when program flow exits a function. An array is a collection of logically related variables of the same data type. Array elements occupy contiguous memory locations. Character arrays store strings and has to be terminated by the null character. A structure is a collection of logically related variables of different data types. Nesting of structures is permitted. Enumeration permits the programmer to assign different names to integer constants. A union is similar to a structure but allocates memory space sufficient to hold the maximum data type within the union. It doesn’t allocate space for all the data types.

• • • • • • • •

More on data types & variables

184

Chapters 4 to 6 1.Q) If an array is initialized as shown below: int ar[5]={1,2,3}; What will be the value for ar[3]? 2. Q.)

int ar[5]; What will be the value for ar[3]?

3. Q.) Will the following code work (if it will, what's the output)?: int ar[5]={1,2,3}; for (int i=0;i<5;i++) { cout<
Answer.) A.) Array elements will be initialized to 0. Hence ar[3] and ar[4] will be 0. Answer.) A.) All the array elements will have unpredictable values (commonly called garbage values). Answer.) A.) i[ar] is like writing 1[ar], 2[ar] etc. This is legal and i[ar] is equivalent to ar[i]. Thus the output will be: 12300 Generally this is not used in programs because it can lead to confusion and this is not a good practice. Why this works is explained in Pointers. Answer.) A.) This might seem really confusing. First of all just rewrite the coding as shown below:

struct st1 { struct 4. Q.) In the below structure how can we { access ‘x’? struct st1 {struct{struct{int x;} st2;}

struct { int x;

st3;}y;

} st2; } st3; }y; Now it might not seem all that complicated. To access ‘x’ you should go from the outermost structure to the innermost one (i.e. from ‘y’ to ‘st2’). So we can access ‘x’ by using: y.st3.st2.x

Q&A - Chapter 4-6

185 5. Q.) Can you predict what will happen? # include int main( ) { unsigned int j=2; cout<=0) { cout<
Answer.) A.) The program will run forever because ‘j’ is an unsigned integer and thus it will never become negative.

Answer.) 6. Q.) Can main( ) be recursive?

A.) C++ doesn’t permit the program to call the main ( ) function.

7. Q.) What will happen? int main( ) { int array1[]={1,2,3}; int array2[]={10,20,30}; array2=array1; return 0; } 8. Q.) What is the result of the code given below:

Answer.) A.) You will get a compilation error because you cannot assign arrays using the = operator.

static int x=2; int main( ) { int sum=0; do { sum+=(1/x); }while(0
Q&A - Chapter 4-6

Answer.) A.) A run-time error (divide by zero error).

186 Answer.)

9. Q.) What would be the output for the following code: int main( ) { int i=5; int j=6; int k=7; int result; result = j>k ? 2 : i>j ? 3 : 4; cout<
Answer is 4. Conditional operator has associativity from right to left. Thus start simplifying from the rightmost side of the expression. The conversion would be as below: j>k ? 2 : i>j ? 3 : 4; For the part i>j ? 3 : 4; the result will be 4. Now plug this into the original problem and you will get: j>k ? 2 : 4; The result of this is 4 (because j is not greater than k). Answer.)

10. Q.) What does the code fragment yield: const int SIZE = 5; int array1[SIZE]={1,2,3,4,5}; cout<
In some other programming languages, this notation is used to access elements of a multi dimensional array. But in C++ the expression within the square bracket is evaluated as: 2,3 the result of which is 3 (the comma operator principle is applied here). Thus the equivalent statement is: cout<
11. Q.) int main( ) { int rad; cout<<"\nEnter the radius:"; cin>>rad; if(rad>0) { double area=3.14*3.14*rad; cout<
Q&A - Chapter 4-6

Answer.) A.) Yes. In C++ we are allowed to declare variables anywhere in the code (it is not mandatory that all variables have to be declared in the beginning).

Q&A - Chapter 4-6

187

12. Q.) Explain the following code snippet:

}

switch(choice) { case 'y': case 'Y': cout<<"\nYou entered yes"; break;

A.) This is an illustration of a fall-through switch case. If the value of choice is ‘y’ or ‘Y’, the same set of statements will be executed:

case 'n': case 'N': cout<<"\nYou entered no"; break; default: cout<<"\nWrong choice"; break;

The programmer needn’t code separately for case ‘y’ and case ‘Y’ since in either case the same set of statements have to be executed.

cout<<"\nYou entered yes"; break;

187

More questions (chapters 4 to 6) Interview and Viva questions 1.

2. 3. 4. 5. 6. 7.

8. 9. 10. 11.

Explain the following data structures and distinguish between them: a.) Structure b.) Union c.) Array Why do we need/use functions? What’s the advantage of using a do-while loop? Is it possible to implement a ‘for’ loop as a ‘while’ loop and vice-versa? When do we use a ‘for’ loop and when do we use a ‘while’ loop? What does scope of a variable mean? Distinguish between local and global variables. Explain the following storage types: a.) auto b.) extern c.) register d.) static What does contiguous memory location mean? Give an example of an enumerated data type. How does a ‘const’ variable differ from a macro? Which one is preferable? Give a simple example of recursion. Is an iterative alternative possible for all recursion uses?

Programs Q.) Write a menu-based calculator to perform simple arithmetic operations. (Menu-based means that the user should be presented with a menu from which he/she can choose the operation they want to perform. After an operation is completed the menu should be redisplayed unless the user wishes to exit the program. Hint: use switch-case statement). Q.) Write a program to display whether a given year is a leap year or not. If it is a leap year check whether it is a century leap year (i.e. the year is divisible by 4 as well as by 100). Q.) Write a program to display the following pyramid of stars on the screen (using loops): * *** ***** ******* ********* ***********

188 Q.) Write a program to display the following numerical pyramid on the screen: (similar to the program on pyramid of stars. Instead of stars you will have to print the numbers in proper sequence). 1 232 34543 4567654 567898765 67890109876 Q.) Write a program to get the marks obtained in 6 subjects by a student and calculate his average percentage (remember to obtain the maximum marks possible in each subject also). Q.) Obtain a positive integer input from the user and display all the perfect numbers existing less than the number entered by the user. A perfect number is one whose sum of divisors will equal the number itself. For example 6 is a perfect number because 6 has the divisors 1,2 and 3. 1+2+3=6. Q.) Write a function that can be used to check whether a number is prime or not. Q.) Use loops to obtain the result of the series: x/1! + x2/2! + x3/3! + x4/4! + … + xn/n! where the value of ‘n’ and ‘x’ has to be entered as command line arguments. Q.) Write a program to obtain a string as input and identify whether the string is a palindrome. (For example: a string ‘malayalam’ is a palindrome because the word remains the same if reversed). Q.) Write a program to obtain a word (in a character array) and then display the word backwards. The reversed word should be stored in another character array. Q.) Use a function to rotate an array of numbers. The number of positions to be rotated will be provided by the user. A positive number means that the array should be rotated to the right and a negative number means a left side rotation. For example if the user inputs an array as: 1 2 3 4 and specifies a value of +3 then the resultant display should be: 2 3 4 1. (When rotating to the right the last value should come to the first place in case we exceed the last element). Q.) Write a program to print the numbers from 100 to 1 without using any type of loop statement. Hint: use recursion. Q.) Write a program to obtain the date (as three integer values for date, month and year). The output should display the date, name of the month and the year. The output should also state the number of days in that particular month and whether the year is a leap year or not. For example: if the user inputs the date as 11 10 1980, the output should be:

189 October 11,1980.This month has 31 days. This is a leap year. (Use switch-case to display the name of the month and enclose the switch case within a function so that it can be called whenever needed). Q.) In the above program, provide an option such that the user can enter a certain number of days and the program should calculate and display the corresponding date. Q.) Use looping technique to print the alphabets from ‘a’ to ‘z’ on the screen. (Hint: use ASCII values and type conversion). Q.) Write a program to convert a decimal number into a binary number (keep dividing by two and the remainders will form the binary number). Q.) Using recursion write a program to convert a decimal number into its binary equivalent. Q.) Write a program to store a set of names using arrays (you have to use 2-Dimension character arrays) and display the names. Q.) Write a program to find the greatest among ‘n’ numbers (value of ‘n’ is provided by the user). Use ternary operator. Q.) Create a function which will calculate the number of days between two dates present in the same year (you have to take care of leap years as well). Q.) Modify the above function such that you can find the number of days between two dates in different years. Q.) Create a simple game of Tick-Tac-Toe (also called as ‘X and 0’) made for a user to challenge the computer. The user should have a display similar to the diagram below:

The user will choose a particular square by specifying the corresponding row and column. After the user enters his/her choice, the program should display the new diagram with the corresponding square marked. Once the user makes a move, the computer should make its move.

190 The logic of the game can be improved such that the computer cannot be defeated. Also you could provide an option wherein the user can choose whether the computer should play first or not. (hint: use separate functions for each of the tasks like computer’s move, user’s move, checking for a win after every move, checking for a draw, displaying the diagram after every move etc. These functions can be called from within the main( ) function using looping technique. You could also use global variables).

191

Pointers- an Intro

The following topics are covered in this section: • • • •

Address of a Variable Run time and Compile time Pointers Be Careful

Address of a variable (An introduction to pointers) Before we get into pointers let’s take a real-life analogy. A city consists of a lot of houses. To locate a house you need to have an address (and that address should be unique otherwise we would have lots of confusion). Similarly, computers deal with memories instead of cities. They store data in memory at particular locations. Memory consists of lots of bits. Each memory location can store a byte (8 bits make a byte and it is more logical to consider them as bytes rather than as individual bits). A memory location is like a house, which has a variable (instead of people) residing in it. Actually it is the value of the variable that resides in the house. You may remember that a character requires one byte for storage, an integer two/four bytes etc. Computers use memory addresses to access the memory locations. Pointers are variables that store memory address. This address is usually the address of another variable. All variables are stored in memory locations. Just like a house has a unique address, every memory location will have its own address. In computers the address is a hexa decimal number. For example: 0X8566fff4 is a hexadecimal number representing an address. Hence when we say that values of variables are stored in the computer, we actually mean that the value has been stored in a particular address. When we write: int x=5; we might be thinking that ‘x’ is physically having a value of 5. In reality, ‘x’ will correspond to some memory location and it is in this location that the value 5 is stored (5 is stored in a binary format and not as a decimal number). This is why a variable is sometimes defined as a named memory location. It is more convenient for us to work in this way (a programmer cannot be expected to know the addresses where variables are allocated memory). So, how do we find out the address of a variable? The ‘address of’ operator is denoted by ‘&’.

Pointers

192 This can be applied to any variable as illustrated below: #include int main ( ) { int var=100; cout<<"Value : "<
// The output will be 6 // Output will be the address of var

The output would be: Value : 100 Address : 006AFDF4

Pointers Pointers are variables that store memory address. This address is the address of another variable. Hence a pointer points to another variable. Declaring a Pointer: Syntax: data-type *name-of-pointer; When * is used in declaration statements, it denotes a pointer. The data type denotes the data type to which the pointer points. Let's see an example: int main( ) { int marks = 70; // marks is an integer int * p; // p is a pointer p = &marks; // p points to marks cout<<"\nAddress is : "<
Pointers

193 In this context * is known as a de-referencing or indirect value operator. This operator will give the value stored at a particular memory location (in other words it will give the value stored at a particular address). It is the complement of the ‘&’ operator. Hence, *p means value at p (which holds address of marks). The output of the program is: Address is : 006AFDF4 Value at that address is : 70 To summarize: •

we can say that * means 'value at the address'.

•

Both the operators * and & can be considered as pointer operators.

The figure below should make the concept of the program very clear to you:

Everything is stored in memory. So what about the pointer itself. A pointer stores an address; but where does it store it? The answer can be found in the above figure. The pointer itself has a memory address where it stores the address of the variable that it points to. Confusing? Basically, the pointer has an address where it stores another address. In the earlier program, if you type the following code: cout<<&p; You will get the result as 006AFDF0. That is the address of the pointer itself.

Pointers

194 This brings to view another point. The difference between pointers and a general variable is that address is primary for pointers. The value stored at the address is secondary. For other variables, the value is primary while the address where the value is stored is secondary. If you want to find the value of ‘marks’ you would just write: cout<
Be careful with Pointers This section deals with some of the mistakes that can be committed using pointers. 1.) Make sure that your pointer variable points to the correct type of data. If you declare a pointer of type integer then make sure that the address it holds contains an integer. float y = 6.6; int * p; p = &y; float.

// y is a float quantity // p points to an integer type // Wrong - p is supposed to point to an integer but y is a

2.) Be careful while making multiple pointer declarations. Suppose you want to declare two pointers: p1 and p2 that point to an integer data type. You might be tempted to write the declaration as: int * p1, p2; Seems right, doesn't it? This declaration is wrong. This will declare p1 as a pointer pointing to integer type. The compiler will consider p2 as an integer and not a pointer. Since * precedes p1, the compiler considers only p1 as a pointer. Hence be careful while declaring pointers.

Pointers

195 3.) A pointer should store an address. Consider an extract from a program given below: int *p; *p = 82;

// marks is a pointer that points to data type long. //wrong

Note the point that we have not yet stored any memory address in marks. When a pointer is created the compiler will allot memory to hold an address. It will not allocate memory to hold the data to which the address points. Perhaps it's a bit confusing. The problem with our program is that we are supposed to store an address in p. After storing an address in p you can then store some value at that address. What we have done is that we haven't assigned any address to p. Without an address you can't store a value. Hence the value 82 cannot be placed anywhere. A pointer which is not initialized is called a ‘dangling pointer’. 4.) Pointers are not the same as integers. Pointers hold a memory address and hence they cannot be multiplied or divided. Pointer addition will be discussed later. 5.) Not advisable to assign a memory address on your own (unless you are really sure of what you are doing). Consider the following: int * p; p = 006AFDF4;

//Correct //wrong

A pointer stores a memory address. So you may think that the second line is correct. We have assigned a hexadecimal number to p (which is a pointer). The problem is that the compiler doesn't know that 006AFDF4 is a memory address. You may get an error message saying ‘data type mismatch’. Instead you can write it as: p = (int * ) 0x006AFDF4;

// This is correct.

This is correct because we are forcibly telling the compiler that this is a memory address (you’ll learn about forcing in the section on ‘casting’). 6.) Some programmers prefer to initialize a pointer to NULL. NULL is a predefined constant with a value of 0. When initialized to null, the memory address stored in the pointer will be: 0x00000000. The code below will compile but it is an erroneous code: int *p; int a=5; cout<<*p;

Pointers

// value displayed is 910569528

196 In this code, the pointer ‘p’ hasn’t been assigned the address of ‘a’. ‘p’ will have some random memory location and reading the value at this location produces a garbage value. Programmers thus prefer to use: int *p=NULL; int a=5; cout<<*p; This code will generate an error when it is run in your computer because ‘p’ is pointing to the location 0x00000000. 7.) Potential hazards of using uninitialized pointers: There are instances when a programmer declares a pointer and forgets to initialize it. Later in the code the programmer uses this pointer and this can lead to serious errors. Since the pointer has some unknown address value, when we dereference such a pointer we cannot predict what will be the value. A bigger problem might arise if you attempt to change the value stored at that address. For ex: int *p; *p=5; In this case, the value at an unknown location will get changed to 5. This particular memory location could actually be some other variable in your program. Thus indirectly you would have changed the value of another variable and it will become difficult to trace the problem.

You may be wondering why we need to tell the compiler as to what type of data a pointer is going to point to? A pointer just holds an address, so why do we need to specify the data type pointed to? The problem will occur when you make use of the dereferencing operator to get the value stored at the address. If a pointer points to a character, then the compiler knows that when we dereference the pointer it should only read one byte. If the pointer points to a short int the compiler knows that it has to read 2 bytes and so on. If we didn’t specify what data type the pointer will point to, then the compiler has no idea as to how many bytes it should read when dereferenced. And if we never dereferenced a pointer then we’d never know what is stored at a particular memory address! What’s the difference between: int *ptr; and int* ptr;

Pointers

197 It is a matter of choice. Some programmers prefer the first one while you may frequently encounter the second type of declaration. The advantage of using the first method is that you are less likely to commit the mistake of declaring a pointer and an integer in one statement. Ex: if you want to declare to pointer ptr1 and ptr2, it is less likely to type int *ptr, ptr2; Pointers Use whichever method you are comfortable with.

198

More Pointers - II

The following topics are covered in this section: • •

Arithmetic operations on Pointers Pointers and Arrays

Arithmetic operation on Pointers You can't perform multiplication and division on pointers but you can do addition and subtraction on pointers. Suppose that p1 is a pointer that points to an integer and the address is 100 (yes, addresses will usually be a larger hexadecimal number but assume 100 as a memory address for simplicity). Also assume that an integer occupies 4 bytes. Now if we say: p1++ ; what would the above expression do? The value of p1 (i.e. the address pointed to by p1) gets changed. The address becomes 104 not 101 because an integer occupies 4 bytes. If an integer occupied 2 bytes then the result would be address 102. Similarly if you do: p1--; the address of p1 will be 98. Hence, when a pointer is incremented it points to the memory location of the next element of its data type. Similarly you could say the following: p1 = p1 + 10; This makes p1 point to the tenth element of p1's data type beyond the current position. If p1 points to a character type then p1 + 10 would move the pointer 10 bytes. Suppose p1 were a integer then p1 would move 20 bytes (if int occupies 2 bytes). Can we add two pointers? Addition of two pointers is not allowed. It doesn’t make logical sense to add two pointers because you won’t know what the new address will be. You’ll get a compiler error if you attempt to perform such an operation. But subtraction of two pointers is allowed since this will give you the number of elements lying between the two addresses. You can use pointers to find the size occupied by a data type (i.e. without using the sizeof operator) as shown below:

Pointers

199 long int i; long int *ptr; ptr=&i; cout<
//ERROR

would cause an error saying that a pointer can only be subtracted from another pointer (or you’d get the message: Illegal pointer subtraction). Assignment Operator with pointers: Whenever we make use of pointers in a program we should be careful about what we are dealing with (i.e. are we wanting to refer to the memory location or do we want to use the value stored at that memory location). Consider two pointers, p1 and p2 (both pointing to integer data types). p1=p2; *p1=*p2; In the first case, both p1 and p2 will now point to the same memory location. But in the second case only the value stored at the location pointed by p1 will change (i.e. the address will not change). Similarly,

if (p1 == p2) and if (*p1 == *p2)

are completely different. In the first case we are checking whether both pointers contain the same address while in the second case we check whether the value contained at the memory location pointed by them is equal.

Pointers

200

Pointers and Arrays Arrays can be accessed using pointers instead of their index numbers. Consider the following program: int main( ) { int marks[3]; int* p; p = &marks[0]; // Pointer points to the first element of array. marks[0]=58; marks[1]=61; marks[2]=70; cout<
Pointers

201 Well, a pointer of type integer (like ‘p’ that was declared above) can point to any integer variable. ‘p’ can point to any other variable (as long as the variable is an integer type). But the array is constant. Whenever you use the array name, it will only refer to the same array. This means that the array is similar to a constant (it remains the same) and in fact it is sometimes called a constant pointer. Thus in the previous example: p = marks; is correct because pointer ‘p’ can take different values but marks = p; is invalid because ‘marks’ is like a constant pointer (value cannot be changed). We refer to an array value by indexing: marks[2]=70; using pointer we can write it as: *(p+2)=70; but even indexing in pointers is allowed: p[2]=70; is also a valid statement. Remember: *(p+2) is 70 but *p + 2 will not be 70. Since * has a higher operator precedence than +, the result of *p + 2 will be 58 + 2 (assuming that *p has a value 58). When using pointers to access array elements ensure that you use the parentheses. Similarly it is not that only the pointer should be called by using the * operator. Since an array is also like a pointer, the following: marks[1] = 61; is the same as: *(marks+1) = 61;

Pointers

202 Beware: Don’t confuse the de-reference operator (*) with the same * that is used to declare a pointer. Though they both seem the same, they are totally different in function; one is to declare a pointer and the other is to access the value held at that particular address. int j; int* p = &j; j = 5; cout<<*p; The above piece of coding is correct because we are initializing the pointer ‘p’ to the address of the variable j. Try this: int* p=5; Absolutely wrong! Cannot assign a value to ‘p’. Consider a modification of the above program. #include int main( ) { int marks[3]; int* p; p = &marks[2]; // Pointer points to the third element of array. marks[0]=58; marks[1]=61; marks[2]=70; p = p-1; //pointer decrements by one, goes to the previous integer address cout<
Pointers

203 We had discussed earlier about passing arrays to functions earlier and you can use any one of the following methods: void disp(int a[ ] ) or: void disp(int a[3] ) Now you should have understood as to how the above two methods really work. In effect we are actually passing the address of the array to the function. Thus you could also pass a pointer to a function (of course the pointer should have the address of the array). See the example below: #include void clear(int *point, int size) { for (int i=0;i
Pointers

204 Instead of: clear(p,3); you could even have used: clear(marks,3); This would have also worked perfectly well because ‘p’ and marks mean the same thing. Another modification you could have done is to change the function syntax to: void clear(int m[ ],int size) { for (int i=0;i
Pointers

205

Pass by value and pass by reference (and reference variables) Pass by value and Pass by Reference We have seen as to how to pass values to a function through arguments. Actually there are two ways to pass values to a function through arguments. These two methods are explained below with examples.

Pass By Value: Example:

void check (int x) {//body of function } int main ( ) { int b = 10; check (b); }

In this function, ‘x’ is a parameter and ‘b’ (which is the value to be passed) is the argument. In this case the value of ‘b’ (the argument) is copied in ‘x’ (the parameter). Hence the parameter is actually a copy of the argument. The function will operate only on the copy and not on the original argument. This method is known as PASS BY VALUE. So far we have dealt only with pass by value (except when passing arrays to functions). // Pass by value illustration #include int square (int x) { return x*x; } int main ( ) { int num = 10; int answer; answer = square(num); cout<<"Answer is "<
Pointers

206 You can see that the value of ‘num’ is unchanged. The function ‘square’ works only on the parameter (i.e. on x ). It does not work on the original variable that was passed (i.e it doesn't work on ‘num’).

The diagram makes it quite clear as to what happens when we call square(num). The following initialization takes place: int x = num; and the function square( ) operates only on a copy of num.

Pass By Reference In pass by reference method, the function will operate on the original variable itself. It doesn't work on a copy of the argument but works on the argument itself. Consider the same square function example: // Illustration of pass by reference #include void square (int *x) { *x = (*x) * (*x); Pointers

207 } int main ( ) { int num = 10; square(&num); cout<<" Value of num is "<
Pointers

208 This is the pass-by-reference method which was used in C. In C++ there is a different approach. Of course you can use the above method, but C++ has its own special way.

C++ style of Pass by Reference In the C style we have seen that you need to make use of & and lots of * symbols to pass-byreference. In C++ we make use of the ‘reference parameter’ (or reference variable) and can avoid the use of so many symbols. All you need to do is put & before your function's parameter. Example: void square (&x) Whatever operation is done on x will actually affect the original calling argument. Basically ‘x’ can be said to be an implicit pointer. The difference is that you needn't use *x to operate on the parameter. Consider the same example: // Pass by reference C++ style example void square ( int &x ) { x = x * x; }

// x becomes a reference parameter //no need to write *x = (*x) * (*x); as we did earlier

int main ( ) { int num =10; int answer; square(num); earlier cout<<" Value of num is "<
// No need to say &num as we did // Value of a is 100

The line x = x * x ; actually operates on ‘num’ and not on a copy of ‘num’. When the C++ compiler sees that a function has been declared with its arguments having ‘&’, it knows that the function is a pass-by-reference type.

Pointers

209

More about reference variables Reference variables are not applicable only to function parameters. You can have them in other places of the program as well. Consider the following program: #include int main( ) {

int x; int &ref = x; //ref is a reference variable x=5; cout<
•

•

•

Usually reference variables will only be used with respect to functions (using them as shown in the program above can lead to confusion). Passing by reference is especially useful in passing structures and objects to functions. In the case of structures, if you use pass-by-value, memory space will be used up to create a copy of the structure within the function. Passing the structure by reference will avoid this overhead. In the case of classes, if you pass an object by pass-by-value you will be invoking an extra destructor (because a copy of the object is made). In passing an object by reference we can avoid this problem (this will be discussed later). References can also be returned by functions (dealt with in operator overloading and in streams).

Pointers

210 Can arrays be passed by value? When we pass arrays to a function we are actually passing the address of the first element of the array. This is as good as passing a pointer to the function. Thus the function will be directly operating on the original array and not on a copy of the array. There is no way of creating a function which when called will operate on a copy of the array (unless you create a new array within the function and manually copy the elements from the original array to the new array).

Test yourself on Pass by Reference This section is intended to make sure that you've understood pass by reference. Write a C++ program to get two numbers from the user and swap the values using a function. You have to do it using reference parameters. The solution will be as follows: #include void swap (int &x, int &y) //pass by reference { int t; t = x; x = y; y = t; } int main ( ) { int a , b; cout<<"Enter the value for a : "; cin>>a; cout<<"Enter the value for b : "; cin>>b; cout<<"a and b before swap are : "<
Pointers

211

More on references •

Reference variables are aliases (an alternate name to a variable). int x; int &ref=x;

//we tell the compiler that ‘ref’ is another name for ‘x’

Working on ‘ref’ is the same as working on ‘x’ and vice-versa. But since a reference variable is an alias, we should initialize the alias. int x; int &ref;

//ILLEGAL reference variable should be initialized.

This makes sense because an alias should be an alternate name for something (and we need to tell the compiler what that something is).

Pointers

212 •

Non-const references should be initialized using L-values (i.e. using something which is permitted on the left hand side of an assignment expression). int &ref=5;

//ERROR

This is an error because ‘5’ is an integer constant and it is not an L-value (we cannot use 5 on the left side of an assignment). Logically speaking also this isn’t possible because a reference variable is an alias (you use an alias instead of another name). One might argue, “instead of the constant 5, I intended to use the term ref”. But when we think from the viewpoint of the compiler, we can understand the complications involved if this were permitted. Let’s say this statement was legal. Now (though the programmer might not purposely do it), there is nothing to stop the programmer from coding: int &ref=5; ref=10;

//ERROR (but let’s assume this is permitted)

What now; where is the new value of 10 supposed to be stored? (there is no location for it). But if we use a const-reference: const int &ref=5;

//Permitted

the compiler won’t complain. The reason is that now we tell the compiler, “This is a const reference and in case I attempt to assign any values to it then you can flag an error”. The compiler feels reassured and it will permit the use of ‘ref’ instead of 5. Note: For the above purpose, it would be more clearer and effective to use const int ref=5; (since we are not really making use of any functionality of a reference variable). •

We have seen that passing by reference is similar to passing a pointer (as was done in C programming). In fact reference variables and pointers are quite similar. You might wonder, “why not use pointers itself?”

When passing a pointer, the function definition will be cluttered with a lot of dereferencing. Passing pointers (C style) void square (int *x) { *x = (*x) * (*x); }

Passing by reference void square (int &x ) { x = x * x; }

The code is clean and reader-friendly when passing by reference.

Pointers

213 •

We can use the ‘const’ keyword in reference parameters to ensure that the function doesn’t modify the argument. For example: //Function won’t modify the argument void print(const int &x) { cout<
//compiler error

is an error. The compiler will complain saying, “you are attempting to modify the value of the constant reference ‘x’”. •

Same address: int x; int &ref=x; cout<
//address of ‘x’ //address of ‘ref’

Both addresses will be the same (which is why working on ‘x’ is the same as working on ‘ref’).

Pointers

214 •

We can return references from functions but beware.

int& dummy( ) { int x=5; return x; } int main ( ) { cout<
Pointers

215

More Pointers - II The following topics are covered in this section: • • •

Returning pointers from functions Run Time and compile time Dynamic Allocation

Returning pointers from functions You can return pointers (or arrays) from functions. The syntax to declare a function which will return a pointer is: return-data-type* function-name (pararmeters); For example: int* create ( ); This is to declare a function called create ( ) that will return a pointer to an integer. Check out the example given below: #include int* create( ) { int marks[3]; int *pt=marks; for (int i=0;i<3;i++) { marks[i]=80; } return pt; } int main( ) { int *p; p=create( ); cout<
216 The output is: The marks are : 80 80 80 As you can see, we return ‘pt’ (which is a pointer to an integer) from the function. This is like returning an address from the function. There is nothing special about returning pointers from functions but you have to be careful with the syntax for the function header.

Run-time and Compile-time The concept of OOPs (Object Oreinted Programming) makes emphasis on making decisions during run-time rather than at compile-time. Run-time is the time when someone runs your program. Compile-time is the time at which you compile the program. To differentiate between run-time and compile-time let's take a real life example. Let us suppose that tonight you decide you are going to walk to office tomorrow. You decide that you will start from home at 7:30am. You have decided these two things at night itself. This is similar to compile-time. Decision is taken before the time of action. Now in the morning, you start from home as decided at 7:30. You walk and on the way someone, your girlfriend or boyfriend, comes in a car. They stop beside you and offer to give you a lift to your office. You had initially decided to walk but suddenly change your mind. Why walk all the way to office? Maybe I could walk tomorrow. You step into the car and reach office. This was a run-time decision. You decided on the spot during the time of action. Coming back to C++, run-time decisions provide more flexibility to adjust. As you can see, in real-life, most of us prefer to take decisions depending on the situation that arises instead of fixing a plan earlier. We take decisions on the spot instantaneously and in C++ this can be illustrated with an example. For example: in a program that makes use of an array for storing a series of numbers, you may declare an array of 20 elements. But sometimes the user may want to enter more elements. Hence you may declare an array of 200 elements. The compiler will allocate memory space for all the 200 elements during compile time itself. But your user may not always make use of the 200 elements. Sometimes it may be 10 sometimes 50. By declaring 200 elements the space allocated to the unused elements is a waste. It would be better if we could decide on the size of the array during run-time (i.e. when the user runs your program rather than fixing the size when you write and compile the program). According to the user’s preference the program could allot the required space for the array. This is a compile-time decision and this can be implemented through pointers, as we shall see later.

Pointers

217

Dynamic Allocation Whenever you declare variables required amount of space is allocated for them in the memory. But there are certain instances when we might not be able to predict how much space might be required when the program executes; it may depend on the user. Suppose that you want to write a program to get the marks from the user and display the entered values. You do not know how many marks the user will enter (it could be for 2 subjects or for 8 subjects). So, you might write the following code: # include int main ( ) { int size,i; cout<<"Enter the size of the array : "; cin>>size; int marks[size]; //WRONG cout<<"\nEnter the marks: "; for (i = 0; i>marks[i]; } cout<
Pointers

218 also illustrate the difference between compile-time and run-time. So, how to overcome this problem? Simple. You could give the variable ‘size’ some value to start with. Replace: cout<<"Enter the size of the array : "; cin>>size; with: size=4; Now everything should be fine. Is it so? Try it and you’ll get the same compiler error. The compiler reads and stores the value of 4 for ‘size’ but it still will not substitute that value in: int marks[size]; The compiler assumes that ‘size’ is a variable (since it was declared like that) and since a variable’s value can change in the program, it will not compile the code. One way to correct this is by declaring the maximum size of the ‘marks’ array by saying: int marks[4]; //program will compile There is no need for the variable ‘size’ and the user can enter only a maximum of 4 values because that is the space allocated for the array ‘marks’. Another way to correct the program is to declare the variable ‘size’ as a constant. const int size=4; Now you can use: int marks[size]; The reason that this is valid is because the compiler makes note of the fact that ‘size’ is a constant and has been given a constant value 4. Since this value will never change in the program and space will be allocated for 4 elements in the array ‘marks’. C programmers made use of macros (instead of ‘const’): #define SIZE 4 to define constants. When the compiler comes across the term ‘SIZE’ anywhere in the program it will simply substitute the value of 4 for ‘SIZE’. But whatever you do, the compiler limits you to fixing the size of the array at compile-time. Can you decide the array size at run-time? Dynamic allocation comes to the rescue.

Pointers

219 Dynamic allocation means allocating (or obtaining) and freeing memory at run-time. There are certain cases where run-time decisions are better. For example, deciding the size of an array. Similarly you can free up allotted memory in your program when you don’t need a particular array by deleting the entire array itself. The two operators used for this purpose are: ‘new’ and ‘delete’. ‘new’ is used to allocate memory while ‘delete’ is used to free the allocated memory (memory which was allocated by ‘new’). The free memory available is sometimes referred to as the heap. Memory that has been allocated by ‘new’ should be freed by using ‘delete’. If you don't use ‘delete’ then the memory becomes a waste and cannot be used by the system. This is called memory leak (i.e. when allocated memory is never returned to the heap). You could go on taking memory from the heap till it gets exhausted. This will lead to memory leak and can cause problems to your program and to other programs which attempt to take memory from the heap. The syntax is: data-type * name = new data-type; delete name ; Beware: Both data types should be the same. Example: int * p = new int; delete p; Remember: delete p; means that the data pointed to by ‘p’ is deleted. The pointer ‘p’ will not get deleted. The following coding is correct: int m = 20; int *p = new int; *p=5; cout<<*p<
Pointers

220 int main ( ) { int size,i; cout<<"Enter the size of the array : "; cin>>size; int *marks = new int[size]; cout<<"\nEnter the marks: "; for (i = 0; i>marks[i]; } cout<
Pointers

221

More Pointers - IV

The following topics are covered in this section: • •

Pointers to Functions Some pointer declarations

Pointers to Functions You can even create pointers that point to functions. The primary use of such pointers is to pass functions as arguments to another function. You have to be very careful while declaring pointers to functions. Take note of the position of the parentheses: return-data (*pointer-name) (arguments); We’ll write a simple program to add two numbers. For this purpose we shall define a function called sum( ). This function sum ( ), will be passed to another function called func( ) which will simply call the sum ( ) function. #include int sum(int a, int b) { return (a+b); } void func(int d, int e, int (*p1)(int,int)) { cout<<"The result is : "<<(*p1)(d,e); } int main( ) { int (*p)(int,int); p=sum; func(5,6,p); return 0; } The output is: The result is : 11 Though the program is simple a few statements might appear confusing. The statement int (*p) (int,int);

Pointers

222 declares a pointer to a function that has a return value of integer and takes two arguments of type integer. sum( ) is a function with return data type of integer and also with two arguments of type integer. Hence the pointer ‘p’ can point to the function sum ( ). Thus we assign the address of the function sum ( ) to ‘p’: p = sum; We’ve also defined another function called as ‘func ( )’ which takes two integer arguments and a third argument which is a pointer to a function. The idea is to pass the function sum ( ) to the function ‘func( )’ and call the sum ( ) function from func ( ). func(5,6,p); will call the func ( ) function and it will pass pointer ‘p’ to func ( ). Remember that p is a pointer to sum ( ). Hence in reality we are actually passing a function as argument to another function. Let’s expand the program one step further by creating another function called product( ) which will return the product of the two arguments. #include int sum(int a, int b) { return (a+b); } int product(int x,int y) { return (x*y); } void func(int d, int e, int (*p1)(int,int)) { cout<
Pointers

223 The output is: The result is : 11 The result is : 30 The program is very similar to the previous one. I just wanted to illustrate that you can pass any function to func ( ) as long as it has a return type of integer and it has two integer arguments. Practical use: You might be wondering why we’d need to pass functions as arguments to other functions. There are instances when you might create generic functions, which the user can tailor to suit his/her needs. For example: Signal handling functions usually contain a function as one of their arguments. These functions are used in a program to react to certain external events- for example if the user presses CONTROL+C keys, the default action is for the program to terminate. But you might write a program in which you want to print “YOU CAN’T TERMINATE THIS PROGRAM” every time the user presses CONTROL+C. To perform this there are standard signal handling functions. These functions generally take the following 2 arguments: 1.) The signal for which you want your program to react (CONTROL+C is just one of the possible signals your program might receive). 2.) The function which has to be performed when your program receives that signal. The function might be something like: int sighandler (int sig, pointer-to-function); All the user needs to do is decide what signal he wants to handle and then decide on the function he wants to perform in case that signal is received (there’s no need to rewrite the entire signal handling function for his application; which would be time consuming. Programming is all about reusing code rather than rewriting). Can you think of any other simpler way in which a generic function like sighandler can be created?

Pointers

224

Pointer Declarations Pointer declarations are a bit confusing. Read through the various declarations described below to clear your doubts: Declaration

What it means

int *p;

pointer to an integer

void p(char *str);

function that accepts a pointer to a character

int (*p)(char *str);

pointer to a function that accepts pointer to character as argument and returns an integer.

int *p(char *str);

p is a function that accepts pointer to character as argument and returns a pointer to integer.

int *p[5];

p is an array of pointers to integers

int (*p)[5];

p is pointer to an integer array of 5 elements

void (*p)(char (*str)[] );

pointer to function that accepts pointer to character array

The list can be made more complicated but this should be sufficient to understand how pointers are generally declared. A couple of declarations are pretty interesting: int *p[5];

-

p is an array of pointers to integers

int (*p)[5];

-

p is pointer to an integer array of 5 elements

The subscript operator has a higher precedence over * in the above declaration. So if we say: int *p[5]; the compiler will create an array of pointers. To forcefully evaluate *p first, we use the parentheses and declare: int (*p)[5]; Now the compiler considers ‘p’ as a pointer and so this means that ‘p’ is a pointer to an array of integers.

Pointers

225

More Pointers - V

The following topics are covered in this section: • • • • •

Pointers to Structures Multiple indirection Pointers to constants Constant Pointers Void Pointers

Pointers to Structures This is similar to creating pointers of other data types but you should know how to access structure elements through pointers. struct phonebook { int pin; int tel; }; int main( ) { phonebook record[2]; phonebook *p; p=record; //Points to record[0] p->pin=60004; p->tel=23451; p=p+1; //Now points to record[1] p->pin=50023; p->tel=89732; p=record; cout<pin; cout<tel; p=p+1; //Points to record[1] cout<pin; cout<tel; return 0; }

Pointers

226 The output is: The pincode is : 60004 The tel. no. is : 23451 The pincode is : 50023 The tel. no. is : 89732 You’ll notice that to access the individual elements we have made use of different operators. When you use pointers, you should not use the dot operator. Instead we make use of the arrow operator (->). p->pin=60004; Actually, the dot operator (or the member operator) can be used but you have to be careful about operator precedence. To use the member operator we’ll have to dereference the pointer and then use it. The following expression: *p.pin would be wrong. The dot operator is a post-fix operator and it has higher precedence over the dereferencing operator (which is a pre-fix operator). So to set it right we will have to use: (*p).pin Thus we could also have used the following code in our program: cout<
Pointers

227

Pointer to Pointer (Multiple Indirection) In C++ you can create a pointer that will point to another pointer. In fact you can even create a pointer that points to a pointer that points to a pointer. But here we shall only deal with the case of a pointer that points to another pointer (the same concept can be extended to other cases). The figure below should make the concept clear. Let ‘marks’ be an integer variable (let us assume that an integer occupies 4 bytes of memory). int *p; int marks=80; p=&marks; int **p2; p2=&p; Thus p2 is a pointer which points to a pointer of type integer (i.e. p2 points to ‘p’).

The pointer p2 can be used for two purposes: • •

p2 can be used to refer to the address of ‘p’ p2 can also be used to access the value of marks.

If you want to access the value of marks through p2 then you can type: cout<<**p2; //result will be 80 (which is stored in ‘marks’)

Pointers

228

Pointer to constants: When a pointer points to a constant term, the pointer cannot modify the value of the constant term. The declaration of a pointer to a constant is as follows: const data-type *pointer-name; Example: const int num=20; const int *ptr; ptr = # •

The address of a constant cannot be assigned to a pointer unless the pointer is declared as pointing to a constant. The following is incorrect: const int num=20; int *ptr; ptr=# //Error (pointer not declared as pointing to a constant)

•

A pointer to a constant cannot be assigned to a non-constant pointer.

const int num=20; const int *ptr; ptr=# int *ptr2; ptr2=ptr; //Error because ptr2 is a pointer to a non constant •

The code fragment below is correct: const int num=20; const int *ptr; ptr=# const int *ptr3; ptr3=ptr; //Correct because ptr3 is a pointer to a constant

Thus you can use pointers to constants as function parameters if you do not want the function to modify the argument. ¾ The following is fine: const const ptr ptr++;

int int =

num=20; *ptr; #

//no problem

The pointer ‘ptr’ itself is not a constant (which means that we can change the value held in ptr at any time).

Pointers

229

Constant Pointers: A pointer, which is declared to be a constant, cannot be changed after initialization. Thus it will always retain the same value. Syntax for declaration: data-type *const pointer-name = address; The constant pointer has to be initialized and this value will be retained throughout the program. For example: int num = 20; int *const ptr = # //constant pointer initialized to address of num. You cannot try to increment the pointer: ptr++; because ptr is a constant pointer and it’s value cannot be changed. You’ll get a compiler error saying “L-value is a constant”. But: cout<<*(ptr+1); is correct. Why? In this case we are only displaying the value stored at the next memory location; we are not trying to change the value held in ‘ptr’ (of course, this will produce some garbage value). The following code fragment is incorrect: int num=20; int *const ptr; //has to be initialized here itself ptr=#

Void Pointers If a pointer is declared as pointing to void then it can point to any data type. The syntax for declaring a void pointer is: void *pointer-name; For example: int num=20; double db=1; void *ptr; ptr = # ptr = &db;

Pointers

230 In the above code fragment the void pointer ‘ptr’ is first assigned the address of an integer and then assigned the address of a double quantity. Though you can assign any data type you cannot attempt to access the value using the dereferencing operator. The following code will produce errors: int num=20; double db=1; void *ptr; ptr = # ptr = &db; cout<<*ptr; //Error – cannot use * to access value stored. Also you cannot try to assign a void pointer to a pointer of some other data type. Pointer arithmetic is also not allowed in void pointers. If a function can operate on any kind of data type then the void pointer can be used (for example: the operator ‘new’ when overloaded will have a void pointer as its argument because this operator can work with any data type).

Pointers

231

More Pointers - VI

The following topics are covered in this section: • •

Pointers to characters Pointers Demystified (2-D arrays and pointers)

Pointer to Characters: Check out the following code: int main( ) { char *name = "Tintin"; cout<
232 When individual characters are assigned to a character array, it is the responsibility of the programmer to include the null character. In the above example we haven’t assigned a null character and thus the resultant output will contain garbage values: Tintin¦¦8_e Strings are constants and you cannot modify them after initializing them. Thus the following code will produce an error: char *name = "Tintin"; *name="h";

//COMPILER error

The reason is because the right hand side is a char[2] (the letter h and the null character). In other words you cannot assign a string to a character (*name can only hold a character since it is a pointer to a character data type). So, we could try the following: char *name = "Tintin"; *name=’h’;

//Run Time error

Now the compiler is satisfied with what you’ve done. Why? Because ‘name’ points to a character and you’ve asked the compiler to store a character at that memory location. The two types match and the compiler gives the green flag. But when you execute the program, it will crash because of a run-time error. Why? Because a string in memory is a constant and you are not supposed to change the value. To prevent such bugs from creeping into your code, it is a good idea to use the keyword const: const char *name = "Tintin"; *name='x';

//Compiler error

Now you’ll get a compiler error because the compiler has been informed that ‘name’ is pointing to a constant and thus it shouldn’t be able to modify the data it holds.

Pointers

233

Pointers Demystified: Before getting into pointers lets refresh our memory on a few important concepts: •

Variables are actually named memory locations.

•

When we ask for a variable value, the program has to access the memory address and retrieve the value stored there.

•

The same concept applies to arrays as well.

•

Arrays are stored contiguously (i.e. in consecutive memory locations).

Now, let’s go a bit deeper into pointers now that we are familiar with the basic concepts. We’ll again take up our discussion on pointers and arrays. Consider the following code snippet: short int marks[5]; //some assignments cout<
Pointers

234 Case I Sometimes, when you are dealing with arrays it might be a good idea to use the pointers to access elements rather than using array indexing. The pointer method might improve the performance. Let’s take a simple example: int main( ) { short int marks[5]={80,70,60,75,90}; int i; short int *ptr; ptr=marks; cout<
80

70

60

75

90

Using pointers:

80

70

60

75

90

Rather than the output we need to focus on the difference between the 2 methods used. In the first method we used array indexes to display the value of each element: for (i=0;i<5;i++) { cout<<"\t"<
Pointers

235 In this way the program calculates the address and retrieves the value stored at that location. You might wonder what’s the problem in this? Let’s take a look at the second method, using pointers: short int *ptr; ptr=marks; for (i=0;i<5;i++) { cout<<"\t"<<*(ptr++); } ‘ptr’ is a pointer which initially holds the address of the first element of the array marks. The first time the program enters the for loop, it will display the value of the first element of the array. Then ‘ptr’ is incremented. Incrementing ‘ptr’ is equivalent to: ptr = ptr + sizeof(short int) Each time the program executes the loop it has to move the pointer to the next element using the above equation. The difference in array indexing and pointer referencing lies in the 2 equations. In the array indexing method the program has to perform a multiplication whereas in the case of pointers this is not required. By using the second method we can improve performance (speed of execution) because multiplication needn’t be performed (and multiplication is generally a time consuming operation for computers). In small programs you may not notice much of a difference but when you are dealing with larger data types this could cause a significant improvement. Case II But this doesn’t mean that using pointers instead of array indexing will always improve performance. It all depends on the situation (just try to think of the problem from the compiler’s point of view). For example, let’s say we have an array: int salary[10]; int id; Later in some part of the code we have the statement: cout<<”Enter the employee ID:”; cin>>id; cout<<”Salary of that employee is:”<
Pointers

236 The following: marks[2]; and *(marks+2); are actually the same. When we say marks[2] the compiler would internally convert it into *(marks + 2). The following code snippet should clarify your doubts: int weights[4]={10,20,30,40}; int *ptr=&weights[0]; cout<
Two-dimensional arrays and pointers: Let us say that we’ve declared a 2-D array: int marks[4][2]; Though we feel that this array is similar to a tabular structure, we don’t have tables in memory. Array elements are stored contiguously in memory (irrespective of whether it is a one dimension or multi-dimensional array). We refer to the 2 dimensions as rows and columns (the first square bracket denotes the row and the second denotes the column number) but as far as the computer is concerned, all the elements are just stored continuously in memory. So, how would the array marks[][] be stored in memory?

Pointers

237

Thus, the first row elements are stored first, followed by the second row elements and so on. When we refer to an element as: marks[3][1] the program has to calculate the address of the element to retrieve the value. The address of marks[3][1] = base address of the 2-D array + offset This is similar to what we saw for 1-D arrays. Base address of the 2-D array = address of marks[0][0] and offset = (number of columns * element’s row number) + element’s col. number In our case: offset (in terms of the number of elements) = (2 * 3) + 1 To obtain the offset in terms of bytes, just multiply the above value by sizeof(short int). The concept might seem confusing at first but once you substitute some values you should be able to grasp the idea. So, how do we refer to 2-D array elements using pointers? A 2-D array is a pointer to an array of 1-D arrays. If we declared an array as: marks [4][5] then when we say mark[0] we are referring to the first row. mark[1] will point to the second row and so on. Let’s take this one at a time. A 2-D array is a pointer to an array of 1-D arrays. In our example, each row of the array contains 5 elements. These 5 elements form the set of 1-D arrays. Thus each 1-D array will make up a row of our original array. If we use: marks[0]

Pointers

238 it is equivalent to marks and it contains a set of elements (the elements are the individual rows: marks[0], marks[1] etc.). marks[0] is an array with elements marks[0][0], marks[0][1], marks[0][2]…marks[0][4]. We finally arrive to the conclusion that a 2-D array is a pointer to an array of 1-D arrays. For a normal 1-D array, marks [2] = *(marks + 2) To refer to an element in a 2-D array, say: marks [2][3] we can use the notation: *(marks[2] + 3) This tells the program to take the address of row2 and add 3 elements to it. But we’ve seen that marks[2] = *(marks +2). Thus: marks[2][3] = *( *(marks + 2) + 3 ) The double asterisk confirms what we stated at the beginning. It denotes that our 2-D array is in fact a pointer to a pointer. Try out the following code snippet: int marks[4][2]={60,75, 80,65, 90,95, 87,76}; cout<
Pointers

239

Core Concepts of OOP

Object Oriented Programming (OOP) Introduction: Introduction: Structured programming can be roughly divided into two categories: Procedural Object Oriented Structured programming is basically dividing a program into smaller modules that are easier to manage. All of what we have covered up to this point is part of procedural programming. In this the programmer divides the program into smaller functions (rather than putting the entire code within one function). Each function would have its own variables and sharing of variables between various functions is also possible (using global variables). What we will see henceforth is related to object oriented programming (OOP). Large programs were difficult to handle in procedural programming and OOP was developed to reduce complexity of software development. In C++, OOP is implemented using classes. The main concepts in OOP are: Data Abstraction Data encapsulation (hiding) Polymorphism Inheritance Data Abstraction: The fundamental data types (like int, float, double, char etc.) might suffice for simple programs. It is difficult for a programmer to always think in terms of the fundamental data types alone. For example, what data type would you use if you want to model a car in a computer application? A car has many properties and each one will be of a different data type (the speed would be an integer, the colour would be a string and so on). We could use a structure to solve our problem but structures also have their limitations. When you create a structure, the user (another programmer who might use your structure or you yourself) can directly manipulate with the member data of the structure. Let’s say that we have created a structure called ‘car’ which has 2 data types for speed and color. You can create an instance of the structure car (say ferrari) and then assign the value for ‘speed’ as 99999. Or you could also set the colour as ‘xyzer’. This would lead to incorrect data and you wouldn’t want the user to

Classes & OOP

240 enter such values. Thus a structure wouldn’t permit us to control the way data is stored or accessed. A user can simply modify anything by directly accessing it. Wouldn’t it be more convenient if we could have some control over our data type? Whenever you create such a complex data type, there will also be some operations that you would want to perform on that data type. In C++, these operations (which are implemented through functions) and the data can be bound together as a class. A C++ class is a data type that the programmer defines. Data abstraction refers to the capability of a programmer to create new, user-defined data types. Classes are also called abstract data types (ADTs or user-defined data types) because they are created using the process of abstraction. So, what is the process of abstraction? Let us consider a simple example of a person. Every person in this world has many attributes (like age, date of birth, name, gender, marital status, salary, number of children, hobbies, strengths, weaknesses, diseases, nationality etc.). If we are designing a patient database application for a hospital, we might not require storing attributes like salary, strengths and weaknesses of a person. So while designing this application we will only choose the particular features of the patient that we are interested in (like age, date of birth, nationality, disease history, gender etc.). Now if we have to design another system for a corporation, we will consider the person as an employee. An employee database system wouldn’t need to store information like disease history, haemoglobin level etc. In this case we would only be interested in date of birth, salary, qualification etc. In both cases, our requirement is to store detail information about a person. In one case we have a patient and in one case we have an employee. Depending on our application we selected what we wanted. Abstraction is the process in which we selectively choose what is needed for our application discarding the unnecessary attributes (based on the requirements). You’ll appreciate ADT as you progress through this chapter. Data Encapsulation: Data encapsulation/ data hiding is an important feature of object oriented programming. The mechanism of hiding data is to put them in a class and make them private. The data is now hidden and safe from any accidental manipulations, i.e. no function (from outside the class) can change the member data. Actually there are two things you can hide: implementation of functions (to the user it doesn’t matter as to how you’ve implemented a particular function) and data. In procedural programming it is possible to only hide the implementation details but you cannot hide/ protect data. OOP lets you achieve this. Why do we need to really hide anything? Who are we hiding the data from? These questions will be answered later in this chapter. A simple example is the case of the ‘car’ we considered earlier. We don’t want the user to directly access ‘speed’ and modify it. By making ‘speed’ private, we prevent the user from doing this.

Classes & OOP

241 Polymorphism: Polymorphism means having many forms. Polymorphism can be seen frequently in the English language. There are many English words, which have a different meaning depending on the context of use. The statements “close a book”, “close the file”, “close the door” and “close the deal” all make use of the verb ‘to close’ but the meaning of each statement depends on the context. Another example is the sentence, “I’ve cracked the exam”. The meaning of cracked in this case is different from the crack used in a sentence like, “The pot cracked”. In both sentences the word is the same but its interpretation varies depending on the context. In the same way you can think of many programming examples. For instance, consider the + operator. When it is used on numbers it will act as an addition operator, adding two numbers mathematically and giving the result. When the + acts on two strings, the result will be the concatenation of the two strings (we’ll take a look at string objects which permit us to use + later). For example: “new” + “delhi” = “newdelhi”. Thus, though the operator is the same (+), it can perform different actions depending on the type of the operands. This is a simple example of polymorphism. A few other examples of polymorphism are:

The << and >> operators are bit-shifting operators and they are also used for displaying information on the screen or for storing values in a variable (the circumstance decides whether they are used to shift bits or as input and output operators). The division operator (/) when operating on two integers will produce an integer as the result of division. But if one of the operands are floating point numbers then the result will also be a floating-point number. In all these cases, the same operator performs different functions depending on the situation. This is called polymorphism. Inheritance: Just as the name implies, inheritance refers to children inheriting property from their parents. In C++, the parents are called the parent classes and the children are called the derived (or child) classes. The idea of inheritance is to prevent classes from being redefined over and over again. If a programmer has already created a class and you want to make use of the same class with some additional features, then you needn’t rewrite the entire class description again. Instead, you can derive a class from the original one (hence all the existing features of the class will be available in your class also) and you can add the extra features you need to your class. This is called re-usability of code. Instead of re-writing, we can re-use through the concept of inheritance. Let’s take the example of animals: a lion belongs to the cat family; the cat family comes under the mammals’ category and the mammals category will come under the general group called animals. Using inheritance, if a lion is being described then only the unique features of a lion need to be defined (you needn’t define the features of animals, mammals and cats). Thus the class ‘lion’ will be inherited from the class ‘cat’ which will in turn be inherited from the class ‘mammals’ which is inherited from ‘animals’.

Classes & OOP

242 OOP Languages: Object Oriented Programming did not originate in C++. In fact it was already existing and OOP was combined with C programming to develop C++. A few of the OOP languages are:

Simula Modula SmallTalk Ada C++ Java Some of these languages are said to be ‘pure OOP’ while others are ‘hybrid OOP’. ‘Pure OOP’ means that everything in a program has to be tied with classes (and you cannot use separate functions). Java is an example of pure OOP. C++ comes under hybrid OOP because you can use OOP as well as the normal C style coding (involving separate functions and data).

A closer look into OOP: The world can be considered to consist of many objects. Objects will have attributes and behaviours. A water-heater is a simple example of an object. It has certain attributes or properties (like colour, size, maximum and current temperatures etc.) and there are certain behaviours associated with the water-heater (like switching on the heater, increasing the temperature or heating for a specified time interval, switching off the heater etc.). These are actions that can be performed on the heater. Or in other words they are actions which can modify certain properties of the heater (for instance by switching on the heater the current temperature of the heater will change). A car is another example of an object. It has a lot of attributes such as fuel capacity, current speed, top speed, number of wheels, type of gearbox etc. There are also a lot of operations which you can perform on this object. For example: you can accelerate the car, apply brakes etc. The attributes of a car will have some values at any given instance of time. Once the car is in motion, you can say that at a particular time the speed of the car is 30 km/hr (thus current speed will be 30km/hr). Similarly, the color of the car is red or the car has four wheels. The values for the attributes at any given instant of time define the state of the object. There are

Classes & OOP

243 two types of states an object can have: static and dynamic. Some attributes of the car will not change over a period of time. The number of wheels in the car is always going to be four (unless you are making a new prototype!). The colour of the car would also remain the same for a long time. These attributes contribute to the static state of the car. The current speed of the car is a dynamic property which will change frequently depending on the actions performed upon the car. In OO terminology you will encounter the following terms frequently: State Behaviour Identity Behaviour of an object refers to the set of operations (or actions) that can be performed on an object. Every object will have some attribute that can be used to uniquely identify the object. For example let’s take the example of a car as an object. All cars have colour as an attribute. But can you distinguish two cars based on their colours? Definitely not. But you can distinguish two cars based on their registration number. Hence registration number is the attribute which can be used to uniquely identify a car. If you take a banking example then the account number is a unique way to identify an account (no two accounts can have the same account number). An object will have two parts: 1. Interface 2. Implementation In a car, the interface is the acceleration and braking actions which can be performed on the car (there are many more but lets just limit ourselves to these two actions). The driver is going to be the user of the car. When the driver presses the accelerator pedal, there are a lot of things that happen within the car which actually cause the rpm (rotations per minute of the wheel) to increase. Is the driver concerned about what actually happens within the engine? No. The driver just wants the car to accelerate on pressing the pedal and is least bothered about the underlying mechanisms used by the manufacturers to achieve this. He doesn’t care about how the engine is designed or as to how the piston is moving to achieve acceleration. All he knows (and wants to know generally) is that the car should accelerate when he presses the pedal. These internal mechanisms are called implementation details in OOP terminology. One of the central features of OOP is to separate the interface from the implementation. The person using an object should not know/worry about the implementation. This is what is termed encapsulation.

Classes & OOP

244

Classes and Objects in C++: In C++ classes are used implement OOP. A class will contain two types of members: member data and member functions. The member functions can be used to operate on the member data within the class. The data members correspond to the attributes while the member functions correspond to the behaviour. Instead of the term ‘function’, some programmers use the term ‘method’. The term ‘class’ and ‘object’ might seem confusing at first. Basically you cannot directly use a class (we need to create an instance of the class and we call this an object). In our fundamental data types we have int, double, char etc. But are we using them directly? For example, do we say: int = 5; No. If we were to do this then we would never be able to create different integer variables. We create an instance of an integer when we say: int x = 5; Since classes are also data types (user defined data types), they also follow the same principle. You have to create instances of a class to do anything useful. An object is an instance of a class, i.e. only when you define an object, will the compiler allocate memory for the object. Class is like a model (or a template) from which you can create many objects of the same type. A template can be compared to the plan of a building. When the plan is drawn, we have not yet allocated the area on land for construction. We only know about how the building structure will be. But when construction work begins, the area will be allocated. Similarly, the compiler allocates memory space for every object that is created. This is why a class is called an abstraction (in other words a class is a generality while an object is a specific instance of the class). Let’s say we have a class called student, with the attributes: id name age We can create two students by saying:

student Watson, Hastings;

Now, Watson and Hastings are 2 students. Each of them will have an id, name and age (we can modify their attributes separately). You will be able to distinguish between a class and an object clearly when we write a few programs. Everything in a class (data and functions) is private, protected or public. They are called access-specifiers (because they decide how the class members can be accessed).

Classes & OOP

245 private: As the name suggests, whatever is in the private area of a class can only be accessed from within the class. If the data is made private then it can be accessed only through member functions of the class. If a function is made private then it can be called from within another member function. Data/function is made private by default (i.e. if you don’t mention any specifier). protected: The specifier ‘protected’ is used in inheritance and will be dealt with later. public: Public members of a class are accessible from outside the class. Hence when objects are created, they can access the public members directly. Usually, data is made private while the functions are made public (this is done to ensure data encapsulation). These public functions can operate on the private data. The syntax for a class is: class name-of-class { private : data-type variable-name; public : functions; };

//these are private //these are public // End of class- make a note of the terminator.

It is not a must that data should be private and functions should be public. You can have private functions as well public data. Remember: No member of your class can be declared as ‘register’ or ‘extern’. Note: Before getting into classes, you should know that there are two types of programmers who work with classes: the class designer and the class user. The designer (or creator) creates a class and the user makes use of the class in his/her programs. The term ‘user’ usually represents the person who will use an application developed by a programmer. But if the term ‘user’ is used while explaining classes, then it refers to a ‘class user’ (a class user is another programmer). In our example codes, we will be the designers as well as the users of the class (of course if you provide the code to someone else, then we will be considered the designers while they will be the users). A class creator will try to hide from the user whatever is not required by the user (why provide more options to the user and lead to complications!). Hide whatever is possible so that the class user cannot tamper with things that they are not supposed to use.

Classes & OOP

246

Demonstration of a Class A program to demonstrate Classes Before getting into the nuances of classes let’s take a look at a few simple examples to illustrate classes and objects. Let’s say that we want to create a timer, something like a stopwatch. We should be able to set the timer to a start value, pause it, stop it or start it. Thinking in terms of OOP we would have one member data: •

count (let’s keep it as an integer)

Being the first example, we’ll implement some simple functions: •

initialize( )

•

display( )

•

increment( )

The function names are self-explanatory and the functions would operate on the member data (i.e. someone who uses our timer shouldn’t be able to change the value of count directly. If this were allowed then the user might set count to a negative value or might misuse it). The user of our timer object should be able to access our timer in a controlled manner. #include class Timer { private: int count; public: void initialize( ) { cout<<"timer!"; count=0; } void display( ) { cout<<"remaining:"<
Classes & OOP

247 int main( ) { Timer t1,t2; t1.display( ); t1.initialize( ); t1.display( ); t1.increment( ); t1.display( ); t2.initialize( ); t2.increment( ); t2.increment( ); t2.display( ); return 0; } When you run the program you may get an output similar to this: Seconds remaining:4289044 Resetting timer! Seconds remaining:0 Seconds remaining:100 Resetting timer! Seconds remaining:200 Since this is our first program in classes, we’ll dissect it line-by-line.

Dissection of the program

Explanation for each part

class Timer {

Begin the declaration of our class called ‘Timer’.

private: int count;

public: void reset( ) { cout<<"timer!";

As part of data hiding, we’ve put the member data (count) within the private section of the class. Only the public functions of the class can access ‘count’.

The keyword public indicates that everything following this label is part of the public section of the class.

count=0; } initialize( ) is a member function of class Timer which will be used for resetting the value of count to void initialize( ) { cout<<"timer!"; count=0; }

zero. Since it is present in the public section, anyone using our class can call this function (and since this function is part of the class, it is permitted to access the member data ‘count’).

Classes & OOP

248 void display( ) { cout<<"remaining:"<
We’ve defined 2 more functions display ( ) and increment ( ) which also access the member data

void increment( ) { count=count+100; } };

‘count’. Signals the end of our class declaration. Next comes the main( ) function in which we’ve created two objects. ‘t1’ is an object or an instance of

int main( )

the class Timer. ‘t2’ is another object (i.e. we now have two timer objects in our program). Every

{

instance of a class will have its own copy of the Timer t1,t2;

member data. This is similar to how we used to create variables from the fundamental data types (ex: int x, y; creates two integer variables). All public members of the class can be called using the dot operator. Thus we call the member function

t1.display( );

display using the dot operator. This would display the value of the t1’s variable ‘count’. Since it hasn’t been initialized, you’ll find a garbage value on your screen.

t1.initialize( ); t1.display( );

t1.increment( ); t1.display( );

t2.initialize( ); t2.increment( ); t2.increment( ); t2.display( ); return 0; }

Set member data count to 0.

We’ve incremented the value of count from 0 by 100. Thus the last display would yield: Seconds remaining:100

These will all act on the ‘count’ of object t2. Thus at the end of our program: count (t1) will be 100 count (t2) will be 200

End of the program.

Remember: When we call member functions using the object t1 we are only manipulating the ‘count’ of t1. The object t2 remains unaffected.

Classes & OOP

249 Remember: Only functions belonging to the class can access the private members of the class. This example should have clarified your doubts about a class and an object. We create objects from a class. The class acts like a general framework from which we can create many objects. Each object will have the same member functions and data but the value for the data can be different. If we apply what we learnt about OOP earlier we can state this in another way: Each object that we create will have its own state. In real life this corresponds to having two timers which are identical in functionality but independent of each other (each one can have a different time). Try adding the following statement to the code above: cout<
cannot access private member declared in class 'Timer'

Let’s modify our class by adding a public member data: class Timer { private: int count; public: int dummy; void initialize( ) { cout<<"timer!"; count=0; } }; int main( ) { Timer t1,t2; t1.dummy=90; cout<
Classes & OOP

250 Note: You generally won’t find programs with a function like display ( ) which we’ve used above. Instead of this we would generally define a function through which the user (i.e. the programmer who would later use our class) can retrieve the value of the member data. So, instead of the function: void display( ) { cout<<"remaining:"<
t1.set_count(-200);

and the compiler would faithfully obey (it’s like creating a digital clock which can be accidentally/ intentionally set to negative time!). To prevent this then we have to test the value of the argument passed within the member function set_count( ).

Classes & OOP

251 Remember: In real application programming, a class designer would avoid using I/O within member functions (i.e. it is preferable to avoid using cout or cin within member functions). This task is left to the user of the class (of course the class designer should provide some member functions through which the user can set member data). In this book you may find cout statements within member functions; these are primarily used to illustrate concepts and how C++ works. Some important points about classes: You cannot access private members of a class directly. Private members can be accessed only through the public member functions. An object in the program can directly access only the public members through the dot operator (the dot operator is also called the member operator). Private members cannot be accessed directly by an object. Whenever we call a member function, we actually say that ‘we are passing a message to the object’. This is another term frequently used in OOP. Can a function be private? Yes. Nothing prevents you from doing so. Once you declare a function as private, it cannot be accessed using the dot operator. You can only call the private function from within a public function. But you might be wondering why would need to create a private function? This topic will be dealt with an example after learning about constructors and destructors. Remember: By default, all data and functions in a class are made private. To make something public you have to explicitly specify the access specifier in your class declaration. It is a good practice to explicitly state which members are private and public in your class (as done in the above program).

Classes & OOP

252

Constructors In our first example in creating a class Timer, we used a member function called initialize( ). This was used to set the starting value of count to some legal value. void initialize( ) { cout<<"timer!"; count=0; } Basically, our idea was that whenever someone creates a Timer object the starting value of count shouldn’t have a garbage value. So we defined a member function which would assign values to our member data. Anyone who uses our class is expected to call the initialize( ) function first before using the Timer object. But there is a problem with this; when a user creates a Timer object he/she may forget to call the initialize function. This would create a lot of problems in the code later. Wouldn’t it be wonderful if we could initialize the member data of an object just like we initialize variables of fundamental data types? Remember: Initialization and assignment are different. Initialization is done at the time of defining the variable. This is discussed at the end of this section. Variables of fundamental data types can be initialized (at the time of declaration). For example: int variable = 5; This line declares ‘variable’ to be an integer and assigns the value of 5 to ‘variable’. Similarly, how about initializing an object? Constructors serve this purpose. When an instance of a class (or an object) is created, a special member function for that class called a ‘constructor’ is invoked. You can declare your own constructor but if you don’t then the compiler will provide a ‘default constructor’ for the class. A constructor is a member function with same name as the class. It is usually used for the initialization of an object and it is executed at the time of creation of the object. Constructors cannot return any data. Basically, objects are created to model real life entities and when an object is created, you will want some particular data (or properties) of the object to be initialized. The idea is to prevent an object from having an uncertain or undetermined state at the time of its creation. So, all initializations of member data are done using the constructor. A constructor is just like a function except that you won’t have a return data type and also the name of the constructor should be the same as the name of the class. General syntax for a constructor is: constructor-name { //body of constructor } Another form that can be used is: constructor-name ( ) : member-data (value) {} Let's take a look at a simple program to illustrate the use of constructors.

Classes & OOP

253 class counter { private : int count; public : counter ( ) { count=0; }

// Constructor sets member data count to zero.

//you can define more functions }; int main ( ) { counter c1; return 0; } When the compiler reads the line counter c1; it goes to the public part of the class and sees the constructor used. Since counter c1; has no arguments the compiler makes use of the constructor without parameters. Hence the count of c1 is initialized to zero. This is what we wanted to do: Create an object and at the time of creation set the member data to a particular value. Instead of zero you can even give a value. For example: counter ( ) { count=7; } If you use the above constructor, then the value of the member data count is initialized to 7. The alternate form for this constructor is: counter ( ) : count (7) {} So, what’s the difference in the two forms? This form makes use of an initializer list (i.e. count(7) forms the initializer list over here) to initialize the values while the constructor body is empty. In the other method we initialize the members within the constructor body. Remember: In the strictest sense, the first form: counter ( ) { count=7; } isn’t really an initialization (it is only an assignment). We’ll discuss this later.

Classes & OOP

254 Beware: When using an initialization list the order in which the members are initialized depends on the order in which you declare them within the class. The first member in the class will be the first member to be initialized. If your initializations depends on the sequence then be careful while using initializer lists. In the case of assigning values within the constructor body, the order only depends on the order in which you write the statements within the body (and not on the declaration order). This is an apt juncture at which we can discuss about initialization and assignment. Before going into classes, let’s consider our primitive (or fundamental) data types. int amount; amount = 92; In this case we have declared (and defined) a variable called ‘amount’. In the second statement, we assign a value of 92 to this variable. Now take a look at the following: int amount = 92; In this case we have initialized the variable ‘amount’ with a value of 92. Initialization is done at the time of declaration. You might recall that: int amount=92; and int amount(92); are equivalent. Now let’s come back to our discussion of constructors. counter ( ) { count=7; } We are actually assigning a value to the member data count. This isn’t an initialization (the member ‘count’ was first defined and then later we are assigning a value of 7 to the member). But when you use an initializer list: counter ( ) : count (7) {} the member data ‘count’ is initialized with a value of 7. Generally, using an initializer list is more efficient than assignment but in the case of simple member data types this may not really matter. We’ll take a look at this topic again later. If we do not provide a constructor, the compiler will provide its own default constructor (but this default constructor will not do anything useful - i.e. it will not initialize our member data). The compiler will not provide its default constructor if we provide our own constructor. A constructor with no parameters is also called a default constructor.

Classes & OOP

255 Constructors with Parameters (Parameterized Constructors): Constructors are like functions and they can also take parameters just like other functions. An example is shown below: class counter { private : int count; public : counter (int x) : count (x) {} // Some other functions in the class }; int main ( ) { int y; counter c1(2); cout<< "What value of count do you want initialise it to?"; cin>>y; counter c2(y); return 0; } The statement: counter c1(2); means that the constructor with one parameter is invoked. The argument passed to the parameter is 2. This value is now assigned to the ‘count’ of object ‘c1’. count (x) is equal to saying count = x. Hence ‘count’ of object c1 is two. You could also write the constructor as: counter (int x) { count=x; } Similarly,

counter c2 (y);

means that ‘count’ of c2 will be initialized to the value of y (i.e. the value the user types in). You could also perform some validations within the constructor to ensure that the user doesn’t initialize the member data to an invalid value. Remember: Constructors cannot return values.

Classes & OOP

256 Overloaded Constructors: Constructors being similar to functions can also be overloaded. To overload a constructor the parameter type or the number of parameters in the constructors should be different. It is possible that in our program we might want to have one constructor with no arguments and one parameterized constructor to initialize the member data to some other values. This is illustrated below: class rect { private: int length, breadth; public: rect( ) //constructor with no parameter { length=breadth=0; } rect(int x, int y) { length=x; breadth=y; }

//constructor with parameters

}; int main( ) { rect a; rect b(1,2); return 0; }

//executes ‘no parameter constructor’ //invokes the parameterized constructor

The above program will create an object ‘a’ whose length and breadth will be initialized to 0. The object ‘b’ will have its length and breadth initialized to 1 and 2 respectively. Another way to write the above program would be as follows: class rect { private: int length, breadth; public: rect(int x=0, int y=0) { length=x; breadth=y; } }; int main( ) { rect a; rect b(1,2); return 0; }

Classes & OOP

//if no argument is passed, x=0 and y=0.

257 The result will be the same as earlier. In this program we do not explicitly specify the default constructor. We make use of a single constructor to deal with both situations. If the program creates an object without any arguments then the constructor function will be executed with the default parameter values (specified to be 0 in this case). If an argument is passed to the constructor, then the parameter will be assigned the values of the argument.

Default Constructors and Arrays of Objects: Just like creating an array of integer data type, we can also create an array of objects belonging to a particular class. When you create an array of objects the class should have a no argument constructor (in other words the class should have a default constructor). Consider the following program: # include class rect { private: int length, breadth; public: rect(int x, int y) { length=x; breadth=y; } }; int main( ) { rect ob[3]; //ERROR return 0; } In the above program we have a parameterized constructor but no default constructor. Thus the statement: rect ob[3]; will cause a compile time error. The reason why this does not work is because when you create an array of objects there is no way in which you can pass arguments to the parameterized constructor. The compiler will not know what to pass for each of the objects. Thus if you want to create an array of objects then the class should have a default constructor. The program can be corrected as shown below: class rect { private: int length, breadth; };

Classes & OOP

258 int main( ) { rect ob[3]; return 0; }

//can be compiled without error

In the above program there is a default constructor provided by the compiler itself. But usually it is better to provide our own default constructor (so that we can initialize the data) as below: class rect { private: int length, breadth; public: rect( ) { length=0; breadth=0; }

//default constructor

}; int main( ) { rect ob[3]; return 0; }

//can be compiled

Let’s recall the main points about default constructors: If no constructor is provided, the compiler provides a default constructor (but this constructor does nothing). If any constructor (even if only a parameterized constructor) is provided, the compiler will not provide a default constructor. A constructor with no parameters is called a default constructor. A constructor with default arguments is also a default constructor. For example: rect(int x=0, int y=0) //if no argument is passed, x=0 and y=0. { length=x; breadth=y; } This is a default constructor.

Classes & OOP

259

Classes continued The following topics are covered in this section: •

Scope Resolution Operator

•

Destructor

•

Dynamically creating objects

•

Objects in Functions (returning and passing them)

•

Initializing an object using an existing object

Scope Resolution Operator (::) In the earlier section on classes, we have defined the member functions within the class itself. Hence there was no need to declare the function. But is it possible to define the member function of a class outside the class? We have already discussed inline functions. Even in classes you can explicitly declare functions to be inline using the ‘inline’ keyword. Remember: When you declare and define a function within the class it is made an inline function. If you define a function outside a class (using scope resolution operator), it will be treated like a normal function (not inline). Usually when using classes, any function that is just one or two lines long will be defined within the class itself. Longer functions are defined outside the class. Member functions can be defined outside the class by using the scope resolution operator. Using this we can declare a function within the class and define it outside the class. Let’s take a look at the syntax: return-data-type name-of-class-to-which-it-belongs :: function-name (parameters) Consider the example below: class Timer { private: int count; public: void display( ); //declared inside the class void increment( ); Timer( ); }; //Function defined outside the class using scope resolution operator void Timer::display( ) { cout<<"remaining:"<
void Timer::increment( ) { count=count+100; }

Classes & OOP

260 Timer::Timer( ) { cout<<"timer!"; count=0; } int main( ) { Timer t1; t1.display( ); t1.increment( ); t1.display( ); return 0; } Everything in the above program is same except that we have defined all the member functions outside the class. For this purpose we use the scope resolution operator to tell the compiler to which class the function belongs to. The statement void Timer::display( ) tells the compiler that the function ‘display’ belongs to the class ‘Timer’ and has no return data type (void). Similarly we have used the scope resolution operator to define the function increment( ). In this example we’ve also defined the constructor outside the class: Timer::Timer( ) { cout<<"timer!"; count=0; } Since a constructor cannot return any value we don’t specify any return data type (not even void should be used as return data type). Remember: Though the functions are defined outside the class, they still belong to the class. The scope resolution operator is used to say that this function belongs to this class. Programmers will usually define functions outside the class because they want to separate the implementation from the interface. When a programmer creates a class and supplies it for others to use he may not give away the implementation details to the public. Instead he’ll only provide the users with the interface and declaring functions outside a class aids a programmer in achieving this. We’ll discuss how this can be achieved later.

Destructor: When an object is created the constructor is invoked (or called). What happens when an object is no longer needed? The complement of the constructor is called. As the name implies, the destructor will destroy the object that was created. For a constructor we use the same name as the class name and for a destructor also we will use the same class name. But to differentiate between the constructor and destructor, C++ makes use of the tilde (~) symbol for the destructor. class class-name { class-name( ) //constructor {} ~class-name ( ) //destructor {} }; The important features of a destructor are: A class can have only one destructor function. Destructor cannot have any arguments. It cannot return anything.

Classes & OOP

261 If a destructor is not explicitly specified by the programmer, there is no problem. In some cases a destructor needs to be specified. So, what are the cases where we need to bother about the destructor? The most common example is when you have allocated some memory using the ‘new’ operator. Memory allocated using ‘new’ should always be freed using ‘delete’ before the termination of the program. Thus in this case we will specify the appropriate ‘delete’ statement in the destructor to ensure that the memory is freed up. Let’s see a simple program to understand a destructor: #include class car { private: int speed; char color[20]; public: car( ) //Constructor { cout<<"\nCreating a Car"; } ~car( ) //Destructor { cout<<"\nDestroying the Car"; } }; //End of class declaration int main( ) { car mine; return 0; } The output would be: Creating a Car Destroying the Car

Dynamically creating objects: In the chapter on pointers we discussed how we can allocate memory dynamically. This concept can be extended to allocate memory for user-defined data types also (like objects). C programmers would be familiar with the dynamic allocation operators ‘malloc’ and ‘free’ (the C++ equivalent are ‘new’ and ‘delete’). One of the most significant features of ‘new’ and ‘delete’ is that these operators are aware of constructors and destructors. Let’s try out a simple example: class car { private: int speed; char color[20]; public: car( ) //Constructor { cout<<"a Car"; } ~car( ) //Destructor {

Classes & OOP

262 cout<<"the Car"; } }; int main( ) { car *mycar=new car; delete mycar; return 0; } The output will be: Creating a Car Destroying the Car As you can deduce from the output, creating an object using ‘new’ ensures that the constructor for that object is called. Similarly delete calls the destructor of the object. This won’t happen if we were to use ‘malloc’ and ‘free’.

Objects in Functions: Objects can be used in functions just like other data types are used. Objects can be passed as argument to a function and an object can be returned from the function. These two topics will be dealt below separately. Passing Objects to Functions: An object can be passed to a function as shown in the program below: #include class rect { private: int length, breadth; public: rect(int x, int y) { cout<
Classes & OOP

263 The output will be: New rectangle created The area of the rectangle is : 20 Rectangle destroyed Rectangle destroyed ‘ob’ is an object of type ‘rect’. It is initialized using the parameterized constructor. The function calculate can accept arguments of type ‘rect’ (i.e. it can be passed ‘rect’ objects). We have created only one object (ob) but the destructor has been executed twice; why? When we say: calculate(ob); ‘ob’ will be passed by value to the function ‘calculate’ (i.e. the function will not directly work on the object ‘ob’. It will only work on a copy of the object ‘ob’). Since it works on a copy of the object, a temporary object of type ‘rect’ will be created when calculate ( ) function is executed. When the program exits the calculate ( ) function, the temporary object has to be destroyed and this is why the destructor has been invoked twice in the above program (once for destroying the temporary object and once for destroying the object ‘ob’). You might wonder why the constructor is also not executed twice? When a temporary object is created the constructor is not invoked. When a temporary object is created the program wants to maintain the state of the temporary object exactly the same as the original object (i.e. the member data values of the original and temporary object should be the same). Constructors are usually used for initializing and if the temporary object gets initialized then the values in the temporary object will be different from the original. So the constructor is not executed for a temporary object creation. This topic is discussed again in the “Copy Constructors” section. Returning Objects from Functions: What happens while passing an object to a function will happen even when you return an object from a function (i.e. a temporary object is created while returning an object also). class rect { private: int length, breadth; public: rect(int x, int y) { cout<
Classes & OOP

264 int main( ) { rect ob(9,9); ob=dummy_func( ); ob.area( ); return 0; } The output is: New rectangle created New rectangle created Rectangle destroyed Rectangle destroyed The area of the rectangle is : 25 Rectangle destroyed The header of dummy_func( ) is: rect dummy_func( ) This signifies that dummy_func( ) is a function which has no parameters and returns an object of type ‘rect’. Based on the output we can say that the destructor is invoked one extra time (just as it was done when we passed an object to a function). In this case the destructor is invoked due to the statement: ob=dummy_func( ); While returning an object the program will create a temporary object (which gets destroyed at the end). This extra temporary object can create problems if you make use of dynamic memory allocation. We’ll revisit this topic after we learn copy constructors.

Initializing an object using an existing object: In fundamental data types, the following is possible: int age1 = 10; int age2 = age1; We’ve used one variable to initialize another. The same is possible with objects also but care has to be taken. Consider the following example: #include class rect { private: int length, breadth; public: rect(int x, int y); void area( ) { cout<
Classes & OOP

265 //Constructor can be defined outside the class using scope resolution operator rect::rect(int x, int y) { cout<
Classes & OOP

266

Classes Explanation A Practical use of classes: The Problem: Living forms (plants, animals and humans) haven’t been fully understood by man. There are many things in life that are very complex and the most complex of all is the human being. A simpler life form would be the bacteria. Nowadays, researchers are trying to mimic or imitate the behaviour of living organisms (like bacterial movement). Consider the problem of optimization. Optimization means finding the best point in a given area. How do we decide which point is best? As a simple example, consider an equation with a single variable ‘x’. Let us assume that you have to find the lowest value for that equation (the equation is also called as a function). In this case the best value means the lowest value. Let the equation be: cost = 10*x + 100 …given that x is greater than 0 and can only take positive integer values between 1 and 100. What value of x do you think gives the least cost? If x=1 then cost=110; if x=2 then cost=120 and so on… It is quite clear that x=1 will give the least cost. Hence the best point (or optimum value) is x=1. That was very easy. The equation was very simple, involving just one variable. In real application you would have equations involving more than one variable and you will also have many conditions (the only condition we used was that x should lie between 1 and 100). You can extend the problem to the case of two variables.

Let’s assume that we have to find the least value for a given equation that has two variables (x and y). Let the limits of x and y be between 1 to 100 (and assume that they can take only integer values). The solution space (or the area in which you have to find the best value) will be as below:

100

Maxi limit

Solution Space

50 Yaxis

0

Classes & OOP

50 X axis

100

267 It is clear from the above graph that there will be 100*100 (=10,000) possible coordinates (in other words 10,000 possible combined values for x and y). The simplest way to find the minimum value for a function involving x and y would be to substitute all the 10,000 combinations, find the cost for each combination and then choose the minimum value. This seems to be a straightforward and simple method, but you can imagine the computational time needed when the solution space increases in size. And if you include floating point values, you are going to end up with a major problem. This is why we need techniques for optimization. We need to use algorithms that can determine the best point in a given solution space as quickly as possible (i.e. the algorithm should not calculate values for each and every combination). This is where bacterial movement comes into the picture. You might have heard of the E.Coli bacteria. This bacterium lives in the human body and has a particular method of movement. It keeps searching for areas where there is more food (or nutrition). Assume that the bacteria is initially at some place in your intestine. It will take a small step in one particular direction. If the new place has more nutrition than the previous position, then it will continue to move in the same direction. Otherwise, it will take a different direction and proceed. Suppose the new position has more nutrition, it will take another step in the same direction. Again if the next position is favourable, it will proceed in the same direction. This movement is a very simplified version of the actual movement (there are more complicated steps involved in bacterial movement but we will not deal with them here). Now you can apply the same bacterial movement algorithm to the problem of optimization. The advantage is that you won’t be computing values for each and every point in the solution space (i.e. we will program in such a way that after a particular number of iterations the program will terminate). There are many other organisms in nature which have different ways of movement and this could also be applied to the problem of optimization (in fact algorithms relating to ants, bees and snakes have been developed already). So, where do we make use of classes and objects? Bacteria is a general category and it forms the class. All types of bacteria will have some stepsize (stepsize refers to the length of the stride taken by the bacteria in moving once) and some particular direction as well (bacteria are in three-dimensional space and they are free to take any direction). Thus, these features are common to all bacteria. We can then model bacteria as a class. This class could contain the following functions: •

• • •

To initialize the starting position of the bacteria. Every bacterium when it is created will have a particular position in 3 dimension. This has to be specified by three variables: x,y and z. To generate the direction in which the bacteria should move (in mathematics this is called the unit vector). To find the new position after the bacteria moves. An algorithm to decide whether to move to the new position or not (move only if new place is better than the present one).

Every instance created from the class ‘bacteria’ is an object. Each object will have a different starting position (decided randomly) and each bacteria will move in different directions (i.e. each one will try to find the best point).

Classes & OOP

268 Thus, we can create 10 objects of type ‘bacteria’ and make each bacteria search the solution space. After some particular number of iterations, we can stop the bacterial movement and find out the positions of each of the objects.

Demonstration of the Bacteria Class We shall create a class called ‘bacteria’. This class will model a real life bacteria and we shall assume that the bacteria is going to move only on a 2-D (two-dimensional) area (i.e. we will only bother about the x and y axis). Of course you can extend it to 3-D as well. To keep track of the position, we shall make use of two variables x[2] and y[2].

x[0] and y[0] will be used to store the starting position. Once the bacteria moves, the new position will be stored in x[1] and y[1]. For the next movement, x[1] and y[1] will become the starting point and so we set: x[0]=x[1] and y[0]=y[1] Another data member is the variable ‘stepsize’. This determines the length of each stride of the bacteria. Higher the value, the more distance the bacteria will cover each time. The other two variables needed are ‘ai’ and ‘bi’. This is used to specify the direction of the movement (those of you who have learnt about vectors will know about the properties of a unit vector). Anyway a unit vector is needed to decide the direction of movement.

Classes & OOP

269 The program written below is meant to illustrate the use of comments as well. Many programmers have different styles of commenting but you should always make use of comments throughout your program. //************************************************************** ** //Aim :Illustrate the movement of a bacteria based on food available * // The class bacteria models a general bacteria * //Author :Santhosh * //Written on :12 Feb 2004 //Revised on :16 Feb 2004 * // (modified the unit_vec( ) function) * //**************************************************************** class bacteria { protected: float x[2],y[2],food[2]; int stepsize; float ai,bi;

//To store the old and new position //Unit vector

public: bacteria( ) {

//Constructor with no arguments

x[0]=rand( ); y[0]=rand( ); stepsize=1; food[0]=x[0]+y[0]; ai=bi=food[1]=0; x[1]=y[1]=0; } void disp_final( ); void disp_initial( ); void unit_vec( ); void calculate( ); void move( ); int test( ); };

Classes & OOP

//To display new position //Display initial position //To generate direction //To move the bacteria

270 void bacteria::unit_vec( ) { ai = rand( ); bi = rand( ); float mag = (ai*ai) + (bi*bi); mag = sqrt(mag); ai = ai/mag; bi = bi/mag; } void bacteria::calculate( ) { x[1]=x[0]+(stepsize*ai); y[1]=y[0]+(stepsize*bi); food[1]=x[1]+y[1]; } int bacteria::test( ) { if (food[1]>food[0]) bacteria { return 1; } else return 0; } void bacteria::move( ) { x[0]=x[1]; y[0]=y[1]; food[0]=food[1]; }

Classes & OOP

//only if food increases we want to move

271 void bacteria::disp_initial( ) { cout<
Classes & OOP

272 The output would be: The original position of bacteria is : 41 , 18467 The new position of bacteria is : 41.2325 , 18468 The original position of bacteria is : 41.2325 , 18468 The new position of bacteria is : 42.0056 , 18468.6 The original position of bacteria is : 42.0056 , 18468.6 The new position of bacteria is : 42.3698 , 18469.5 The test( ) function is used to ensure that the bacteria moves to positions with more food. If the amount of nutrition at the new place is less, then we will find a new unit vector and search in another position. In the above program the food will always keep increasing in the new position (because there is no provision provided for generating a negative unit vector). In real applications you would have to provide means for doing that as well. Also, the food function here is simply ‘x’ coordinate plus ‘y’ coordinate; in real applications you will have complicated equations. The output may appear a little weird. What does 42.3698 , 18469.5 mean? Actually we are working with vectors; thus the output is as good as saying: 42.3698 x + 18469.5 y 42.3698 units on the x axis and 18469.5 units on the y axis.

This is a very simple illustration. In reality, the bacteria would probably have to move around thousands of times and it has to move in some logical manner. Over here we make the bacteria move in a completely random manner. And you will also need to use a lot more bacteria objects to search for the best point (one bacteria object will not be sufficient to search a huge area).

Classes & OOP

273 The use of Inheritance: We’ve modeled a general class called ‘bacteria’ but the problem is that certain types of bacteria have different methods for movement (for example: E.Coli and TB bacterium move differently). E.Coli and TB are bacteria but they have different movements. Now what can we do? Should we declare another class called ‘ecoli’ and ‘tb’? Should we again declare the coordinate variables x,y,z and the member functions in each of these classes? And if we should do that, what is the purpose of having a general ‘bacteria’ class? The idea of having a general bacteria class serves two purposes: •

•

First of all, we are modeling the real world (we have different types of bacteria, each with some unique features). But all bacteria have certain common features and it is these common features that we declare in the general bacteria class. It is easier to think and program based on real life objects (this is the basis of OOP). Secondly, we can use the concept of inheritance to solve our problems. Using this we needn’t redefine all the variables and functions that are present in the ‘bacteria’ class again.

The ecoli and TB will also be modeled as classes but they will be derived from the general ‘bacteria’ class. In this way the two classes will inherit the properties of the ‘bacteria’ class. This is known as inheritance. Thus now you can create objects of type ‘TB’ and ‘ecoli’ as well. Inheritance will be dealt with in Chapter 10. Suppose another programmer in future wants to add another type of bacteria, he can simply derive a new class from the existing ‘bacteria’ class (thus saving time and reusing the code).

Classes & OOP

274

Data Encapsulation

Let us assume that you have created a new library that you want to distribute to other programmers. For example, working with images (bmp, gif or jpg) isn’t that easy in C++. You have to write methods (functions) for reading an image, identifying what type it is, displaying the image etc. There are many image-processing applications where the first step is to read an image. The simplest application is Optical Character Recognition (OCR). In OCR we write a program that will be able to recognize hand-written letters or numbers. For instance, if you write 8, the computer should be able to recognize that an 8 has been written (no matter how bad the handwriting is). Whatever you write on paper will be scanned into the system and stored in the form of an image file. A programmer developing an OCR application could either start from scratch or he could focus on his problem (i.e. OCR). By starting from scratch, he has to write a lot of coding just for the purpose of reading an image. Instead if he can get access to some good Image processing library (which will contain files for reading images), he could simply use the #include directive and concentrate on the OCR algorithm. So, let’s say that you have created a library for the purpose of image processing. You will make use of the concept of classes. You will create a class called ‘Image’, which contains member functions for reading an image, identifying the type of image etc. You will also have some member data like the height and width of the image. When you distribute your library to others, you give them the opportunity to create objects (or instances) of your ‘Image’ class. You will also have provided a little help file describing the various functions that are available for use. Note: You will only describe the use of the various functions (ex: the function syntax and what it will do). You will not be providing an insight into the implementation aspect of the function (i.e. you will not be explaining the function definition). Now, the OCR person will start coding his application. There is a chance that he might use the same member data identifier ‘length’ and ‘width’ in his program. Imagine the consequence if ‘length’ and ‘width’ are not made private within your class. There is a good chance that the user will fiddle around with the data (knowingly or unknowingly) and their values will get

Classes & OOP

275 altered by the user (which is what you don’t want). The result is that your functions, which operate on these member data, will produce some ambiguous results. By hiding your data, you prevent such problems from happening because the user will never be able to access or modify your class’ private members. The idea of encapsulation is to prevent users from having access to everything. They should be able to access members that are needed for their use. In larger classes there may be many members (data and functions) which are not required for someone who is going to use your class. These members should be made private. Remember: Usually the class declarations are written in a *.h header file (this is called as the interface) while the definitions for the member functions are written in a *.cpp source file (this will be the implementation). Thus even if the implementation is changed the interface remains unaffected (more about this in Multiple file programming). Thus to summarize: •

Data encapsulation means hiding the implementation of a class from the user. We restrict the user in such a way that the user can perform only limited operations on the private part (and that is only through the member functions). The user cannot access any of your private members directly.

•

Another advantage of hiding the implementation is that you (the class designer) may decide to change the process of implementation. You might have discovered some better and effective method for doing the same purpose. By hiding the implementation, all you need to do is to change the function definition. The user will never have to change his code (because you have only changed the implementation, which the user has nothing to do with). The code written by the user will still run even though you have changed the implementation.

Classes & OOP

276

More on Classes and Objects The idea of OOP is to write programs which will mirror the real world. Whenever you write a program using classes you have to decide as to what are the members of the class? To do these take the real-world entity that you are going to model. For example: Let us model a class based on a cricket player (say a batsman). Our problem is that we want to write a program to maintain records of different batsman (particularly we need to keep track of their highest and lowest scores). Every batsman will have the following attributes (or properties): • • • • • • •

A name A player number Date of Birth Native place Best score (or highest score) Worst score Physical description (like hair colour etc.)

We are not interested in storing information about all the attributes and hence we must isolate the attributes that are relevant to our problem. Considering our problem we will only need to use the name, player number, best score and worst score properties. Next we have to decide on the methods (or functions) that are required in the class. The following will be needed: • • • •

Initialize the member data. A display function to display the player details (i.e. display the member data values) Function to update the best score after every match. Function to update the worst score after every match.

Classes are sometimes modeled diagrammatically as shown below:

In this example, ‘batsman’ is the class and any instance created from this class is an object (i.e. if you create an object having values for each of the properties then that object is said to be an

Classes & OOP

277 instance of the class). For example: if we create an object called ‘ob1’ with the following member values: Name: Sachin Number: 10 Highest score: 200 Lowest score: 5 then ‘ob1’ is an instance of the class (or entity) ‘batsman’. This should clarify any doubts you might be having about the difference between a class and an object. Similarly whatever real life object you consider, you can model them into classes depending on the problem.

Private Member functions: Usually member data are made private while functions (or methods) are made public. There might be instances where you might want to make certain functions private (i.e. you may not want the user to directly access these functions). Private functions can only be called from within public member functions. These functions are also called ‘helper functions’ Why do we need them? Let’s take the example of the class ‘batsman’. After every match the user will enter the batsman’s new score and then he will have to call two functions to update the batsman’s record (i.e. the user has to call update_best ( ) and update_worst ( )). It is unnecessary to bother the user with this kind of a double function call. Why should the user access these two functions directly? Instead of this, we could define another function called update ( ) which will call update_best ( ) and update_worst ( ). In this way the user needs to only call one function after every match. The idea of classes is to restrict user access. We don’t want the user to access data or functions unnecessarily. So, we will make update_best ( ) and update_worst ( ) as private functions while update ( ) will be a public function.

Classes & OOP

278 // To illustrate the use of helper functions (private functions) #include class batsman { private: int player_number; int best_score,worst_score; void update_best(int); void update_worst(int); public: batsman(int n, int b, int w) //constructor { player_number=n; best_score=b; worst_score=w; } void update(int); void display( ); }; void batsman::update(int x) { update_best(x); //private function is called update_worst(x); cout<<"\n\nThe scores have been updated\n"; } void batsman::display( ) { cout<<"\nHighest score : "<best_score) { best_score=y; } }

Classes & OOP

279 void batsman::update_worst(int z) { if (z
Classes & OOP

280

Friends and more! The following topics are covered in this section: • • • •

Friend Function Friend Class Static Members Constant Objects

Friend Function:

The private member data of a class can be accessed only by the class' member functions. Well, there is one exception. A friend function will be friendly with a class even though it is not a member of that class. By the term friendly we mean that the friend function can access the private members of the class. Check out the example below: #include class car { private: int speed; char color[20]; public: void input( ) { cout<<"\nEnter the color : "; cin>>color; cout<<"\nEnter the speed : "; cin>>speed; } friend void display(car); //Friend of the class 'car' }; void display(car x) { cout<<"\nThe color of the car is : "<
Classes & OOP

281 The output is: Enter the color : red Enter the speed : 345 The color of the car is : red The speed of the car is : 345 First of all we've created a class named car. It has two private data: color and ‘speed’ and one public function ‘input’. It also has a friend function called display ( ). Next comes the definition of display ( ): int display (car x) The parameter specifies an object of type ‘car’. The function has been defined to output: x.color; x.speed; The idea is that you will pass an object of type ‘car’ to this function and the function will display the corresponding color and speed values for that particular object. In the main ( ) part, an object called ‘mine’ has been created whose private data are set by the user through the input ( ) function. Next the friend function has been called: display(mine); Remember: Friend functions are not members of any class but they can access private data of the class to which they are a friend. Beware: Since they are not members of any class, you should not call them using the dot operator. You might be wondering what's the big point of friend functions. In the above example, we could have made ‘display’ as a member function of the class instead of declaring it as a friend function. What's the use? A friend function can be friendly to 2 or more classes. The friend function does not belong to any class, so it can be used to access private data of two or more classes. No other function can do that! #include class virus; // forward declaration of ‘virus’ class class bacteria { private: int life; public: bacteria( )

Classes & OOP

282 { life=1; } friend void check(bacteria, virus); }; class virus { private: int life; public: virus( ):life(0) {} friend void check(bacteria, virus); }; void check (bacteria b,virus v) {

if (b.life= =1 || v.life= =1) { cout<<"\nSomething is alive"; } if (b.life = = 1) { cout<<"\nA bacteria is alive."; } if (v.life = = 1) { cout<<"\nA virus is alive."; } } int main( ) { bacteria fever; virus cholera; check(fever, cholera); return 0; } In the second line of the program we have the statement: class virus;

Classes & OOP

283 This is a forward declaration of the class ‘virus’. This is done because when the compiler reads through the lines in the ‘bacteria’ class, it encounters the word ‘virus’ in the friend function declaration. Until this point it doesn't know what ‘virus’ is because we will be defining the ‘virus’ class later on. So we tell the compiler in advance that ‘virus’ is a class by declaring it in the starting itself. If you don't declare it, you will get errors. Just try it out. One more note: You should declare the friend function in both the classes where you want it to be a friend. In this program we want to check whether any organism is alive at present by testing the value of ‘life’. Of course you can write individual member functions in each class but the use of a friend function makes it simpler and easier to understand the logic.

Friend Classes Just like functions are made friends of classes, we can also make one class to be a friend of another class. In this way, the friend class will have access to all the private members of the other class. #include class add { private: int x,y; public: add( ) { x=y=4;| } friend class support; //support is now a friend of add }; class support { public: void sum(add ob) //it can access private members of class 'add’ { cout<<"The sum of the 2 members is : "<<(ob.x+ob.y); } };

Classes & OOP

284 int main( ) { add ad; support sup; sup.sum(ad); return 0; } The output will be: The sum of the 2 members is : 8 In this program, the class ‘support’ is a friend of the class ‘add’. Thus the class ‘support’ can access all the private members of the class ‘add’ (i.e. ‘x’ and ‘y’). Friend classes are rarely used.

Static Class Members A class is just an empty area. No area is allocated when you create a class. So, only when you create an object of that class will the compiler allocate space to the object. Again, this means that: private: int x; does not allocate space for an integer x. When you create objects belonging to this class, required space is allocated for holding the integer. Each new object that you create belonging to this class will have its own version of the integer ‘x’. The keyword ‘static’ helps you to create a single copy for all objects belonging to the same class. #include class bacteria { private: static int count; public: void modify( ) { count=count+1; cout<
Classes & OOP

285 int bacteria::count=5; // memory allocated for ‘count’ over here int main( ) { bacteria b; bacteria plague; b.modify( ); plague.modify( ); plague.modify( ); return 0; } The output is: The new count is : 6 The new count is : 7 The new count is : 8 The integer ‘count’ is declared to be static. But again outside the class we say: int bacteria::count=5; This is done so that the compiler will allocate space for the integer ‘count’. If ‘count’ were not static, when would the compiler allocate space to it? It would allocate space when an object is created. But in the case of static variable members in a class, we will create it only once and so we have to ensure that the compiler creates that one instance of the variable. In this case we’ve initialized it to a starting value of 5. If you simply type: int bacteria::count; ‘count’ would be automatically initialized to 0. Since ‘count’ is static, each time you change the value of ‘count’, all the objects belonging to that class will make use of the new value. So far we’ve seen static member data but you can also make functions static in a class. Just precede the function by the keyword static. Static functions will be useful to operate on static member data.

Classes & OOP

286

Constant Object Classes are user-defined types and objects can also be made constant using the ‘const’ keyword. When an object is made constant there are some peculiar properties that you should take note of. A constant object is created to avoid making changes to any of the values of the member data (that is the purpose of constant in general and so is the case with constant objects). 1.) Constant objects cannot access member functions that are not constant. #include class bacteria { private: int life,count; public: bacteria( ) { life=1; } void display( ) { cout<
Classes & OOP

287 2.) So, the question arises, what are constant functions? Constant functions can be called by constant objects. The compiler doesn’t know when a function modifies data values and when a function doesn’t. When you make a function constant, the compiler believes that the function will not change any of the member data values. To create a constant function you have to simply add the keyword ‘const’ at the end of the function. class bacteria { private: int life,count; public: bacteria( ) { life=0; } void display( ) const { cout<
Classes & OOP

288 3.) Can a constant member function never modify any member value? Again there is an exception to this. If a member data is declared as ‘mutable’, then the constant member function can modify this member data. You might wonder what purpose this would solve? There might be a case where you want to keep count of something for all objects (irrespective of whether they are constant objects or not). In this case, a constant object should also be able to access such member data. Let’s take the same case of the bacteria class. We shall make the member data ‘life’ mutable. class bacteria { private: mutable int life; public: bacteria( ) { life=0; } void display( ) const { life=life+1; cout<
Classes & OOP

289

Copy constructors, pointers to objects The following topics are covered in this section: • • • •

Pointers to Objects this Pointer How objects are stored in memory Copy Constructors

Pointers to Objects You can create pointers to objects and to access the member functions you will have to use the arrow operator just like you would do for structures. class bacteria { private: int life; public: bacteria( ) { life=1; } void display( ) { cout<<"Life is : "<display( ); return 0; } The output is: Life is : 1 You cannot attempt to access any private members of a class using a pointer to an object (data hiding is retained irrespective of whether you create an object or a pointer to an object).

Classes & OOP

290

How are objects stored in memory? We know that classes are just a framework- they do not occupy memory space. Instances of the class (objects) will occupy memory space. But a class has member data as well as member functions. It is obvious that every instance of the class should have its own copy of the member data; but is it necessary that every object should have a copy of all the member functions? The member data values will vary from object to object but the member functions are going to be the same. Member functions are implemented by taking advantage of this fact and hence only a single copy of the member functions is stored in memory. For example: #include class heater { private: int temp; public: heater( ) { temp=0; } void set_temp(int x) { temp=x; cout<<"temperature is now:"<
Classes & OOP

291

Now an interesting question arises. If all objects are going to access the same member functions how does the function operate on the correct object? How does the function know on which object it has to act upon? How is it that when h1 calls set_temp(), the member ‘temp’ of h1 gets set? This indicates that there must be a way in which the member function can identify who called it? The member function set_temp( ) should be able to differentiate between the objects h1, h2 and h3. To achieve this we pass a special member to the function (which the function uses to identify who called it). This member is the ‘this’ pointer.

‘this’ Pointer We’ve seen that objects can call member functions (public functions) by simply using the dot operator. But the member functions are not called as we might think. The address of the object (i.e. the object calling the function) is passed to the member function. This is passed as an argument to the member function. You might be thinking, "We never mentioned any argument in my member function. Where does this argument go?" Actually this is a kind of hidden argument (something that isn’t explicitly stated). Where does this argument go? The hidden argument is the address of the object and hence it has to go to a pointer. What is the name of the pointer? This pointer is called as ‘this’ pointer because it will point to the address of the object which called the member function (it will point to this object or in other words the present object). In an earlier example (the one with a class called ‘car’), we came across the function: void input( ) { cout<<"\nEnter the color : "; cin>>color; cout<<"\nEnter the speed : "; cin>>speed; } This is a member function belonging to the class called ‘car’. ‘color’ and ‘speed’ are member data of that class.

Classes & OOP

292 In reality, the above function is equivalent to: void input( ) { cout<<"\nEnter the color : "; cin>>this->color; cout<<"\nEnter the speed : "; cin>>this->speed; } In fact the compiler will convert our code into something similar (since it has to use the ‘this’ pointer to access the member data of the correct object). The ‘this’ pointer is useful when a member function of a class has to pass the address of the current object to another part of the program (or another function). Beware: The ‘this’ pointer is not present in static member functions. It is also not present in friend functions (because friend functions are not members of a class).

Copy Constructors It’s time to go back to the problem we discussed earlier (the mystery of the default copy constructor). A copy constructor is invoked when you initialize a new object of a class using an existing object. This will happen when: •

You pass a copy of an object as argument to a function (i.e. when passing by value).

•

When you return an object from a function

•

Or initialize an object during declaration using another object.

If we don’t specify a copy constructor, the compiler already has a default copy constructor. This default copy constructor will simply perform a bit-by-bit copy of the original object to the new object (i.e. it will blindly copy everything to the new object). This can lead to problems (especially if you use the ‘new’ and ‘delete’ operators in the constructor and destructor of the class). An example was discussed earlier in this chapter (using the ‘rect’ class). We’ll start by considering the same example: class rect { private: int length, breadth; public: rect( ) { cout<
Classes & OOP

293 length=breadth=0; } rect(int x, int y); void area( ) { cout<
Classes & OOP

294 Let’s try to map the output with the code we wrote: rect ob1(10,9); rect ob2=ob1; rect ob3(ob1); rect ob4; ob4=ob3; We’ve created 4 objects and we have 4 destructors but only 2 constructors. Why? ob1 is created using the parameterized constructor. No problems here since we are calling the constructor directly. ob2 and ob3 do not call the constructor. They are initialized using ob1 and in these 2 cases it is the default copy constructor that is called. ob4 is created using the no argument constructor. Thus we’ve called only 2 constructors and the problem is because of our default copy constructor. What we need to do is to provide our own copy constructor. A copy constructor for the above program would be defined as shown below: rect(const rect &rc) { cout<
Classes & OOP

295 As you can see, the copy constructor is called twice (for ob2 and ob3). That’s good but you might ask, “Why should I worry about this copy constructor?”. We’ll take another example. Let us suppose that we are using the ‘new’ operator in the constructor of the class and ‘delete’ is used in the destructor of the class. We also have a function whose argument is an object of that class. While calling this function, we will pass an existing object to the function. The function will create a temporary object (a copy of the object) but it will not invoke the constructor for this new object. Hence the ‘new’ operator (present in the constructor) is not invoked and an exact replica of the passed object is made. During destruction, the temporary object will invoke the destructor (which has the ‘delete’ operator and it will delete the portion of memory allocated to the original object). When the original object is destroyed, it will also invoke the destructor and this will again try to free the same memory. This can lead to serious problems. To solve this problem we have to define our own copy constructor. Let ‘bacteria’ and ‘virus’ be two classes. Each one will have a variable called ‘life’ created dynamically using the ‘new’ operator. We shall also define a friend function to which we will pass objects of both ‘bacteria’ and ‘virus’. #include class virus; class bacteria { private: int *life; public: bacteria( ) { life=new int; cout<<"\nCreated Bacteria"; *life=1; } ~bacteria( ) { cout<<"\ndestroyed bacteria."; delete life; } friend void check(bacteria, virus); }; class virus { private: int *life; public: virus( )

Classes & OOP

296 { life=new int; cout<<"\nCreated virus"; *life=0; } friend void check(bacteria, virus); ~virus( ) { delete life; cout<<"\ndestroyed virus"; } }; void check (bacteria b, virus v) { if ( (b.life[0]==1) || (v.life[0]==1) ) { cout<<"\nSomething is alive"; } } int main( ) { bacteria fever; virus cholera; check(fever,cholera); return 0; } The output will be: Created Bacteria Created virus Something is alive destroyed bact. destroyed virus And then an error is generated when using VC++ (because the same memory area is being deleted twice)…. In Visual C++ compiler it generates an error during run time and other compilers will also produce something similar (or in the worst case your program could freeze). Anyway, this can lead to drastic effects so you have to program in such a way that this problem does not occur. We’ll add our own copy constructors to both the classes.

Classes & OOP

297 Add the following to the bacteria class: bacteria(const bacteria &ba) { cout<
Classes & OOP

298 life[0]=ba.life[0]; life[1]=ba.life[1]; This ensures that the values will be the same. Now when the temporary object is destroyed, the destructor will be called and memory will be freed. When the original object is destroyed, the destructor is called again and memory (a different area) is freed up. Hence there is no clash of memory. Another question is why do we use const in: bacteria(const bacteria &ba) A copy constructor is used only for the purpose of copying; to initialize a new object based on an existing one. In this case you don’t want the copy constructor to modify the existing object (so we use ‘const’). Note: The above example was purely meant for explaining the idea of copy constructors. You wouldn’t really be creating a variable like ‘life’ dynamically. Another solution: Instead of using the copy constructor we could have taken a more simpler approach as well. The problem arose because we were passing 2 objects to the friend function by value. If we passed them by reference then the compiler would never need to create temporary objects. What should we do to achieve this? First declare the friend function as: friend void check(bacteria &, virus &); and then define it as: void check (bacteria &b, virus &v) { if ( (b.life[0]==1) || (v.life[0]==1) ) { cout<<"\nSomething is alive"; } } Try the program and you’ll get what we actually wanted: Created Bacteria Created virus Something is alive destroyed virus destroyed bact.

Classes & OOP

299 Beware: The copy constructor will not work when you use the assignment operator (=) to assign one object to another. In such cases, you have to overload the = operator to avoid the problem (operator overloading is discussed in the next chapter). If our above program had: int main( ) { bacteria fever; bacteria ecoli; ecoli=fever; return 0; }

//RUN-TIME ERROR

we’ll again get into memory problems because now we are using the assignment operator to copy ‘fever’ to ‘ecoli’. This leads to the same problem we had with copy constructors (both fever and ecoli will now access the same memory location for ‘life’ and both will try to free the same memory location). This just proves the point that when you perform such assignments, the copy constructor does not come into play. Remember: bacteria ecoli=fever; is different from bacteria ecoli; ecoli=fever; The first case is an initialization using an exiting object (copy constructor comes into action) but in the second case we are performing an assignment (assignment operator comes into action).

Classes & OOP

300

Miscellaneous Topics on Classes

The following topics are covered in this section: • • • • •

Returning Objects revisited The keyword 'explicit' Constructor using initializer list Declaration and definition revisited Recap

Returning Objects revisited (return value optimization): Returning an unnamed object (instead of a named object) might help the compiler to optimize the code to improve efficiency. Method I (copy constructor invoked)

Method II Returning an unnamed object

class base { private: int val; public: base(int x=0) { val=x; cout<
class base { private: int val; public: base(int x=0) { val=x; cout<
Classes & OOP

301 OUTPUT: OUTPUT: Constructor; value:5 Constructor; value:6 Copy constructor Destructor; value:6 Destructor; value:6 Destructor; value:5

Constructor; value:5 Constructor; value:6 Destructor; value:6 Destructor; value:5

In the first method we create an object in the function and return it: base btemp(val+1); return btemp; In this case, a constructor and destructor are called for objects ‘b1’ and ‘btemp’. In addition a copy constructor and destructor are called on a temporary object when we return an object from the function: return btemp; In the second method we return an unnamed object directly: return base(val+1); Here neither is an additional destructor called nor is the copy constructor invoked. This is called return value optimization (wherein the compiler is able to avoid the creation of a temporary object; thus improving efficiency). Note: The compiler tries its best to optimize code using various techniques (so that it can reduce work for the processor which in turn helps improve efficiency of our program). Return value optimization is one such optimization technique.

The keyword ‘explicit’ Let’s consider a simple program using classes. The class ‘circle’ has 2 constructors: a single argument constructor and a no argument constructor. #include class circle { private: int radius; public: circle( ) { cout<<"No argument constructor invoked"; radius=0; }

Classes & OOP

302 circle(int x) { cout<<"Single argument constructor invoked"; cout<<"is:"<
Classes & OOP

303 normal scenario). If we didn’t have a single-argument constructor, the compiler would not permit this. For example if our constructor were: circle(int x, int y) instead of circle(int x) then the compiler would give an error message saying “conversion from `int' to non-scalar type `circle' requested” So, what should we do to prevent this implicit conversion from taking place? Should we avoid using a single argument constructor? C++ provides a keyword called ‘explicit’. Instead of the constructor: circle(int x) { cout<<"Single argument constructor invoked"; cout<<"is:"<
When we have a single argument constructor, the compiler might try to perform an implicit conversion to convert an object into an object of the required type. This can be prevented by using the keyword ‘explicit’ in the constructor.

Classes & OOP

304

Constructor using initializer list: The following code: int main( ) { const int x; return 0; } will not compile because a ‘const’ has to be initialized. The compiler error will be: ‘x’ : const object must be initialized if not extern The next code snippet will also produce a compiler error: int main( ) { int x; int &ref; return 0; } This time we have created a reference variable but haven’t initialized it. The error message will be: 'ref' : references must be initialized Keeping these two facts in mind, let’s go back to initializer lists. The constructor for the class can be written as: counter ( ) { count=7; } or we could use the form: counter ( ) : count (7) {} The second method makes use of an initializer list (i.e. count(7) forms the initializer list over here) to initialize the values while the constructor body is empty. The first form isn’t really an initialization; it’s just an assignment. The first form is equivalent to writing: int count; count = 7; Thus the variable ‘count’ is first created and later assigned a value of 7. Initialization means giving a value to the variable at the time of creation; i.e. int count=7; is an initialization.

Classes & OOP

305 To prove that counter ( ) { count=7; } is just an assignment, let’s write a small program. #include class counter { private: const int count; public: counter( ) { count=0; } }; int main( ) { return 0; } Compiling this code you would get at least a couple of errors: 'count' : must be initialized in constructor base/member initializer list l-value specifies const object The second error is produced because of the line: count=0; //A const object cannot be assigned a value. Or you might get the error: assignment of read-only member `counter::count' This program clearly indicates that the constructor we’ve used is simply performing an assignment operation rather than initialization of member data. Let’s modify the code: #include class counter { private: const int count; public: counter( ):count(0) {}

Classes & OOP

306 void display( ) { cout<<"count is:"<
All const and reference member data types have to be initialized using an initializer list. Anything within the body of a constructor is only an assignment and not an initialization. If one class contains another class (i.e. one object contains an object of another type), then you’ll have to initialize the other object in the initializer list.

Beware: When using an initialization list the order in which the members are initialized depends on the order in which you declare them within the class (does not depend on the order specified in the initializer list). The first member in the class will be the first member to be initialized. If your initializations depends on the sequence then be careful while using initializer lists.

Classes & OOP

307

Declaration and Definition revisited: Now we are in a better position to understand these 2 terms (which were introduced in the first chapter itself). Declaration: We tell the compiler that “this is the name of an object of this type which I might use later in my program.” Example: class virus; //class declaration We tell the compiler beforehand that ‘virus’ is a class. int getHealth ( ); //function declaration extern int error_no; //declaration of error_no The last example is used when you are writing code in multiple files (where one part of the code uses variables defined in another file). This will be dealt with later. But the point to note is that in the above 3 cases, we are only declaring something to the compiler (a function, a class and an object). The compiler does not allocate any memory space for them. Definition: Let’s start of with the examples: //Defining a class class virus { private: int life; //rest of the class }; //defining a function int getHealth ( ) { return health; } In a definition we provide the compiler with details. What about the next case? //defining and declaring int error_no; This is what we’ve been using frequently so far. This statement defines error_no (the compiler allocates storage space for it) and also declares error_no as type integer.

Classes & OOP

308

Recap •

The main concepts of OOP are: data abstraction, data encapsulation, inheritance and polymorphism.

•

Classes form the basis for OOP. Using classes, data and the functions that can operate on the data can be bundled together.

•

An object is an instance of a class.

•

The 3 access specfiers used in classes are private, protected and public. These specifiers determine as to who can access the class members.

•

The constructor is a special function invoked when an object is created and the destructor is invoked when the objected is deleted (or destroyed).

•

Every class is provided with a default constructor by the compiler if the programmer doesn’t define any constructor.

•

A constructor without parameters is a default constructor.

•

Constructors can be overloaded using different parameters.

•

When creating an array of objects, the class should have a default constructor.

•

When an object is passed to a function or when an object is returned from a function, a temporary object is created (the temporary object will only invoke the destructor but not the constructor).

•

Friend functions are not members of a class but they can access the private members of the class.

•

Objects can be made constant but they can only access constant functions and they cannot alter the value of member data (unless the member is declared to be ‘mutable’).

•

Static members can be accessed even without using an object.

•

Copy constructors should be defined in a class in case the dynamic memory allocation operators are used in the constructor and destructor.

•

Copy constructors are not invoked in assignments.

•

The ‘explicit’ keyword is used with constructors to prevent implicit conversions.

•

Initializer lists are used to initialize the member data of an object.

Classes & OOP

309

Chapters 7 and 8 (Classes and Pointers) Workshop Quiz

Q.) Predict the output: void change( int *b, int n) { int i; for( i = 0; i < n; i++) { *(b+i) = *(b+i) + 5; } } int main( ) { int a[]={ 2,4,6,8,10 }; int i; change(a,5); for( i = 0; i <= 4; i++) { cout<<“ ”<
2. Q.) do?

What will the program below void func(int *x, int *y) { int *t; t = x; x = y; y = t; } int main( ) { int a=2; int b=3; func(&a,&b); cout<
Answer.) 7

9

11

13

15

A.) I don’t think this should pose much of a problem. We are passing the address of the first element of an array to the function (through a pointer). Within the change ( ) function, we modify each element by adding 5 to it. Hence the output will be: 7

9

11

13

15

Answer.) Nothing On seeing a temporary variable and assignment statement, people jump to the conclusion that the above program will swap the values of two integers. But this is WRONG. The program actually does nothing. void func(int *x, int *y) { int *t; t = x; x = y; y = t; }

Within this function, all we are doing is assigning addresses (we are in no way altering ‘a’ or ‘b’). The output will be: 2 , 3 You could swap the values at a particular address (which is what we always do) but here we are simply using the addresses. Hence ‘a’ and ‘b’ are not swapped.

310 3. Q.) What is the value of ‘sum’ in the program below: int getNewValue(int x) { static int div=1; return(x/++div); } int main( ) { int a[ ]={12,24,45,0,6}; int i; int sum=0; for(i = 0; a[i]; i++) { sum+=getNewValue(a[i]); } cout<
Answer.) 25 There are a few important points to note in the above program. First of all you should note that we can pass individual array elements to functions as shown in the program above. Secondly, as long as the condition (i.e. the middle expression) in the ‘for’ loop is true (or non-zero), the loop will keep repeating. Thirdly, you should know about static variables and also about the prefix ++ operator. The ‘for loop’ will terminate for the case of a[3] because a[3] is 0. The value of sum will be: sum = (12/2) + (24/3) + (45/4) = 25 (because of integer division).

Answer.) Returns the number of characters in the string

4. Q.) What is the use of this function? int len(char *str) { int length=0; while(*str++!='\0') { length++; } return length; }

The use of *str++ might seem confusing. ++ has a higher precedence than * (but it’s better to use parentheses to make it clear- the parentheses have been dropped out here just to make the code appear more complex! Some C++ tests might present similar code fragments). Postfix ++ will increment its operand only after the assignment has been done (i.e. it will occur only in the next statement). Thus when * (the dereferencing operator) is applied, we will check whether the character is a null character or not and then we increment the value of ‘str’ (which means ‘str’ will now point to the next character in the string).

311 Answer.) Garbage values 5. Q.) Can you predict what will happen? int main( ) { int const max=5; int ar[max]={1,2,3,4,5}; int *ptr=&ar[0]; for (int i=0;i
A.) If you are expecting that the output will be 6,7,8,9,10 then you are wrong. Why? ptr was initialized to the address of ar[0]. But within the ‘for’ loop we have kept on incrementing ‘ptr’. Each time the corresponding value at the location is incremented by 5. Once the first loop is complete, ptr is now pointing to the next location beyond ar[4]. Thus in the second loop we are actually displaying garbage values (instead of getting the display of 6,7,8,9,10). If the 2nd loop were: for (i=0;i
6. Q.) Will this compile? void print(int &x) { cout<
print(y); the code might compile on some compilers. But this statement will produce a compile-time error because the compiler wouldn’t be able to decide which print( ) function to call. Some compilers will flag an error saying “parameter list of print(int) is not sufficiently different from print(int &)”. And this is logically true since there is no way in which the compiler will know which function to call.

312 7. Q.) Is there an error? What would be the output? class dummy { private: int data; public: int get_data( ) { return data; } }; int main( ) { dummy d1; cout<
Answer.) Output will be a garbage value The code will compile and execute even though there is no constructor explicitly defined for the class dummy. The compiler will provide with a default constructor. But some beginners are tempted into believing that a default constructor will initialize all member data. This is not true. The above program will display some undefined (garbage) value. To initialize member data correctly, the class designer should define a constructor and not rely on the implicitly created default constructor. Answer.) Compile Error A.) The compiler will complain at the statement: increment(y)=2;

8. Q.) Will the following code compile? If it saying that increment(y) is not an L-value. The will, what is the output? function increment( ) returns an integer which we can use as an R-value, not an L-value. An int increment(int &x) L-value is one which can be used on the left { side of an assignment expression. This in turn x++; means that an L-value should refer in someway return x; to a memory location where a new value can be } stored (after the assignment). Thus in the above code fragment, the statement: int main ( ) { int y=5; increment(y)=2; cout<
increment(y)=2; is equivalent to writing: an-integer-constant=2; where integer-constant could be anything like 1 or 2 or 3 etc. This is illegal since an integer constant is not a memory location.

313 Answer.) Output is 2.

9. Q.) By changing the increment function will it work? int& increment(int &x) { x++; return x; } int main ( ) { int y=5; increment(y)=2; cout<
A.) This will compile since we are returning a reference (and we aren’t returning a reference to a local variable; so the compiler won’t flag a warning). So how does this work and what is the output? ‘y’ is passed as reference to the function increment( ) within which modifying ‘x’ is the same as modifying ‘y’. Thus the value of ‘y’ is incremented to 3. Then we return a reference to x (which is equivalent to returning a reference to ‘y’). Thus the value 2 gets assigned to ‘y’ and the output will be 2. The point to note is that when a function returns a reference, it can be used as an Lvalue.

10. Q.) What is the output? class bacteria { public: static int count;

Answer.) 2 public:

//multiple use of public void modify( ) { count=count+1; cout<
A.) The code will compile (we’ve used ‘public’ twice but this isn’t an error). The output of the code will be 2 (i.e. count will be 2). Since ‘count’ is a public member the statement bacteria::count=1; will modify ‘count’. If ‘count’ were private then the statement would have yielded an error.

314

More questions (classes and pointers)

Interview and Viva questions: Q.) List out the two uses for the & and * operator and also how they differ. Q.) List out the important characteristics of OOP. Q.) Differentiate between a class and an object. Give an example. Q.) What are pointers? Q.) What is the relationship between arrays and pointers? Q.) Should we use reference variables or pointers? Can we use references everywhere instead of pointers? Q.) Why is it better to pass by reference than by value? Q.) Differentiate between the use of ‘public’ and ‘private’ in classes. Q.) Is it that we should always make data private and functions public? Q.) Explain constructors and destructors in classes and why they are needed. Q.) How many constructors and destructors can a class have? Can we overload destructors? Q.) What is a default constructor? Q.) Which method of accessing arrays is more efficient/ faster? (indexing or pointer accessing). Q.) When we pass 2-D arrays to a function why do we need to specify the 2nd dimension in the function declaration? Q.) What is a copy constructor? Should we pass the argument to the copy constructor only by reference? Why? Q.) Does implicit conversion occur only when the class has a single-argument constructor?

315 Programs to try out Q.) Write a program to display the address of an array of integers (the array element values are entered by the user). Q.)Use pointers to reverse a given array of integers. Q.)Sort an array in descending order using pointers. Q.) Write a program to set the value of the entire array to some user-defined value (use an integer array). Q.) Create a class for complex numbers. It should have two member data (for the real and imaginary parts of a complex number). The class should have functions for calculating the magnitude of the number, displaying the complex number and also for obtaining inputs from the user and setting the values for the real and imaginary parts. Q.) Create a class called ‘batsman’ which should contain member data for keeping track of his name, highest and lowest score, number of matches etc. There should be a function to obtain these values from the user and another function to display the details. Q.) Create an employee class which models a real life employee and make use of appropriate class members. Provide parameter and parameter-less constructors for the class. The class should at least consist of the following: employee ID, department, age, salary and experience. Also include a function to calculate bonus for an employee (bonus=10% of salary * experience). Q.) Create a class called ‘student’. It should have provision for the following: •

Obtaining the name, date of birth and marks in 5 subjects for the student.

•

Calculating the current age of the student.

•

Calculating the average marks of the student.

Q.) Create a class called ‘time’. This should have 3 member data: hours,minutes and seconds. There should be functions to reset the time, to add user-entered minutes to the time and calculate the new time (for example if the user inputs 70 minutes then the member function should add 1 hour and 10 minutes to the present time). A function should exist to display the current time. Q.) Write a class to model a 3x3 matrix. This class should have functions to obtain the elements of the matrix, to find the inverse of the matrix and also to find the determinant of the matrix.

Conquering C++ - Part II/II

Contents - PART II Advanced C++ 9.) Operator Overloading • • • • • • • •

Overloading a unary operator • Manipulators (with return data type) • Buffering and Flushing Streams Overloading a binary operator • Formatting flags for manipulators (with arguments) • Creating new manipulators Operator overloading restrictions (custom manipulators) Operator overloading through • Strings (string objects and friend functions character arrays) Overloading a Unary Operator • Mathematical calculations using Friend Function • Good programming practices Overloading the Assignment • Typedef Operator (=) Returning Reference • Bitwise Operators Adding Objects with Built-in (fundamental) data types Overloading ‘new’ and ‘delete’ operators 13.) Advanced Topics

10.) Inheritance • • • • • • • • • •

•

12.) Useful Classes and Functions

Concept of Inheritance Access specifiers Overloading and overriding Virtual Functions Pure Virtual Functions and Abstract classes Can a Destructor be Virtual? Pointers to base and derived classes Multiple Inheritance (multiple base classes) Virtual Base Classes Relationships between classesobject composition and private inheritance More polymorphism (poly polymorphism!)

• • • • • • • • •

Preprocessor directives Namespaces and Headers Multiple file programs Extern (as a storage and linker specifier) Creating Libraries in C++ Exception Handling Templates Casting and cast operators An introduction to STL (Standard Template Library)

14.) General Question and Answers

11.) Files and Streams • • • • • • • • • • • • •

Need for Streams Overloading << and >> Predefined streams Stream Status and status flags Reading the stream status Opening and Closing a file Writing and Reading a Text file Accessing other devices (printer and monitor) through streams Structures in Files Padding/Packing of structures Random Access of Files Sequential Access and Random Access Files Command Line Arguments

Workshop (for units 9-11) • •

Quiz-IV Bonus Questions-IV

15.) Data Structures • • • • • • • • • • • • • • • • • • • •

Linked List Linked List using STL Stacks Queues A closer look at STL Sequence Containers (Vectors) Subscripts and Vectors More functions on Vectors Lists Member functions in Lists Deque Associative Containers Set Container MultiSet Container Map Container Multimap Container Container Adaptors Algorithms Trees Implementing a Binary Tree

•

An intro to analysis of algorithms-I (searching and

(extra programs)

sorting) •

Analysis of algorithms-II

•

Appendix (Working in VC++)

318

Operator Overloading- Intro

The following topics are covered in this section: • •

Intro to operator Overloading Operator overloading with return data type

An Introduction to Operator Overloading Operator overloading means giving additional meaning to normal operators when they are applied to user defined data types. How will the compiler recognize this? The compiler identifies that it is an overloaded operator by looking at the data type of the operand (i.e. if it is a user defined data type then the compiler knows it is an overloaded operator; if it is a built-in data type then the compiler will do the normal operation). You have to remember that objects are defined by you (or the programmer). You choose the data that comes under an object. The data type that you use will be in-built data types like integer or character but the object as a whole is user defined. Hence it is not possible to add two objects (even though they belong to the same class) using the + sign. The addition operator is designed to work only on in-built data types like integers, float etc. It cannot add two objects. But using operator overloading you could use the same + sign to add two objects. Operator overloading is a form of polymorphism (for example, the + operator once overloaded in a class can be used in different ways depending on the operands. If the operands are objects then the overloaded + is used. If the operands are fundamental data types then the normal + operation is carried out). Syntax: return-data-type operator symbol-of-operator (parameters) { //body of the function } Example: void operator ++ ( ) { body of function; } The word ‘operator’ is a keyword and is necessary for overloading an operator. Let us write a program to overload a unary operator (++)

Operator Overloading

319 class timer { private : int countdown; public : timer ( ) : countdown (100) {} int display ( ) { return countdown; } void operator -- ( ) { -- countdown; }

// Constructor

// -- is overloaded operator.

}; int main ( ) { timer c1, c2; cout<<"\nInitial c1 value : "<
Operator Overloading

320

Operator Overloading with return data type Consider the same example as in the previous section. This time we shall make use of the return data type in the operator function to return something to the main ( ) function. class timer { private : int countdown; public : timer ( ) : countdown (100) {} timer (int t) : countdown (t) {} int display ( ) { return countdown; } timer operator -- ( ) { -- countdown; return timer(countdown); using 2nd constructor }

// Constructor with arguments

//unnamed object created

}; int main ( ) { timer c1, c2; cout<<"\nInitial c1 value : "<
Operator Overloading

321 --countdown; return timer(countdown); As in the earlier program, the overloaded operator just decreases the ‘countdown’ value by one. It does the same here. We know that ‘timer’ is the name of the class. Within the braces we have written countdown. In the program countdown of c1 was 100 and then it became 99 because of the --countdown; statement. Now countdown is 99. Hence the return statement is equal to timer (99). This line creates an object without a name (an unnamed object). The constructor with parameters is made use of to initialize this object. The ‘countdown’ value of the unnamed object is initialized to 99. Now all this is supposed to be returned to the calling function. c2 = --c1; c2 is an object and hence the value of count of the unnamed object is stored in c2. So c2's count becomes 99. What do you think will happen if we type: c2 = c1--; instead of: c2 = --c1; We have overloaded for the prefix -- operator and not the postfix -- operator. If you want to overload the postfix operator what should we do? The compiler should be able to distinguish between the two forms and hence according to C++ norms, you should use an integer argument if you want to overload the postfix form of an unary operator. In this case you should modify the function header as: timer operator -- (int x) The integer ‘x’ is just for telling the compiler that this function corresponds to the postfix operator. The same method is used for the unary increment operator ++ also. In case you don’t overload the postfix operator (but have overloaded the prefix operator), and you use the postfix operator, then your compiler might display a warning message and make use of the prefix overloaded form.

Operator Overloading

322

Operator Overloading- II

The following topics are covered in this section: • • • • •

Binary Operator Overloading Restrictions on overloading Overloading using Friend Functions Overloading unary operator using Friend Functions Overloading the assignment operator

Binary Operator Overloading In the case of a unary operator we generally use no arguments. In the case of a binary operator we need to use one argument. // Overloading the binary + operator #include class time { private: int hours,minutes; public: time( ) { hours=0; minutes=0; } time(int x,int y) { hours=x; minutes=y; } void display( ) { cout<=60) { m = m-60; h = h+1;

Operator Overloading

323 } return time(h,m); } int main( ) { time t1(2,40); time t2(3,30); time t3; t3 = t1+t2; t3.display( ); return 0; } Let's take a closer look at the program. The values for hours and minutes of t1 and t2 objects are initialized using the constructor function. The compiler then reads: t3 = t1 + t2; Remember: You cannot simply add two objects and assume that the compiler will add up the corresponding member data. Objects are user-defined data types and the operators will operate only on in-built data types. Thus to operate on user-defined data types, we overload the operator and tell the compiler as to what it should do. On seeing the two operands, the compiler knows that + is overloaded and so it goes to the definition of the operator function. But we have a problem. + works on two operands, t1 and t2. It would appear that we need to pass two values to the operator function so that it can add these two values. But the operator function has only one parameter. What does this mean? It means that only one of the values are passed (i.e. only one object is passed). So, out of the two (t1 and t2) how do we know which one is passed? And what about the other object? The operand to the right of the operator is passed as an argument. Hence the values of hours and minutes of t2 are passed to the operator function. Let's take a look at the first two lines within the operator function. int h = hours + z.hours; int m = minutes + z.minutes; First of all, you know that t2 is passed as an argument. Hence, z actually represents t2 in our case.

Operator Overloading

324 In the expression: int h = hours + z.hours; what does the hours stand for? This hours is the value of t1's hours. t1 is on the left of the operator and it is not passed as argument. Hence hours and minutes refer to the member data of t1. In technical terms: When an overloaded operator is invoked, the object on the left of the operator is the object of which the operator is a member and the object on the right must be provided as argument to the operator. Actually the object on the left of the operand is passed to the operator function (remember the ‘this’ pointer which is always present in member functions; we don’t specify it explicitly, it is like a hidden argument). The ‘this’ pointer is the reason that you don’t need to pass any arguments while overloading unary operators.

Is there anything that cannot be overloaded? Well, almost all operators can be overloaded in C++. You can overload even the [], the comma operator, new, delete etc. But the following operators cannot be overloaded: • • • • •

The dot/member operator (.) The scope resolution operator (::) .* operator Ternary (conditional) operator (?) Sizeof operator

•

You cannot create new operators; you can only overload existing C++ operators. You also cannot overload operators to operate differently on in-built data types (for example: you cannot ask the + operator to operate differently on integers). The operator precedence and associativity remain the same even when overloaded (they cannot be altered).

•

•

If any operator is overloaded in the base class, then any derived class will also inherit the overloaded function. But if the overloaded operator is the assignment operator (=), this will not be inherited by the child class.

•

Whenever you use operator overloading try to retain the original meaning of the operator. For instance when you overload +, overload it in such a way that it will ultimately be adding some data.

Beware: If an operator is a binary operator, then you cannot overload it or convert it into a unary operator.

Operator Overloading

325

Overloading using Friend Functions So far we have overloaded operators using member functions. We can also overload operators using the friend function. Friend functions are not members of the class and they do not have the ‘this’ pointer. Hence when you overload a unary operator you have to pass one argument. When you overload a binary operator you have to pass two arguments. Let’s see that same example that we saw earlier for overloading a binary operator. class time { private: int hours,minutes; public: time( ) { hours=0; minutes=0; } time(int x,int y) { hours=x; minutes=y; } void display( ) { cout<=60) { m = m-60; h = h+1; } return time(h,m); } int main( ) { time t1(2,40); time t2(3,30); time t3; t3 = t1+t2; t3.display( ); return 0; }

Operator Overloading

326 The output will be: 6 hours and 10 minutes Just one point to note here: the operand on the left will be passed as the first argument while the operand on the right will be passed as the second argument.

Overloading a Unary Operator using Friend Function When you overload a unary operator using a friend function you would have to pass one argument to the friend function. Beware: When you use friend functions, they will not have the ‘this’ pointer. If you attempt to modify some value of an object passed as argument, then the friend function actually only operates on a copy (it does not act on the original object). This is because it is passed by value (and not as reference). Thus you would actually have to work on a copy of the object, and then return a newly initialized object having the modified values (we did the same process in using friend function for binary operator overloading). To work directly on the original object, you can make use of reference parameters in the operator overloaded friend function. //Overloading a unary operator using friend function #include class timer { private : int countdown; public : timer ( ) : countdown (100) {} timer (int t) : countdown (t) {} int display ( ) { return countdown; } friend timer operator -- (timer &x); }; timer operator --(timer &x)

Operator Overloading

327 { x.countdown=x.countdown-1; return x; } int main ( ) { timer c1, c2; cout<<"\nInitial c1 value : "<
Overloading the Assignment Operator (=) and returning reference There are some other aspects of operator overloading that will be illustrated in this section by overloading the assignment operator. The assignment operator has to set the left operand value to that of the right operand. Thus, when we equate objects we will want the same process to occur. The following program would seem quite adequate for the purpose: class timer { private : int countdown; public : timer ( ) : countdown (100) {}

Operator Overloading

328 timer (int t) : countdown (t) {} int display ( ) { return countdown; } void operator =(timer &x) { countdown=x.countdown; } }; int main ( ) { timer c1, c2(98),c3(94); cout<<"\nInitial c1 value : "<
Operator Overloading

329 c2 = c3; Hence c2 will get the values of c3. But this evaluation does not return anything and the next step for the compiler will be: c1 = void; and this is not possible. Thus you have to overload the assignment operator such that it will return something (it should return an object of course). class timer { private : int countdown; public : timer ( ) : countdown (100) {} timer (int t) : countdown (t) {} int display ( ) { return countdown; } timer& operator =(timer &x) { countdown=x.countdown; return *this; } }; int main ( ) { timer c1, c2(98),c3(94); cout<<"\nInitial c1 value : "<
Operator Overloading

330 The output is: Initial c1 value : 100 Initial c2 value : 98 Initial c3 value : 94 Final c1 value : 94 Final c2 value : 94 Final c3 value : 94 Within the function parameter we use & to represent a pass by reference. Similarly, here in this program we also return a reference (which is indicated by timer&). timer& operator =(timer &x) Now when the compiler encounters: c1 = c2 = c3; It will first evaluate: c2 = c3; and it will not only assign c3 to c2, but will also return c2 (c2 was the object that invoked the operator member function and ‘this’ refers to c2). The next step will now be: c1 = c2; and your program will work perfectly. The overloaded = operator now performs two operations: assignment as well as returning a reference to the object that invoked the overloaded operator function. Maybe you are wondering, why not return a pointer to type ‘timer’ instead of using references for returning? Again, c2 = c3 will work but the overall expression: c1 = c2 = c3; will not work since the expression will reduce to: c1 = pointer; and this is wrong!

Operator Overloading

331

Operator Overloading- III

The following topics are covered in this section: • • •

Adding object with fundamental data types Overloading new and delete operators Recap

Adding Objects with Built-in (fundamental) data types So far we’ve seen binary operators operating on two objects. Now we’ll see how to overload a binary operator such that it will add an object along with an integer (which is a fundamental data type). class timer { private : int countdown; public : timer ( ) : countdown (100) {} timer (int t) : countdown (t) {} int display ( ) { return countdown; } timer& operator+ (int j) { countdown=countdown+j; return *this; } }; int main ( ) { timer c1, c2(98),c3(94); cout<<"\nInitial c1 value : "<
Operator Overloading

332 The output is: Initial c1 value : 100 Initial c2 value : 98 Initial c3 value : 94 Final c1 value : 200 Final c2 value : 98 Final c3 value : 94 When the compiler encounters: c1+100; it knows that the object c1 is invoking the operator+ member function. This function has an integer as its argument and 100 is passed by value to the integer ‘j’. The rest of the program is as normal. Another point to note is about the drawback of using the overloaded operator function as a member function. In the above program if you tried: 100 + c1; it wouldn’t work! Why? Because according to what we’ve learnt in operator overloading, the object on the left of the operator will invoke the overloaded member function. But now the operand on the left of the operator is an integer and the compiler does not know what to do. The problem is because the operator+ function is a member function of the class and it is passed the ‘this’ pointer. The problem can be avoided if you made use of friend functions. In friend functions the ‘this’ pointer is not passed (and they are not members of the class). So you can specify the order of the arguments when you overload an operator using a friend function. The program below illustrates the use of friend function to solve this problem: #include class timer { private : int countdown; public : timer ( ) : countdown (100) {} timer (int t) : countdown (t) {} int display ( ) { return countdown; } friend timer& operator+ (int, timer&); friend timer& operator+ (timer&, int);

Operator Overloading

333 }; timer& operator+ (int j, timer &x) { x.countdown=x.countdown+j; timer *p=&x; return *p; } timer& operator+ (timer &y, int k) { y.countdown=y.countdown+k; timer *pt=&y; return *pt; } int main ( ) { timer c1, c2(98),c3(94); cout<<"\nInitial c1 value : "<
Operator Overloading

334 timer operator+ (int j, timer &x) { x.countdown = x.countdown+j; return x; } Well, this is quite correct but you have to bear in mind that the copy constructor is invoked each time you return an object from a function (which means that the destructor will be copied exactly to a temporary object bit by bit). Try it: You can check this idea by creating your destructor function for the class. Whenever you return an object from a function, you will see that the destructor function is invoked whereas if you return a reference to an object, the destructor function will not be invoked. In the above program this won’t cause any problems because we are not making use of the ‘new’ and ‘delete’ operators. But in case you make use of them then you should take note of this point. The same is the reason for using pass by reference in the above program.

Overloading ‘new’ and ‘delete’ operators The ‘new’ and ‘delete’ operators are usually sufficient for most programs but there might be cases wherein you want to overload them as well. Some important points are: •

You can overload these operators globally or you can overload them for specific classes. If you overload using member function for a class then we say that you have overloaded only for that specific class. If overloading is done outside a class (i.e. it is not a member function of a class), the overloaded ‘new’ and ‘delete’ will be called anytime you make use of these operators (within classes or outside classes). This is global overloading.

•

Be careful if you overload ‘new’ and ‘delete’ globally (because there might be other parts of your program which rely on the normal operation of these operators). Usually programmers do not overload them globally. malloc( ) and free ( ) are the C equivalent of ‘new’ and ‘delete’ respectively. To use these functions you will need to include the stdlib.h header file.

•

The syntax for overloading ‘new’ and ‘delete’ are: void* operator new (size_t n) { //allocate memory and return the address (a void pointer) } void operator delete (void *p) { //free the memory space pointer to by the pointer ‘p’ }

Operator Overloading

335 You will notice that the parameter for ‘new’ is: size_t n; size_t is a numerical data type defined by the system to specify memory size in bytes. For instance if you use ‘new’ to create a character, the value of n (i.e. the argument passed to ‘n’) will be 1. If you pass a ‘double’ quantity then the value of ‘n’ will be 8 (you needn’t worry about this). •

The ‘new’ operator should return a void pointer while the ‘delete’ operator will pass a void pointer as argument.

The program below overloads the ‘new’ and ‘delete’ operators globally. #include #include void* operator new(size_t n) { cout<
Operator Overloading

336 We make use of C functions malloc( ) and free ( ) to overload the ‘new’ and ‘delete’ operators in the above program. •

The above overloading of ‘new’ and ‘delete’ will not overload the ‘new’ and ‘delete’ used for arrays. For arrays we make use of the ‘new [ ]’ and ‘delete [ ]’ operator and you have to overload these separately. The syntax is similar but you should specify [ ] to denote arrays. The syntax for overloading ‘new [ ]’ and ‘delete [ ]’ are: void* operator new [ ] (size_t n) { //allocate memory and return the address (a void pointer) } void operator delete [ ] (void *p) { //free the memory space pointer to by the pointer ‘p’ }

Recap • • • • • • •

Overloading is the process of giving additional meaning to existing operators. Operator overloading is done so that the various C++ operators can be used on user-defined data types. New operators cannot be created using operator overloading. When overloading is done through member functions, one argument is automatically passed to the overloading function (through the ‘this’ pointer). Binary operator overloading member functions should have one parameter while unary operator overloading member functions don’t need any parameters. Friend functions can also be used for operator overloading (but in this case the ‘this’ pointer is not passed to the function). Friend functions to overload unary operators should have one parameter while two parameters are needed for binary operator overloading through friend functions.

Operator Overloading

337

Inheritance- intro The following topics are covered in this section: • •

Introduction Access Specifiers

Inheritance Inheritance means getting something from the parent. In C++ also, inheritance means the same. But who is the parent? Remember that classes and objects are a key feature in C++. When we talk of inheritance in C++, we refer to classes. We will have the parent class and the derived class. The derived class inherits all properties of the parent class. The parent class is also known as the base class. All classes that arise from the base class are known as derived classes. These derived classes inherit all non-private parts of the base class (i.e. there are a few things that cannot be inherited from the base class. This is discussed later). We have discussed earlier about a general class called ‘bacteria’. We also referred to two other classes called Ecoli and TB. Now, bacteria will form the base class while ecoli and TB will be derived from the bacteria class. In this way they will inherit all the general properties of a bacteria. In addition they will have their own special features (in our case they would have a special member function to describe the unique way in which they move).

You might wonder as to whether the child inherits everything from the parent? The derived class inherits everything that is NOT PRIVATE in the parent class. Remember we used ‘private’ and ‘public’ to restrict access to class members. Now when you declare any member as ‘private’, that member cannot be inherited by any of the children (in other words, private members are not inheritable). Only the ‘public’ members are inheritable.

Inheritance

338 When any data is made private in a class, it can be accessed ONLY by member functions of that class. A derived class CANNOT access the private members of its base class. It might seem as if the concept of data encapsulation would be lost if a derived class can access only it’s parent’s public members (because the aim of classes is to restrict access to data and hence we make them public. But if we can’t inherit the private data, what’s the use of inheritance?). C++ provides us with a third access specifier called ‘protected’. The three access specifiers for class members are: • • •

private public protected

If you declare class members as ‘protected’, then any class derived from the parent can access the protected members but no one from outside can make use of the protected members. In a way protected members are similar to private class members (because both cannot be accessed from outside the class). But both are different because protected members can be accessed by derived classes whereas private members cannot be accessed by derived classes. The use of protected access specifier is very important in inheritance. Let's take a look at the syntax for making a derived class. Create the base class as you normally would. Then when you want to create the derived class, use the following syntax: class d1 : public b1 { //body of d1; }; where d1 is the name of the derived class and b1 is the name of the base class. Let’s consider a different example for inheritance (instead of bacteria and biology). Consider cars: there are different types of cars in the world. Broadly we could divide them into two categories: normal cars and racing cars. Both of these categories belong to the same family of cars (since all cars will have some properties in common). Though they are common in certain respects they will have their own properties as well. Thus these two categories of cars can be derived from the general class of cars. Again within racing cars we have different manufacturers (and each manufacturer might make use of different specifications). For instance a ‘Ferrari’ and a ‘McLaren’ are not one and the same (even though both are racing cars). Thus let’s model a general class called ‘car’ (which will refer to racing cars). We will provide this class with only two properties: color and speed. From this class, we shall derive two classes called ‘Ferrari’ and ‘McLaren’.

Inheritance

339

From the above figure, it can be said that, “an object of type Ferrari is a RacingCar”. This is referred to as “is-a” relationship. The various types of relationships are:

• is a • has a • is implemented in terms of Remember: Every Ferrari is a car but not every car is a Ferrari. When designing relationships between classes, ideally, whatever the parent can do the child should be able to do (this is the ‘is-a’ relationship). // Program to demonstrate inheritance #include class car { protected: int speed; char color[20]; public: car( ) { cout<<"\nCreating a Car"; } ~car( ) { cout<<"\nDestroying Car"; } void input( ) { cout<<"\n\nEnter the colour of your car : "; cin>>color; cout<<"\nEnter the top speed : "; cin>>speed; } };

Inheritance

340 class ferrari : public car { private: int f; public: ferrari( ) { cout<<"\nCreating a Ferrari"; } ~ferrari( ) { cout<<"\nDestroying the Ferrari"; } }; class mclaren : public car { private: int m; public: mclaren( ) { cout<<"\nCreating a McLaren"; } ~mclaren( ) { cout<<"\nDestroying the McLaren"; } }; int main( ) { ferrari mine; mine.input( ); return 0; } Protected data will be inherited by the derived classes. Both the member data (speed and color) of the base class ‘car’ are protected. Thus all classes derived from ‘car’ will also have the property of ‘speed’ and ‘color’. You might be wondering as to how the constructors and destructors will execute and in what order? The output would be: Creating a Car Creating a Ferrari Enter the colour of your car : red Enter the top speed : 150 Destroying the Ferrari Destroying Car

Inheritance

341 As can be seen, constructors execute from the top to bottom while the destructors execute in the reverse order. It’s like you will first construct a car and then label it as a Ferrari and while destroying you would remove the label Ferrari first and then dismantle the car. Remember: The constructor of the base class and also the destructor will be invoked.

More on Inheritance (Base-Class Access specifier) So far we have used the following syntax for inheritance: class derived-name: public base-name { //body of class; }; where derived-name is the name of the derived class and base-name is the name of the base class. We have already dealt with access specifiers as used for class members. The type of access specifier used determines how the members of a class are accessed (i.e. whether they can be accessed from outside, or whether their access is restricted to class members or whether they can be accessed by derived classes). The 3 types of access specifiers are: • • •

private protected public

These 3 access specifiers can be used to determine how the derived class will access the properties derived from the base class. The general syntax for inheritance is thus as given below: class name-of-derived-class : access-specifier name-of-base-class { //body of derived class; }; We know that the derived class cannot access the private members of the base class. But what about the protected and public members of the base class? Do they become private members of the derived class? It is for clarifying this that we have to use an accessspecifier to specify what we want the inherited members to become. 1. If you use the access specifier ‘public’: All the public members of the base class become public members of the derived class. The protected members become protected members of the derived class. 2. When you use ‘private’ as the access specifier: All public members of base class become private members of derived class. All protected members of base class also become private members of derived class. 3. When the base class is accessed as ‘protected’: All the public and protected members of base class become protected members of derived class.

Inheritance

342

Inheritance- II The following topics are covered in this section: • • • •

Overloading and Overriding Virtual Functions Pure Virtual functions Implementing Polymorphism

Overloading and Overriding There are a few terms that are repeatedly used in C++ programming; you could call them C++ programming jargon and you’ll find references to these words often. Overloading and overriding belong to that category and it is important to know the difference between these two terms. We have already discussed about function overloading. In overloading, though the function names are the same, the functions will have different types of parameters. Thus depending on the types of arguments, the compiler will correctly choose between the functions when they have the same name. So, what is overriding? Overriding occurs when the functions have the same name and same return type. You might wonder as to how the compiler will distinguish between functions that have the same name and arguments. Actually in this case the compiler will not be able to decide which function to use while compiling. The choice is made at run-time. Overriding is related to inheritance and is implemented using virtual functions.

The problem Let’s take a simple problem. We want to write a program that will ask the user as to what they want to create: a general car or a ferrari. Depending on the user’s input we want to display some details of the car. (The example might seem a bit trivial but it should give you a good idea about the problem we are going to face). We’ll make use of a base class pointer in this program. The topic on pointers and inheritance is discussed later but for the time being just remember that a base class pointer can point to an object of the base class as well an object of the derived class. #include class car { protected: int speed; char color[20]; public: void display( ) { cout<<"\nThis is a general Car"; } };

Inheritance

343 class ferrari : public car { public: void display( ) { cout<<"\nThis is a Ferrari"; } }; int main( ) { char choice; car *ptr; cout<>choice; if (choice=='g') { ptr=new car; } else if (choice=='f') { ptr=new ferrari; } else { cout<
Inheritance

344

Virtual Function (late/dynamic binding) A virtual function is a member function of a base class, which is redefined by a derived class. You need to make use of the keyword ‘virtual’, to make a function virtual. The function is redefined in the derived class to meet the needs of the derived class. The main advantage of virtual function is that they support run-time polymorphism. #include class car { protected: int speed; char color[20]; public: virtual void display( ) { cout<<"\nThis is a general Car"; } }; class ferrari:public car { public: void display( ) { cout<<"\nThis is a Ferrari"; } }; class mclaren:public car { public: void display( ) { cout<<"\nThis is a McLaren"; } }; int main( ) { car *p; car mine; ferrari f; mclaren m; p=&mine; p->display( ); p=&f; p->display( ); p=&m; p->display( ); return 0; }

Inheritance

345 The output would be: This is a general Car This is a Ferrari This is a McLaren The function display ( ) is made virtual. Notice that the ‘virtual’ keyword is used only in the base class’ display ( ) function. The derived classes ‘ferrari’ and ‘mclaren’, redefine the display ( ) function. car *p; We are creating a pointer to point to ‘car’ (which is a class). Hence you can say that ‘p’ is pointing to an object of type ‘car’. A pointer which points to an object of the base class, can point to an object of a derived class. But the reverse is not possible. The next statement is: p = &mine; This assigns the address of the object ‘mine’ to the pointer ‘p’. Remember that ‘p’ is a pointer to ‘car’ type and ‘mine’ is an object of type ‘car’. So there's no problem in this assignment. Pointers can be used to invoke member functions. Invoking in this way is done by using the following operator: -> (it is a minus followed by the less than sign. It is called the arrow operator). Since ‘p’ is pointing to an object of type ‘car’, the display( ) function of the base class will be executed. If ‘p’ were an object of type ‘car’, we would call the member function using the dot operator: p.display( ); But since it is a pointer, you have to call it using the arrow operator. The next statement is: p = &f; A pointer to object of the parent class can point to an object of a derived class. ‘f’ is an object of the class ‘ferrari’ (which is derived from ‘car’). Therefore, p can point to ‘f’ and the address of ‘f’ is now assigned to p. When the display ( ) function is now invoked through the pointer ‘p’, the compiler will run the derived class’ version of the display ( ) function. This decision of choosing which function to execute is made at run-time. Hence this is known as run-time polymorphism. In effect you are actually overriding the existing base class display ( ) function. This not overloading because the name of the function, the return datatype and the parameters of the function in the parent as well as the derived class are the same. Another term used is ‘late binding’. In this situation ‘binding’ refers to the decision that has to be made regarding which function should be called (this depends on the type of object pointed to by the pointer and it can be determined only at run-time). This method of using virtual functions helps achieve ‘late binding’ (i.e. the function call is not resolved till the program is run). The opposite of late binding is ‘early binding’ and in this case everything about the function call is known at compile-time itself. All the member functions called through the normal use of the dot operator are examples of early binding. The advantage of early binding is that it will make the program faster (since everything is determined at

Inheritance

346 compile-time itself). In ‘late binding’ the decision has to be made at run-time and hence execution of the program could be slower. But ‘late binding’ provides a lot of flexibility. ‘Late binding’ is also sometimes called ‘dynamic binding’ and ‘early binding’ is called ‘static binding’. What will happen if we don’t redefine a virtual function in the derived class? If you don’t redefine a virtual function in the derived class, the derived class will execute the base class’ function.

Pure Virtual Functions and Abstract Classes One very useful feature of virtual functions is creating pure virtual functions. When a virtual function is equated to zero, it becomes pure virtual. For example: #include class car { protected: int speed; char color[20]; public: virtual void display( )=0; //Pure virtual Function }; class ferrari:public car { public: void display( ) { cout<<"\nThis is a Ferrari"; } }; class mclaren:public car { public: void display( ) { cout<<"\nThis is a McLaren"; } }; int main( ) { car *p; ferrari f; mclaren m; p=&f; p->display( ); p=&m; p->display( ); return 0; }

Inheritance

347 The output is: This is a Ferrari This is a McLaren The advantages of pure virtual functions are: • •

•

You have to redefine the virtual function in your derived class. You cannot create an object from a class having a pure virtual function. Such classes are called as abstract classes. In the above example we cannot create an object of the type ‘car’. If you don’t define your virtual function in your derived class, then the derived class will also become an abstract class (and you cannot create any objects of this as well).

There are cases where you might not want to create objects belonging to the base class and you might feel that a particular function would make no sense in the base class. In all these cases you can make use of pure virtual functions in the base class. If you go back to the example of the class ‘bacteria’, it wouldn’t make sense to create a concrete object belonging to the class ‘bacteria’. You will want to create particular strains of bacteria but not general bacteria objects and in this case the bacteria class can be made abstract so that no one can ever create an object of type bacteria (the users of your class can thus only create objects belonging to classes derived from ‘bacteria’).

Implementing Polymorphism Polymorphism has already been explained in the Chapter on classes. Polymorphism is simply giving different meanings to the same name (in C++ this can be a function or an operator). C++ supports compile time and run-time polymorphism. Polymorphism tends to be associated frequently only with virtual functions (late/dynamic binding). But C++ implements polymorphism in a number of ways. They are through the use of: • • • •

Operator overloading Function Overloading Virtual Functions Templates

We have already seen three of these methods. Templates will be described in Chapter 13. It has to be noted that run-time polymorphism is implemented only through the use of virtual functions. Polymorphism that is implemented through mechanisms other than virtual functions (like operator and function overloading) is also called "ad hoc polymorphism".

Inheritance

348

Inheritance- III The following topics are covered in this section: • •

Virtual Destructor Pointers to base and derived classes

Can a Destructor be Virtual? We’ve seen about classes and we’ve also dealt with inheritance. But there is one case that we haven’t seen as yet. Let’s go back to the class called ‘car’ and let’s assume that we have one derived class from ‘car’ called ‘ferrari’. If you create an instance of ferrari, then when the ferrari object is destroyed this will invoke 2 destructors (the ‘ferrari’ class destructor and the ‘car’ class destructor). Suppose we create an object of ‘ferrari’ using the ‘new’ operator and the pointer is of the base class’ type (i.e. the pointer is of type ‘car’). What do you think will happen? Just see the coding below so that you get an idea of the problem: #include class car { private: int speed; char color[20]; public: ~car( ) { cout<<"\nDestroying the Car"; } }; class ferrari:public car { public: ferrari( ) { cout<<"Creating a Ferrari"; } ~ferrari( ) { cout<<"\nDestroying the Ferrari"; } }; int main( ) { car *p = new ferrari; delete p; return 0; }

Inheritance

349 You can be sure that a new ferrari object has been created. The question is: does the ferrari object really get destroyed? The output for the above program would be: Creating a Ferrar Destroying the Car Surprised? The ferrari object hasn’t been destroyed though the object was created. The problem is that since we are using a pointer to the base class the compiler tends to only invoke the base destructor when you delete it. How to overcome this problem? This is where we have to make the destructor virtual. By making the destructor virtual, the correct destructor will be called in the program. A destructor is just like any other member function; so to make it virtual just precede the base class destructor by the keyword ‘virtual’. Check out this modified program: class car { private: int speed; char color[20]; public: virtual ~car( ) { cout<<"\nDestroying the Car"; } }; class ferrari:public car { public: ferrari( ) { cout<<"Creating a Ferrari"; } ~ferrari( ) { cout<<"\nDestroying the Ferrari"; } }; int main( ) { car *p = new ferrari; delete p; return 0; } The output would now be: Creating a Ferrari Destroying the Ferrari Destroying the Car This is what we call virtual destructor in C++.

Inheritance

350

Pointers to base and derived classes “Every Ferrari is a car but not every car is a Ferrari”. We’ve seen how to create pointers to objects and how to use them to access member functions. Now the question arises what will happen if we create a pointer to an object of base class and then point to an object of a derived class? What if we do the reverse? Upcasting: a derived class being treated like the base class (going up the hierarchy). Downcasting: a base class being treated like a derived class (going down the hierarchy). Consider the following example: class car { protected: int speed; public: car( ) { speed=100; } void display( ) { cout<<"\nSpeed of general car is : "<
Inheritance

351 int main( ) { car *cp; car c; ferrari f; cp=&c; cp->display( );

// Speed of car is : 100

cp=&f; cp->display( );

//pointing to derived object // Speed of car is : 200

cp->change( );

//ERROR – change ( ) not present in class ‘car’

return 0; } Compiling the code throws an error on the line: cp->change( );

The reason for this error is that ‘cp’ is a pointer to the base class. The base class ‘car’ does not have a function change ( ) and so even though ‘cp’ is now pointing to a derived object, it cannot call the change ( ) function of the derived class. Remember: A base class pointer cannot access a member which is not present in the base class (even though it points to a derived type). We’ll take a look at the reason for this once we learn about virtual functions. The term ‘upcasting’ is used when we consider a derived class object as a base class object (we treat a Ferrari as a car; or a teacher as an employee; or a student as a person etc.). Since we are going up the inheritance hierarchy tree (from derived to base), we call this upcasting. This is a very useful feature because any function that operates on the base class will be capable of operating on the derived class as well. Upcasting is what you will come across when we discuss polymorphism using virtual functions. The drawback is that upcasting can lead to object slicing (we’ll take a look at this later). The opposite of upcasting is downcasting and it is dangerous. It is dangerous to consider every employee as a teacher or every person as a student because the base class will not have the specializations of the derived class. Downcasting would’ve been acceptable if every person can be considered a student – in that case every person will have properties like student ID number, courses opted for etc. But this isn’t correct because every person is not a student. A person who isn’t a student will not have these attributes. So if we have a member function in class student to display these attributes, then invoking this function on an object of type person will lead to unpredictable results. Thus downcasting is dangerous. If we comment out the code: cp->change( );

and then compile and execute the above code, we’ll get an interesting output:

Inheritance

352 Speed of general car is : 100 Speed of general car is : 200 What’s wrong? It’s actually the base class’ display( ) function which has been called twice; the derived class’ display( ) function has never been called. If it were called the output should have been: Speed of general car is : 100 Speed of ferrari is : 200 Thus we can come to the conclusion: cp=&f; cp->display( );

isn’t performing what we expect. If ‘cp’ is pointing to the ferrari object then it should have used the display( ) function present in the class ferrari! Another doubt that you might have is: “How is the value of speed correctly displayed in the output?” Speed of general car is : 100 Speed of general car is : 200 If the pointer ‘cp’ were still pointing to the base class object then it should have displayed: Speed of general car is : 100 Speed of general car is : 100 But since we have a display of the value 200, it indicates that ‘cp’ does really point to the ferrari object after the statement: cp=&f; The only problem is that the wrong display function is being called. The function is wrong but member data is correct! Two parts to this answer: 1.) The concept of early binding decides what definition to be called – the compiler decides at compile time what function definition to be used. The compiler thinks like this: “I don’t see any instruction for late binding and cp is a pointer to type car. So I shall use the display( ) function defined in the base class car”. More on this in the section on virtual functions that follows. 2.) The data is correct because of the way objects are stored in memory. The relative position of the data ‘speed’ in the base class and derived class is the same; so since we changed the address of cp to ‘f’, the member data access will be that of the derived object.

Inheritance

353

Inheritance- IV The following topics are covered in this section: • •

Multiple Inheritance Virtual Base Class

Multiple Inheritance When we have more than one base class for a derived class, we call it as multiple inheritance. So far we have only seen the case where a derived class has one base class. In this section we will deal with the features and problems associated with multiple inheritance. Some programmers advise against the use of multiple inheritance. In fact Java does not permit multiple inheritance. For a basic explanation about multiple inheritance, assume that you have created two classes called ‘bacteria’ and ‘virus’ to model the two different life forms. Now, maybe you discover a new life form that has the features of both bacteria and virus. Instead of creating a new class with all the properties again you can simply derive a new class from both bacteria and virus (hence bacteria and virus will be the two base classes). Let’s call the derived class as ‘crossbreed’. The program is written below: class bacteria { protected: int x; public: bacteria( ) { cout<
Inheritance

354 class crossbreed:public bacteria, public virus { public: crossbreed( ) { bacteria::x=10; cout<
Inheritance

355 then the base class virtual function would have been executed. But in this case there are two base classes and the compiler will produce an error (because it won’t know which base class function to execute). This is one of the problems with multiple inheritance.

Virtual Base Class There is another problem associated with multiple inheritance. There is a good chance that your derived class can have more than one copy of the base class. Consider three classes as shown in the figure below:

The following diagram is better suited to explain the problem inherent in multiple inheritance. mainbase

mainbase

base1

base2

derived

The problem with the above form of inheritance is that both base1 and base2 will have a copy of the class ‘mainbase’. When the class ‘derived’ is obtained from these two classes, it will end up with two copies of ‘mainbase’. If mainbase had a member data called ‘count’, then ‘derived’ class cannot access the member ‘count’ by saying: count=1; The ‘derived’ class has to specify which copy of ‘count’ it wants to access using the scope resolution operator.

Inheritance

356 base1::count=1; Mostly you wouldn’t want such a case and so C++ introduces virtual base class to prevent the ‘derived’ class from obtaining two copies of the same class. You can specify in the derived class that the base classes are ‘virtual’. Check out the example below: #include class mainbase { protected: int count; public: mainbase( ) { count=0; } }; class base1 : virtual public mainbase { }; class base2 : virtual public mainbase { }; class derived : public base1, public base2 { public: void set( ) { count=1; cout<
Inheritance

357 Alternative Representation of Inheritance: In all the earlier figures for inheritance we have used a downward pointing arrow to denote inheritance. The following representation is also used for inheritance:

In this case the arrow points from the subclass to the superclass. This also means that the class or RacingCars is inherited (or derived) from the GeneralCars class. Do not get confused with the two methods of representing inheritance.

Inheritance

358

Inheritance- V The following topics are covered in this section: • • •

Relationships between classes (isa, hasa, is implemented in terms of) Reinforcing OOP concepts Recap

Relationships between Classes (Object composition and private inheritance): Let’s take the following scenario: • We’ve modeled an engine as a class. • We’ve modeled a wheel as another class. • Engine and wheel are not related to each other (that’s quite obvious). Now we want to model a class called car. Let’s say our first requirement is that a car has an engine. We already have an engine class but how should we use it within the class car? We might be tempted to do the following: class engine {//engine class specifications }; class car: public engine {//define this class }; Now we have established a relationship between the car and the engine. Next we need to relate wheel with car. After all, a car has wheels. So we might be tempted to do the following: class car: public engine, public wheel { //define this class }; That seems good. “But wait a minute”, you say. “A car has 4 wheels. How do we represent that in this relationship?” That’s a very good observation and leads us to the fact that our modeling has a major flaw. The way we’ve created the relation between car and engine was wrong in the first place. Why? Let’s go back to the beginning of this chapter where we said: “A Ferrari is a car”. Then we proceeded to derive Ferrari from a car because a Ferrari is a highly specialized version of a car. Or another example is the class ‘employee’ and ‘accountant’. An accountant is an employee (a specialized employee trained in accounting). The key words are “is a”.

Inheritance

359 If we coded: class accountant: public employee then it is equivalent to the statement “An accountant is an employee”. So when we coded: class car: public engine this actually means that “a car is an engine!”. Voila! That’s the mistake; a car isn’t an engine. A car has an engine. Similarly a car has wheels (a car isn’t a wheel). Sometimes we might be able to get the desired functionality in the wrong way. If our car didn’t have wheels then class car: public engine might still be sufficient for us. After all, a car has only one engine. But again, the means of achieving the result is wrong and it can lead to disastrous side effects. It would also mislead anyone who reads your code later (they would assume that a car is an engine). So, in this scenario public inheritance won’t work. The ‘has a’ relationship is called composition. A car is composed of an engine, 4 wheels, a steering wheel etc. Or in other words, a car has an engine; a car has 4 wheels; a car has a steering wheel and so on. In C++ this “has a” relationship can be expressed using object containment (or object composition). It’s quite simple: class car { private: wheel bridgestone[4]; engine honda; };

Well, wasn’t that easy! We are able to model the real world car just as we desired. Note: The relationship between classes (‘is a’, ‘has a’ etc.) are not something specific to C++. They are part of the Object Oriented principles. So if you happen to read any books/ tutorials on object oriented programming you are bound come across these terms. In object oriented terminology, we have different forms of composition. They are called composition, association and aggregation. They all have subtle variations but as far as C++ is concerned you needn’t worry about them. The main idea is the concept of whole and part. In our example the car is the whole entity and the parts are the engine, wheel etc. The whole entity is composed of many parts.

Inheritance

360 Let’s take an example to illustrate object composition: class engine { private: //status denotes whether engine is ON or OFF //width specifies one dimension of the engine int status; int width; public: engine(int wd=5) { status=0; width=wd; cout<
Inheritance

361 The output is: Engine created with width:20 Starting the car Starting the engine Car destroyed Engine destroyed A few points to note in the above example: 1.)

car( ):honda(20) {}

To initialize the engine object honda, we’ve made use of an initializer list in the class car. This is one use of an initializer list (the same cannot be implemented in a constructor body). 2.) The constructor and destructor of the class engine are invoked automatically upon creating a car object. 3.) The engine object honda cannot be directly accessed by the user of the class car (because it is lying inside the private region of car). Of course the user can create a stand-alone engine but cannot manipulate the engine present in a car. In our example, we want to provide an interface for starting the car (not for starting the engine). If we permitted that (by making engine honda public), then the user can start the engine and then start the car (which is not what we want). Thus: mycar.honda.start( ); //is now illegal mycar.start( ); //is the only way to start the car (and engine) If you remember, there were 3 relationships listed in the beginning of this chapter: 1. is a 2. has a 3. is implemented in terms of The first 2 relations should be clear to you by now. We’ve encountered the following statement a couple of times already: • Every Ferrari is a car (but not every car is a Ferrari). Some similar statements would be: • Every teacher is an employee (but not every employee need be a teacher). • Every student is a person (but not every person is a student) The words “is a” are important in these statements. When we establish an “is a” relationship between 2 objects it means that we should inherit from the base class using the public access specifier.

Inheritance

362 Ex:

class employee { //class definition };

class teacher: public employee { //class definition }; According to the above relationship, whatever an employee can do a teacher can also do (that is the basis of an ‘is-a’ relationship). Or as far as the programming language is concerned, a function which takes an employee as argument can take a teacher as argument (but a function taking a teacher as argument can’t take an employee as argument). Every teacher is an employee but not every employee is a teacher. Thus public inheritance helps incorporate the ‘is-a’ relationship in C++. We also know that instead of public inheritance, we can inherit another class as private or protected (called private inheritance and protected inheritance). So, what does the following mean? class employee { //class definition }; class teacher: private employee { //class definition }; Going back to our example about an engine and a car, we decided not to use public inheritance because it gave the meaning: a car is an engine. But what about private/protected inheritance? The following examples illustrate some of the difference between public and private inheritance: 1.) A room isn’t a door. class door {}; class room:private door {}; void common_func(door d) {} int main( ) { door d1; room r1;

Inheritance

363 common_func(d1); common_func(r1); return 0; }

If the derived class were inherited publicly then the function call: common_func(r1); will work fine because of the “is a” relationship. But in our program, the compiler complains: conversion from 'class room *' to 'const class door &' exists, but is inaccessible When we use private inheritance, everything in the base class becomes private in the derived class and so the conversion from derived to base isn’t possible. In an “is a” relationship, any function which operates on the base class can operate on the derived class (or in other words whatever a car can do, a Ferrari can also do). But in private inheritance this doesn’t hold true. 2.) Another difference is that the public members of the base class now become private in the derived class. Now a user cannot open the door twice! class door { public: void open( ) { cout<
The output is: Door opened Room opened Door opened

Inheritance

//permitted. Not an error

364 Actually, when the room is opened it implies that the door has been opened. And this is why the function open( ) in the class ‘room’ has been defined as: void open( ) { door::open( ); cout<
Private Inheritance (permitted)

class door { protected: void shut( ) { cout<
class door { protected: void shut( ) { cout<
class room { private: door d1;

class room:private door { public: void close( ) {

Inheritance

365 public: void close( ) { cout<
cout<
When we inherit a class privately, the protected members (data and functions) of the base class become private in the derived class. The public functions of the derived class can invoke these functions (which were inherited from the base class). But in the case of object composition, this is not possible. The class ‘room’, can only access the public parts of class ‘door’. The private inheritance relationship is termed “is implemented in terms of”. Protected inheritance is similar to private inheritance except that another derived class will inherit the protected members of this class. Ex:

class base {};

class derived1:protected base {}; class derived2:private derived1 {};

The class ‘derived1’ can access the protected members of the class ‘base’. The class ‘derived2’ can access the protected members of class derived1. But any class derived from ‘derived2’ will not be able to access the protected members inherited from ‘derived1’ (because derived2 privately inherited derived1).

Reinforcing the OOP concepts: Let’s just take a quick look at the various OOP concepts in brief. Whenever you are faced with a problem (to develop an application) you should first identify the problem. The necessary details have to be separated out from the unnecessary details. The abstract model (which is a class in C++) has to be modeled based on the relevant details. Let us suppose that someone puts forth the following requirement: “I want to have a program to keep track of all the cars I own. I’m interested in knowing the colour and top speed of the car…” In real life cars have many properties but in this particular problem we are only concerned with two properties: top speed and colour. These are the relevant details (relevant for our requirement) which are required to construct an abstract model. For some other problem it may be necessary to include other properties like type of fuel, dimensions etc. Abstraction is a way of looking at the same real-life entity from different perspectives. Depending on the requirements we create our own abstract view of the problem.

Inheritance

366 Encapsulation means hiding implementation details while providing a consistent interface to the user. In other words, no matter how you modify the implementation your interface should remain the same (i.e. the user will be unaffected by changes in the implementation). It’s similar to our telephone connection. The interface is the socket where we simply plug in the telephone jack and the implementation is the media carrying our voice to the telephone exchange (the implementation is hidden from us. As users we wouldn’t know if the media were changed from copper cables to fibre optic cables. Such changes do not affect the user since the user will still need to simply plug the jack into the telephone socket). Inheritance is the process of establishing relationships between classes. It helps in reuse of code rather than rewriting the same code. The 3 major relationships are: • Is-a • Is-implemented-in-terms-of • Has-a A fourth relation termed ‘a-kind-of’ is basically an ‘is-a’ relationship. If you really want to distinguish between the two, we could say that ‘is-a-kind-of’ relationship is at the class level while ‘is-a’ relationship is at the object level. In C++ we have the option of deciding how we want to inherit the parent (as public, private or protected). When a relationship is of the type ‘is-a’, we will inherit the parent class using the ‘public’ access specifier. In this case the relationship should be such that whatever action can be performed on the base class is permissible on the subclass also. In other cases you will have to inherit either as ‘private’ or ‘protected’ (depending on whether the current subclass will be further used as a parent class or not) - this represents the ‘isimplemented-in-terms-of’ relationship. Object composition represents the ‘has-a’ relationship.

Recap • • • • • • • • • • • • •

Inheritance: This is the property by which a derived class can inherit features of a parent class. Parent class: This is also referred to as the ‘base class’ or the ‘super class’. Derived class: This is also called as the ‘child class’ or the ‘subclass’. Inheritance helps in reuse of code (instead of rewriting existing code). The ‘protected’ access-specifier (used in inheritance) is less restrictive than ‘private’ but more restrictive than ‘public’. A virtual function is a member function of the base class but it is redefined in the derived classes. Run-time polymorphism is implemented through the use of virtual functions. A virtual function that is equate to zero is a pure virtual function. An abstract class will have at least one pure virtual function. You cannot create objects of an abstract class. When a base class pointer is used to access a derived object, you can make use of virtual destructors to invoke the correct destructor. Multiple Inheritance: If a class inherits from more than one parent class then we refer to this as multiple inheritance (or MI). Virtual base classes are used in multiple inheritance to prevent the derived class from having more than one copy of a base class.

Inheritance

367

More Polymorphism (Poly polymorphism!) Students generally aren’t able to appreciate the use of polymorphism in programming. So let’s revisit this topic. We’ll start with the problem, assuming that we don’t have inheritance in C++: Let’s say that we are creating a game similar to Microsoft’s Age of Empires. The concept of the game is that a player should build an empire and destroy all other empires. An empire consists of different characters/units - villagers, archers, horsemen, cavalry etc. Villagers are needed to collect resources and resources (like food, wood etc.) are needed to create units. Any game will run within a window (a gaming window - i.e. the entire game program will run within this window). Our requirement is that if at any point of time, the player minimizes the gaming window, then the game should pause, the window should minimize into the taskbar, the desktop should appear and the user can work on other things. To resume the game, the user can click on the taskbar. On clicking, the gaming window should maximize and all the characters which were present at the time of minimizing should be redrawn on the screen. Initially while developing the game we decide to work with only two types of characters: villagers and archers. So we would design two classes to represent them. In this section we shall concentrate on our requirement (which is redrawing the characters on the screen as they were at the time of minimizing the window; let’s ignore other aspects of the game). We should provide a draw( ) member function in each of these classes (for drawing the villager or archer on screen; the draw( ) function varies in the two classes because villagers and archers are represented differently in our game). Every villager and archer created in the course of the game has to be contained within the gaming window (the player can just click on a villager icon to create a new villager and on an archer icon to create a new archer). If the player creates 10 villagers then we should draw these 10 villagers on the screen. The draw( ) function will serve this purpose. Our gaming window will be another class (all objects created in the game, have to be placed within this gaming window; the window will have properties like height, width etc.; the window can be minimized, restored and closed - these would be some of the member functions of this window class). Our window class also needs to keep track of the various villager and archer objects created. Thus to store these objects, we can create an array to hold villagers and another one to hold archers (in reality we won’t use arrays since they are of a fixed size and we can’t predict how many villagers or archers would be created. We’ll take a look at different data structures in a later chapter but for the time being let’s assume we use arrays for this purpose). The reason we need to keep track of the objects created is simple; when the restore( ) function is invoked (it gets invoked when the user restores the gaming screen after it has been minimized), all the objects present in the window need to be redrawn. When the gaming window is minimized and then restored it, we would need to redraw the villagers again. If there were 5 archers then these would also have to be redrawn within the gaming window.

Inheritance

368 So each time a new villager or archer is created we’ll store the address of the new object in our villager or archer array (i.e. we’ll store a pointer; we can also have an array to store the archer and villager objects itself but this would lead to presence of multiple copies of our object in memory- so instead of the object we store the address of the object in the arrays). In our restore( ) function we will cycle through each of these two arrays; in each cycle we’ll retrieve the address of the object and invoke the draw( ) function for that object. In this way we’d redraw all the characters which were present on the screen just before the player minimized the window.

Note: The villager and archer class would have many other properties (like location: x and y coordinates, which will be required to draw the object at the correct position) but to keep the example simple we won’t consider them. Our restore function might be something like this: void restore( ) { Perform till end of villager array { varr[i]->draw( ); } Perform till end of archer array { aarr[i]->draw( ); } } where ‘varr’ is the array containing the addresses of all the villager objects and ‘aarr’ is the array containing the addresses of all the archer objects (instead of the address we could also store the entire object in the array but this would consume a lot of space). To populate the villager and archer array we’ll need to have another two functions in the window class: add_archer(archer *); add_villager(villager *);

Inheritance

369 Every time a new villager or archer is created we’ll call the appropriate function to populate the ‘varr’ or ‘aarr’ arrays. The program flow seems satisfactory: 1. User can create archers or villagers. 2. If an archer is created then the function add_villager is called to add the address of the new villager object to the array ‘varr’. 3. Similarly if a villager is created then add_archer is called and ‘aarr’ is populated. 4. In both cases their respective draw( ) functions are called to draw the character on the screen. 5. If the player minimizes the window and then restores it, the restore( ) function of the class ‘window’ would be called. This in turn will cycle through both arrays and call the appropriate draw( ) functions. Everything is fine except for the problems we’ll land into later. 1.) Both archers and villagers have some properties in common (example: life). We are replicating the same chunk of code repeatedly. 2.) If we were to add a new character, say swordsmen, then we need to create another array to hold all our swordsmen. We would also need to modify the restore ( ) function in our window class to cycle through this new array. Imagine the number of arrays required later when we introduce ten new characters in the game! Ah, the first problem is simple to solve. We need to use inheritance. An archer is a person and a villager is also a person. And every person has an attribute ‘life’; fairly simple. So we convert our initial design into the following:

But what about our second problem? One option might seem to be something on the following line of thought: Declare a dummy draw( ) function in the class ‘person’; use a single array called ‘parr’ to store villager and archer object addresses and invoke the draw( ) function.

Inheritance

370 //the base class person class person { protected: int life; }; //The window class member functions restore( ) and add( ) would be: void restore( ) { Perform till end of person array { parr[i]->draw( ); } } void add_person(person *p) { add ‘p’ to parr } //In the main( ) function we would add archers and villagers to parr window gaming_window; archer a1; gaming_window.add_person(&a1); villager v1; gaming_window.add_person(&v1); gaming_window.restore( ); The statement: gaming_window.add_person(&a1); is correct. The add_person( ) function requires address of a person but we are passing the address of an archer. Since an archer is a type of person (relationship established through inheritance), the function call is correct. Try compiling the code and you would get a compile time error flagging the statement: parr[i]->draw( ); The problem is that parr is an array supposed to hold the address of person objects. A villager is a person and so ‘parr’ can hold this type of an object. But the class person doesn’t have a member function draw( ). Obviously a base class cannot be expected to know the functions present in the derived classes and so the compiler complains saying “person class does not have a member function draw( )”.

Inheritance

371 To correct this you might modify the person class as: class person { protected: int life; public: void draw( ) {cout<<"a person";} }; Now you won’t get a compile error and the code will run. But no matter what type of character you create, the call: parr[i]->draw( ); will always print: Drawing a person. Villagers and archers will never appear! Why? This is because we never specified that the code should examine the type of object and then call the appropriate draw( ) function. As far as our program is concerned, it sees parr as an array holding address of persons and thus when we try to call a member function through this address it will only call the member function present in class person (and not the ones present in the derived class). So now we need to figure out a way to examine what sort of a object we’re holding in ‘parr’ and then call the correct darw( ) function. To examine the type of object, we need to store some information in the class which will indicate the object type. An extra member data would serve the purpose well. Our person class could be defined as: class person { protected: int life; public: int obj_type; void draw( ) {cout<<"a person";} }; The member data ‘obj_type’ will hold different values depending on whether the object is an archer or a villager. For example we might decide that an obj_type of 1 denotes a villager and value of 2 denotes an archer.

Inheritance

372 The class villager would now be: class villager:public person { public: villager(int x=100) { obj_type=1; life=x; } void draw( ) {cout<<"\nDrawing villager:"<
Every villager created would have obj_type as 1. Similarly in our archer class we would code: obj_type=2 in the constructor. Thus if at any point of time we want to check whether an object is of type archer or villager, we will simply check the value of obj_type.

Our modified restore( ) function in the window class would be as below. Now we’ve resolved the problem of determining what type of object address we have stored in our ‘parr’ array. void restore( ) { Fetch object addresses stored in ‘parr’ array until end of array is reached { switch(parr[i]->obj_type) //check if it’s a villager or archer { case 1: ((villager*)parr[i])->draw( ); break; case 2: ((archer*)parr[i])->draw( ); break; } } } void add_person(person *p) { add ‘p’ to parr } To ensure that the right version of draw( ) is called we perform casting (i.e. forcing the compiler to treat a pointer to a person as a pointer to a villager/archer). If obj_type is 1 then we force the pointer parr[i] to act like a pointer to a villager. Thus when we now call draw( ) using this pointer, we are actually telling the compiler to call the draw( ) member function of the class ‘villager’. But the drawbacks of this method are quite obvious. Casting itself is not a practice encouraged in programming (because by casting we are attempting to modify the type of an object temporarily and are skipping the type-checking operation performed by the compiler). It also clutters the code with lots of parentheses making the code appear complicated as well. And the biggest problem occurs when we want to add new characters to our game. If a swordsman has to be introduced then:

Inheritance

373 • all objects of type swordsman should have a particular obj_type (maybe value 3). • We should tamper with the restore function in the window class and we will introduce more casting in the restore( ) function. • If there are other places where we examine obj_type then we should ensure that we modify the code in all these places to handle obj_type of 3. Obviously we need some cleaner method of achieving this functionality. You might have noticed something interesting, “We are expecting our objects to respond differently to the same message!” The message we send is draw( ) and the drawing of villagers and archers are different. Our problems would be solved by run-time polymorphism using virtual functions. By using the keyword virtual the compiler puts that extra bit of code so that the type of the object is examined at run-time and the correct implementation is of draw( ) is called. We needn’t worry about distinguishing between different types of objects and we needn’t use an extra member data like ‘obj_type’. We also get to avoid all the casting complications because now the compiler will insert its own code so that the type of the object is determined at run-time and the correct version of the draw( ) function is called. Now we also needn’t worry about new characters being added into the game. Even if we were to introduce our swordsman, he would be derived from person (a swordsman is also a person) and thus the code of the window class needn’t be tampered with. Our code in restore( ) function will be: parr[i]->draw( );

Inheritance

374

Streams and Files - Intro The following topics are covered in this section: • • •

Intro to streams Overloading << and >> Predefined Stream Objects

Introduction to Streams You might have heard of I/O. It stands for Input-Output. Before dealing directly with files we shall first take a look at streams. Using C++ you can access a device through an intermediate medium. The intermediate medium is called a stream. The device that you access is known as file. Don't mistake the term file as the normal computer file. A normal file (a text file or a word document) is referred to as disk file. When dealing with streams, the term file takes a broader meaning. It includes disk files, tape drives, the terminal, printers and other devices. C++ is designed to interact with these devices and this can be accomplished using streams. Each device is unique in its own way. The C++ file system transforms each device into a stream. All streams will behave similarly though they provide access to different devices (or files). Hence streams are mostly device-independent. The function used to write to a disk file can be used to write to the monitor screen as well. Hence all streams are similar but all files are not. Each stream is associated with a specific file by using the open operation. Once you open a file (not just disk file – it could even be a printer), information can be exchanged between the file and your C++ program. This exchange is done through the medium of streams. A stream is an object and there are different kinds of general I/O streams: • • •

Input stream (belongs to class a class called ‘istream’) – cin is an object of this stream and handles input. Output stream (from the class called ‘ostream’) – cout is an object of this stream and handles output. Stream for both input and output (obtained from the class called ‘iostream’)- handles both input and output.

These are general I/O streams and they are not specifically for disk file operations. We shall deal with file I/O later. The iostream class has two overloaded operators: • •

>> (extractor) << (inserter)

These operators (which are actually bitwise shifting operators) are already overloaded to work with fundamental data types and a programmer can also overload them to work with objects (user-defined data).

Files & Streams - C++

375

Overloading insertion and extraction operators The insertion (or output operator <<) and extraction operators (or input operator >>) are binary operators that are already overloaded to operate on built-in data types. The insertion operator will insert data into a stream while the extraction operator is used to extract data from a particular stream. Suppose we had a class ‘car’ and we created an object called ‘ford’, wouldn’t it be wonderful if we could just type: cout<> operators. We have seen this in the chapter on operator overloading but since we are dealing with streams, one of the arguments to the friend function should be a stream. #include class car { private: int speed; char color[20]; public: void set( ) { cout<<"\nEnter the speed: "; cin>>speed; cout<<"\nEnter the colour: "; cin>>color; } friend ostream& operator<<(ostream&, car&); }; ostream& operator<<(ostream &stream, car &ob) { cout<<"\nThe speed is: "; stream<
Files & Streams - C++

376 The output from the above program will be: Enter the speed: 280 Enter the colour: red The speed is: 280 The color is: red You just have to remember that you will need to use a stream as one of the parameters in the operator overloading function. By the way, cout is an object of type ‘ostream’. ‘cin’ is an object of type ‘istream’. In the above program you could write: stream<<"\nThe speed is: "<>ford; instead of creating a member function called ‘set’ for this purpose? This can be achieved by overloading the input operator >> as shown below: #include class car { private: int speed; char color[20]; public: void set( ) { cout<<"\nEnter the speed: "; cin>>speed; cout<<"\nEnter the colour: "; cin>>color; } friend ostream& operator<<(ostream&,car&); friend istream& operator>>(istream&,car&); }; ostream& operator<<(ostream &stream,car &ob) { cout<<"\nThe speed is: "; stream<
Files & Streams - C++

377 } istream& operator>>(istream &str,car &x) { cout<<"\nEnter the speed: "; str>>x.speed; cout<<"\nEnter the colour: "; str>>x.color; return str; } int main( ) { car ford; cin>>ford; cout<> and << to work on your objects. Reference: There exists a bug in VC++ compiler when using friend functions to overload the << and >> operators. Refer to question 9 in Chapter 14 for details.

Pre-defined Stream objects In C++ there are 4 streams which are already defined. These streams are opened when you run a C++ program. They are: Stream Name

Used for

Linked to

cin

Standard input

Keyboard

cout

Standard ouput

Monitor

cerr

Standard error

Monitor

clog

Buffered error display

Monitor

•

cin- is an object of the class ‘istream’ and is connected to the standard input device (which is usually the keyboard).

Files & Streams - C++

378 •

cout- is an object of the class ‘ostream’ and is connected to the standard output device (which is usually the monitor).

•

cerr- is an object of type ‘ostream’ and is connected to the standard error device. Output through ‘cerr’ is unbuffered (i.e. the output will appear immediately on the screen). It is used to inform the user about some error that has occurred.

•

clog- is similar to the ‘cerr’ object but ‘clog’ is buffered (i.e. output will be held in the buffer till the buffer becomes full or till the buffer is flushed).

Buffering and flushing will be dealt with in the next chapter. The standard streams described above can be redirected to other devices or files. The ‘cerr’ object is similar to the ‘cout’ object but the difference is that even if ‘cerr’ is redirected by the user to some other device the error message will be displayed on the console (i.e. on the monitor screen).

Files & Streams - C++

379

Streams and Files - II

The following topics are covered in this section: • • • • •

Stream Status Reading stream status Opening files Closing files Errors while opening

Stream Status To determine the present state of a stream, there are four bits (or flags) associated with every stream. They are: • • • •

ios::goodbit ios::eofbit ios::failbit ios::badbit Stream Status Flag

Purpose

badbit

Set when a fatal error occurs.

eofbit

Set when the end of the stream is encountered (if stream relates to a file then it is set when end of file encountered)

failbit

Set when non-fatal error occurs (for example when invalid data is stored)

goodbit

It is set if there are no errors.

Let’s see a very simple illustration of how you can make use of these bits. Let us create a class called ‘date’ which will be used to obtain the date from the user in the following pattern: DD-MM-YEAR To achieve this we shall overload the >> operator. #include class date { private: int day,month,year; public: date( ) //constructor {

Files & Streams - C++

380 day=month=year=0; } void disp( ) { cout<>(istream&, date&); }; istream& operator>>(istream &istr, date &dt) { char dash; cout<>dt.day; istr>>dash; if (dash != '-') { istr.setstate(ios::failbit); //setting stream status } istr>>dt.month; istr>>dash; if (dash != '-') { istr.setstate(ios::failbit); //setting stream status } istr>>dt.year; if (istr.fail( )) //checking stream status { cout<>d; d.disp( ); return 0; } The output if the input is typed correctly is: Enter the date (separated by - ): 11-10-1981 The date is : 11-10-1981 The output if the input is typed incorrectly is as follows: Enter the date (separated by - ): 11/10-1980 Error in the format of the date entered! The date is : 11-0-0

Files & Streams - C++

381 The function used to set the ‘failbit’ is: setstate( ) (Some compilers might not support this function). We have set the ‘failbit’ when the separator used by the user is something other than the ‘-’ character. As soon as the ‘failbit’ is set all further stream operations are ignored till the error is corrected (which is the reason why even ‘1980’ is not accepted by the program). The function: istr.fail( ) is used to read the status of a stream. It will be discussed in the next section. Reading the status of a stream: We have learnt about the stream status flags and we have even discussed as to how the flags could be set. To identify which status bit has been set we can make use of corresponding member functions. Function

Stream Status Flag checked

int bad ( )

badbit

int eof ( )

eofbit

int fail ( )

failbit

int good ( )

goodbit

‘cin’ is a stream and even its ‘failbit’ can get set as shown in the program below: #include int main( ) { short int num; cout<<"Enter a short integer : "; cin>>num; if (cin.fail( )) { cout<
Files & Streams - C++

382 The output for a value that exceeds the short integer range will be: Enter a short integer : 56432 Error in input The number stored is :32767 The fail ( ) function will return a non-zero value if the number entered by the user exceeds the limit of a short integer. If this is the case then the ‘if’ condition is satisfied and the loop is executed. Usually we will not be using the stream status flags as shown in the above case. The same concept will be applied for files (because files are also accessed via streams and all the points discussed here are relevant for files). Remember: Once any of the error bits are set, they will continue to remain set till they are cleared. For example: #include int main( ) { short int num; int num2; cout<<"Enter a short integer : "; cin>>num; if ( cin.fail( ) ) { cout<>num2; cout<
Files & Streams - C++

383 In the second case, the ‘failbit’ for the stream ‘cin’ is set to 2 (because a very high number was entered initially). This bit hasn’t been reset and thus ‘cin’ cannot be used to obtain the value for the second integer (the program will not allow the user to enter a value because the ‘cin’ stream has an error). The modified program will be: #include int main( ) { short int num; int num2; cout<<"Enter a short integer : "; cin>>num; if ( cin.fail( ) ) { cout<>num2; cout<
Opening and Closing a ‘File’ So far we have dealt with standard I/O. Next we shall deal with file I/O and to access any device you have to make use of another header file: ‘fstream.h’. This header file has a number of classes already defined. To access a file you have to have a stream. We have already come across the classes istream, ostream and iostream. From these classes, 3 more

Files & Streams - C++

384 classes are derived (they are ofstream, ifstream, and fstream) and these classes are specifically useful for streams used in ‘file’ operations. The hierarchy of classes will be as shown in the figure.

As can be seen, the ‘ifstream’, ‘ofstream’ and ‘fstream’ classes are derived from the ‘istream’, ‘ostream’ and ‘iostream’ classes. These are file streams that are derived from the general I/O streams that we have seen earlier. ifstream in; ofstream out; fstream both; output

// file stream named ‘in’ created for handling input // file stream named ‘out’ created for handling output // file stream named ‘both’- can handle both input and

Once you've created a stream, you can use the open ( ) function to associate it to a ‘file’. To associate the stream to a disk file, we should specify the name of the disk file. The open ( ) function is a member available in all the three classes. It can be used as follows: out.open("text.txt") ;

// Opens a file called text.txt for output.

Remember: When you say that a file is opened for output, it actually means that now you can write data to the file. When a file is opened for input (i.e. using ifstream), the data in the file can be displayed on the screen. What if there already is a file called text.txt. When using the output stream (ofstream), the stream will create a new file text.txt. Whatever content was there in the original text.txt gets deleted and you can write new data to text.txt. The 3 classes (ofstream, ifstream, fstream) have a constructor function that makes it easier to open a file. Example: ofstream out("text.txt"); This creates an object out for output and opens the file text.txt in one single statement. Here we don’t make use of the open ( ) function.

Files & Streams - C++

385

Closing a File Anything that you open has to be closed. The member function for closing is close ( ). Since you do all I/O through the stream, you have to close the stream as follows: stream-name.close( ); Actually you can link this back to the object and classes concept. ‘stream-name’ is an object and close is a member function of the ofstream class. Hence by saying stream-name.close( ); you're actually invoking the member function close( ). A stream is associated to a device when using the open function. When the close ( ) function is used, the stream is disassociated from the device.

Can Errors occur while opening a file? When you open a file using ofstream (which means for output), you can write data to the file. You could say it's an input to the file. Hence open for output means actually for input. When a file is opened for reading, you will make use of the ifstream as follows: ifstream instr("test.txt");

// The file test.txt is opened for reading

Beware: Many beginners confuse between the use of ‘ifstream’ and ‘ofstream’ objects. Be clear as to what you want to use. When you want to read a file, it implies that the file is already present in your directory. What will happen if we attempt to open a file that is not present? This will cause an error and you should provide the necessary coding to deal with this situation. When you open a file for writing data, the stream will create the file even if it doesn't exist. But if you attempt to open a file for reading data and if it isn't present in the computer, this will cause an error. You should always check whether an error has resulted while using the open operation as follows (‘instr’ is an object of type ifstream): if ( ! instr ) { cout<< "The file cannot be opened"; } if ( ! instr ) stands for : ‘if not instr’ (that means ‘if instr not open’) then do what is said in the body of the if statement.

Files & Streams - C++

386

Streams and Files - III

The following topics are covered in this section: • • • • • •

Modes of opening files Binary Files Writing to files Reading from files Accessing other devices Using get( ) and put( )

Modes of Opening Files When you open a file (for writing or reading), there are 6 modes that you can use to specify how you want the file to be opened. The usually used modes are: ios::app ios::ate ios::binary ios::in ios::out ios::trunc • • • •

Including ios::app causes all the output (or whatever you write) to be appended to the end of the file. This mode can be used only for files opened for output. ios::in specifies that the file is capable of input only. ios::out specifies that the file is capable of output only. ios::binary causes the file to be opened in binary mode. ios::trunc causes contents of pre-existing file by same name to be destroyed.

So far we've seen the file opening as follows: ofstream out; out.open("test");

// This means test is opened in normal mode.

By default this is the same as out.open("test", ios::out); // opened specifically for output We can combine two modes using the bitwise OR operator: out.open("test", ios::out | ios::binary ); This will open a stream in output and in binary mode. The different methods for opening a file are summarized in the table below:

Files & Streams - C++

387 Opening Mode

Function

ios::in

File opened in input mode (for ifstream objects)

ios::out

File opened in output mode (for ofstream objects)

ios::app

Append to the file. All output operations (like writing to file) are done at the end of the file.

ios::trunc

Delete file if it exists and create a new file.

ios::ate ios::binary

Open file and go to the end of the file. Open file in binary mode (by default files are opened in text mode).

ios::nocreate

Only if file exists will it open

ios::noreplace

The file should not exist (otherwise open fails).

An example is shown below: #include #include int main( ) { ifstream istr("test.txt",ios::in| ios::nocreate); //error if file not present if (istr.fail( ) ) { cout<<"failed to open - no such file"; } return 0; } The fail( ) function is inherited by the ofstream, fstream and ifstream classes. Hence we can check whether the open( ) operation was successful or not using this function. ‘fstream’ objects can be used to operate in either input or output modes.

Files & Streams - C++

388

What are Binary Files? Reading and writing formatted text is easy and is always used for displaying data to the user. But sometimes you may need to work with unformatted data (i.e. in binary or raw form) and not as text. When we refer to formatted text it means that the information has been processed to make the output understandable (like using the ASCII table for conversion). If you want to perform binary operations on a file, you should open it in binary mode. If a file is opened in text mode (or normal mode) and you make use of these functions (that are intended for binary mode), the functions will work but some character translations will occur. This might seem to be really confusing. Basically there are two types of files: binary files and text files. Binary files can contain any data representation format. Text files contain only alphanumeric data as represented by the compiler's character set (for example ASCII). By default, all files are opened in text mode unless you specify ios::binary. When in text mode, the file is considered as containing a number of lines each ending with a "\n". As a binary file, it is considered simply as a sequence of bytes. Unless, the OS maintains different file formats for a binary file and for a text file, these modes of opening are irrelevant. But is always advisable to use the binary mode while opening files (even text files). An example of how character translation can occur is while using the ‘\n’ (newline character). In a binary file this will be stored as a single character. If the OS distinguishes between text and binary files, then when you store a ‘\n’ in a text file it will be stored as two characters. Certain functions used in file I/O will work only in binary files; so it is better to always work on binary files. Another simpler example is the case of storing numbers in a file. Let’s say we have: int x = 124; If you write ‘x’ to a file in text mode then the program will convert 124 into it’s equivalent ASCII form (i.e. it will take each digit separately, convert the digit to the ASCII value and then store the ASCII value in the file). If you read this file using Notepad you’ll see the number 124 displayed on the screen. Suppose you store the same number to a file in binary mode, the program will convert 124 directly into its binary value and store this binary value in the file. Now if you try to read the file in Notepad you’ll see some weird character on your screen (because Notepad will apply ASCII decoding since it thinks that everything you open in Notepad is stored in ASCII format).

Files & Streams - C++

389

Writing to a File The << operator can be used to write to a file and this is the easiest method of writing to a file. #include #include int main ( ) { ofstream out("trial.txt", ios::out); test.txt out<<"First "<<1<
// Create a stream for output linked to

In the above program, instead of writing to the screen, we want to write to a particular file. So we create a stream called ‘out’ for output and open the file trial.txt. It is better to clearly specify the method of opening the file (ios::out). out<<"First "<<1<
Reading a File In a similar way we can use the >> operator to read data from a file. The file created in the earlier program can be read using this program. # include # include int main ( ) { ifstream in("trial.txt", ios::in); if(!in) // If file doesn't exist then the program will quit. { cout<<"File cannot be opened"; return 1; } char string[15]; int num; in>>string>>num; cout<>string>>num; cout<
Files & Streams - C++

390 in.close( ); return 0; } >> is the extraction operator. As you know, it is used for obtaining an input from the keyboard along with ‘cin’ (console in). Suppose you declare an integer ‘x’, you can get the value from the user using the statement: cin>> x ; What the user types is stored in the variable ‘x’. Similarly in the above program what the code: in>>string>>num; reads from the stream called ‘in’. It will store what it reads in the variables ‘string’ and ‘num’. The process is as follows: The file is opened. The system reads the file (trial.txt which has been opened). It reads the first 15 characters. The first word in the file is ‘First’. After this it encounters a blank space. Hence the array ‘string’ is terminated (because the >> operator will not save whitespaces). The word ‘First’ is stored in the character array ‘string’. Next comes a number in the file. This is stored in the variable ‘num’ that we have declared. The next statement is for displaying whatever was read from the file. After this remember that the program has reached the end of the first line of the file. It now automatically moves to the second line of the file. Hence when we repeat the statement: in>>string>>num ; and the program will read the second line of the file. The process just repeats and the word ‘Second’ and ‘2’ are now stored in ‘string’ and ‘num’. Remember: The << and >> operator will write the data to a file in text format irrespective of whether you open the file in text or binary format. To check this try to write an integer to the file and then open the file in Notepad (if it were written in binary format you would not see the same number on the screen). To handle files in binary format we need to use other functions like write( ), get( ), put( ) etc., which will be discussed later.

Accessing other Devices (printer and monitor) through streams All streams work similarly even though they are connected to different devices (like files, printer or the monitor). Every stream is associated to a device (or a ‘file’) using the open function.

Files & Streams - C++

391 //program to print in the printer as well as on the screen # include #include int main( ) { ofstream monitor; ofstream print; print.open("LPT1"); print<<"Hi This is the printer."; monitor.open("CON"); monitor<
Get ( )and Put ( ) In the earlier example program to read and write into files we knew what data was present in the file (i.e. we knew that there was a string followed by an integer and hence it was easy to read the data from the file). Usually you won’t know what is stored in a file and this is where the get ( ) and put ( ) functions will be handy. get and put functions read and write unformatted data. Both these functions operate on single characters only. fet ( ) is used to read a character from a stream while put ( ) is used to write a character.

Files & Streams - C++

392 // Program to create a file, write to it and then display the contents of the file #include #include int main( ) { ofstream out("c:/test.txt",ios::out | ios::binary); char letter; cout<<"\nEnter what you want to store: "; cin>>letter; while (letter != '*') { out.put(letter); cin>>letter; } out.close( ); //Now we want to read the file cout<<"\nThe contents of the file are: "; char ch; ifstream in("c:/test.txt", ios::in | ios::binary); while (in) { in.get(ch); if (in) { cout<
Files & Streams - C++

393 This condition becomes false only when the end of file is reached. So till the end of file is reached we keep getting the characters one by one and then displaying them one by one on the screen. Assume that we have stored the word ‘check’ in the file test.txt. When the compiler opens the file for reading, it has a small bookmarker that points to the beginning of the file. The bookmarker points at the letter ‘c’. It gets the letter ‘c’ (using the get(ch) statement) and then displays it on the screen. The compiler knows it still hasn't reached the end of file. So, the next time it goes through the while loop, the bookmarker has moved to the next character (i.e to ‘h’). The process repeats till the end of file is reached. Remember: You cannot save spaces (blank spaces) using put and get functions. Try it in the above program and see what happens! If in the above program the input were as below would yield: Enter what you want to store: A Fine Morning* The contents of the file are: AFineMorning As you can see, the whitespaces are not stored. The put( ) will basically ignore whitespaces. One more point to note in the above program: ofstream out("c:/test.txt",ios::out | ios::binary); Usually we refer to files by saying c:\test.txt but here we have used: c:/test.txt In C++ you should always use this slash within the double quotes whenever you are referring to directory/drive paths. Let’s suppose that we use the normal slash, then the statement would become: ofstream out("c:\test.txt",ios::out | ios::binary); If you notice, within the double quotes the compiler will encounter a ‘\t’ and this actually corresponds to an escape sequence. Hence the compiler will not go to the C drive itself. Another alternative to c:/test.txt is to use double slashes as below: ofstream out("c:\\test.txt",ios::out | ios::binary); This method is also accepted in C++ programming. Beware: Make use of forward slash (c:/test.txt) or double backslash (c:\\test.txt) instead of single backslash (c:\test.txt) when referring to file locations in C++.

Files & Streams - C++

394

Streams and Files - III The following topics are covered in this section: • • •

Writing structures to files Padding/packing of structures Detecting end of file

Writing a structure to a file The read ( ) and write ( ) functions are another way to read and write blocks of binary data. This is particularly useful in writing and reading structures to files. The read and write ( ) function syntaxes are very similar to each other. But I think you'll find the arguments a bit hard to understand. The syntax is as follows: objectname.read(char * buf, int n); objectname.write(const char * buf, int n); The syntax might appear to be a bit weird. Let's go one by one. First of all, read ( ) and write ( ) functions have to be called by an object which belongs to one of the streams. You can't call them without an object (in this case the object is a stream). The read ( ) function will read ‘n’ characters (or ‘n’ bytes) from the invoking stream and puts them in the buffer pointed to by ‘buf’. The write ( ) function will write ‘n’ characters (or ‘n’ bytes) to the invoking stream from the buffer (buf). ‘n’ is basically an integer that denotes the size in bytes. (char *) buffer : This tells the compiler the starting memory location. If you are using the write function then this denotes the starting point for copying data into the file. The function needs the first argument to be a pointer to a character and that’s why we use casting (casting is discussed in a later chapter). Basically when you pass the first argument to the read/write( ) functions, you should make that argument look like a pointer to a character. int n : Here we specify the number of bytes we want to write or read (usually we make use of the sizeof operator to determine the size of what we want to write/read because you can’t expect the programmer to remember the sizes). Beware: The read and write( ) functions write and read binary data (not text format). Remember: These two functions are very useful in reading/writing an entire array in binary format to a file. // Program to create a file, write to it and then display the contents of the file #include #include struct email { char name[20];

Files & Streams - C++

395 char id[20]; }; int main ( ) { email user; email check; //user, check are structure variables. cout<<"Enter a name: "; cin>>user.name; cout<<"Enter the email address : "; cin>>user.id; //get values for elements of user ofstream out("c:/email.txt", ios::out | ios::binary); //Open the file test.txt out.write( (char *) &user, sizeof (struct email) ); out.close( ); cout<
//read the structures

The output is: Enter a name: ajay Enter the email address : [email protected] Contents of file are : ajay [email protected] The program upto the write ( ) function is normal. We open a stream called out for writing the structure to the file. out.write((char *) &user, sizeof (struct email)); Compare the above line with the syntax of the write ( ) function. You'll notice that instead of ‘buf’ we've used ‘&user’. This is because we want to save the structure variable ‘user’ into the file. So we point to the address of ‘user’. Then instead of ‘n’ we've used: sizeof (struct email) In the general syntax, ‘n’ refers to the number of bytes you want to write. In this case we want to write as many bytes as the structure will occupy. Instead of specifying some fixed number, it's better to use the ‘sizeof’ operator to find the number of bytes. The name of the structure is ‘email’. So by saying sizeof (struct email)

Files & Streams - C++

396 the compiler will find out how many bytes the structure ‘email’ occupies. This value is the same as that of ‘user’ (since ‘user’ is a variable of structure ‘email’). Next we create a stream to read the contents of the file test.txt (just to see whether the structure was saved in the file). in.read((char *) &check, sizeof(struct email)); The syntax is same as that of write ( ) function. Except that we've made use of another structure variable namely: ‘check’. This is also a variable belonging to structure type ‘email’ except that we haven't obtained any values for check.name and check.num Now, we will read ‘sizeof (struct email)’ bytes and store it in the structure variable ‘check’ and then print the values of check.name and check.num. Instead of using ‘check’, you can also use the structure variable ‘user’. A different structure variable is used for the two purposes to demonstrate clearly that we are really writing and reading from the file. Remember: It is always a good idea to store structures in binary-format rather than textformat (since they contain a mixture of data types and you wouldn’t want conversion of data).

Padding/Packing of Structures What do you think is the space occupied by the structure variable ‘t’ below: struct test { long int num; char a; }t;

// long int is 4 bytes //char is 1 byte

The actual size is 5 bytes but the compiler might do padding to the structure and make the size of the structure 8 bytes. Why? Some compilers prefer to uniformly allocate memory space to the structure members (i.e. each structure member is given a fixed length). In the above structure ‘test’ the compiler notes that ‘long int’ is the maximum element size (of 4 bytes) and so it prefers to allocate memory space in increments of 4 bytes. Thus if ‘num’ occupies memory from byte number 1 to byte 4, then ‘char a’ will occupy memory from byte number 5 to byte 8 (even though ‘char’ requires only 1 byte). In this case we say that the packing is 4 bytes (because each member is packed to 4 bytes). Why does the compiler do packing? Consider the structure: struct test { short int s; char c; double d; long int i; }

Files & Streams - C++

// 2 bytes // 1 byte // 8 bytes // 4 bytes

397 The structure ‘test’ will now have packing of 8 bytes (because a ‘double’ occupies 8 bytes). Let us assume that the compiler allocates memory starting from byte 0. The allocation will be: [2+1+(5)] + [8] + [4 + (4)] = 24 bytes The number within ( ) denotes the number of extra bytes added for the sake of uniformity (the padded bytes). ‘s’ and ‘c’ (both combined occupy less than 8 bytes) are put together in one field. Since ‘d’ cannot be accommodated within the same 8-byte field, five bytes are padded to the first field. ‘d’ will occupy the next 8-byte field. No padding of bytes is required here. The last field is occupied by the integer ‘i’ and it occupies only 4 bytes. So another 4 bytes are padded here to make this field 8 bytes long. Thus the starting location of each member (in terms of bytes) when 8-byte packing is used is: 0, 2, 8, 16 (a total memory space of 24 bytes is needed). Suppose we didn’t use padding (i.e. if packing is 1 byte), the positions will be: 0, 2, 3, 11 (a total of 15 bytes) If we use packing of 4 bytes, the positions will be: 0, 2, 4, 12 (a total of 16 bytes) As you might have noticed, when we use packing, all the members will be at multiples of 8 or 4 (depending on the packing used) and such an alignment is faster to access. A 32-bit processor would be able to access members at 32 bit boundaries faster. If there is no packing the elements are at varying positions (i.e. they are not uniformly placed in memory). Though more space is occupied by padding, the speed of the program can be improved using padding. To take advantage of this fact some compilers implement padding whenever they deal with structures. There is no need to worry about padding if you are developing software entirely in a single compiler. The problem arises when you write two programs (one for writing structures and another for reading the file) on two different compilers. If both compilers implement packing of bytes then there won’t be a problem. For example: Turbo C++ does not use padding while VC++ uses padding. So, if you write a program to write structures to files in VC++, the program will use padding to store the data in the file. While reading the file using a TC++ program, the compiler does not know about packing and so when you use the read ( ) function, you will get strange results. An example to highlight this problem is given below. //Program to write structures to a file using a compiler which implements padding #include #include struct test { char a,b,c; long int num; }t;

//by default each member is packed to 4 bytes.

int main( ) { t.a='a';

Files & Streams - C++

398 t.b='b'; t.c='c'; t.num=456789; ofstream str("c:\\text.txt"); str.write((char *)&t, sizeof(t)); str.close( ); return 0; }

//it will write a structure of 8 bytes in the file

This program writes the structure to a file (and it uses padding). Let us suppose that we write another program to read this file in a compiler which doesn’t support padding. //Program to read structures using a compiler which does not know padding #include #include struct test { char a,b,c; long int num; }t; //compiler assumes ‘t’ as occupying 7 bytes int main( ) { ifstream str("c:\\text.txt"); str.read((char *)&t, sizeof(t)); //it reads only 7 bytes. cout<
Files & Streams - C++

399 #pragma pack(1) is the same as using no padding. Remember: Compilers that do not use padding (like TC++) will not support the #pragma pack ( ) directive. These compilers always use a packing of 1 and this cannot be changed. Thus if programmers feel that they will be working across different compilers, they prefer to specify the directive: #pragma pack(1) which instructs the compiler to treat the members just as they are (no padding). This directive has to be added along with the #include directive (outside the main ( ) function). Thus: #pragma pack(1) struct test { short int s; // 2 bytes char c; // 1 byte double d; // 8 bytes long int i; // 4 bytes }; will cause any variable of type ‘test’ to occupy only 15 bytes. Remember: Padding is a problem mainly when you are working with storing data in files and when you are using two compilers.

End of File There exists a member function that you can use to identify whether the end of file (EOF) has been reached or not. int eof( ); This function will return true if the end of file has been reached. You could test for EOF using something similar to the following: while( !in.eof( ) ) { //body of while loop } where ‘in’ is an input stream.

Files & Streams - C++

400

Streams and Files - V The following topics are covered in this section: • • • •

File Pointers Sequential and Random Access Command Line Arguments Recap

Random Access of Files (File Pointers) Using file streams, we can randomly access binary files. By random access, you can go to any position in the file as you wish (instead of going in a sequential order from the first character to the last). Earlier in this chapter we discussed about a bookmarker that will keep moving as you keep reading a file. This bookmarker will move sequentially but you can also make it move randomly using some functions. Technically this bookmarker is a file pointer and it determines as to where to write the next character (or from where to read the next character). We have seen that file streams can be created for input (ifstream) or for output (ofstream). For ifstream the pointer is called as ‘get’ pointer and for ofstream the pointer is called as ‘put’ pointer. fstream can perform both input and output operations and hence it has one ‘get’ pointer and one ‘put’ pointer. The ‘get’ pointer indicates the byte number in the file from where the next input has to occur. The ‘put’ pointer indicates the byte number in the file where the next output has to be made. There are two functions to enable you move these pointers in a file wherever you want to: seekg ( ) - belongs to the ifstream class seekp ( ) - belongs to the ofstream class We’ll write a program to copy the string "Hi this is a test file" into a file called mydoc.txt. Then we’ll attempt to read the file starting from the 8th character (using the seekg( ) function). Strings are character arrays terminated in a null character (‘\0’). If you want to copy a string of text into a character array, you should make use of the function: strcpy (character-array, text); to copy the text into the character array (even blank spaces will be copied into the character array). To make use of this function you might need to include the string.h header file. #include #include #include int main( ) { ofstream out("c:/mydoc.txt",ios::binary); char text[80]; strcpy(text,"Hi this is a test file"); out<
Files & Streams - C++

401 out.close( ); ifstream in("c:/mydoc.txt",ios::binary); in.seekg(8); cout<
Files & Streams - C++

402 The syntax for seekg( ) or seekp( ) is: seekg(position, ios::beg) seekg(position, ios::cur) seekg(position, ios::end) By default (i.e. if you don’t specify ‘beg’ or ‘cur’ or ‘end’) the compiler will assume it as ios::beg. ios::beg – means that the compiler will count the position from the beginning of the file. o ios::cur – means the compiler starts counting from the current position. o ios::end – it will move the bookmarker starting from the end of the file. o

Just like we have 2 functions to move the bookmarker to different places in the file, we have another 2 functions that can be used to get the present position of the bookmarker in the file. o o

For input streams we have: tellg( ) For output streams we have : tellp( )

You would think that the value returned by tellg ( ) and tellp ( ) are integers. They are like integers but they aren’t. The actual syntax for these functions will be: streampos tellg ( ); where streampos is an integer value that is defined in the compiler (it is actually a typedef). Of course you can say: int position = tellg ( ); Now, the variable ‘position’ will have the location of the bookmarker. But you can also say: streampos position = tellg( ); This will also give the same result. ‘streampos’ is defined internally by the compiler specifically for file-streams. Similarly, the syntax of seekg ( ) and seekp ( ) was mentioned as: seekg(position, ios::beg) Again in the above syntax, ‘position’ is actually of type ‘streampos’.

Sequential and Random Access Files Basically variables are used for temporary storage and files are used for permanent storage of data. Based on how files are accessed, they can be divided into sequential and random access files. Actually this division of files depends on how we read and write to files (physically the file is stored as a sequence of bytes in memory).

Files & Streams - C++

403 All data is represented in the form of bits. A set of 8 bits (or a byte) can be used to represent one character. A set of similar bytes will form a ‘field’. A set of related fields will form a record and a file consists of a set of related records. Let us suppose that a University maintains a database consisting of its student’s details.

Fields and records are the terms used when we deal with files. Records are equivalent to ‘structures’ or ‘objects’ in C++. Usually when storing such data (like a student record as shown above), the programmer will use one unique ‘key field’. A ‘key field’ is the field which can be used to identify or locate a particular record in the file. For example in the above diagram, the student ID number will be the key field (thus if we want to access the details about the student Ajay then we can just refer to student ID number 1). The key field should be something unique (i.e. no two records should have the same key field). Usually we write and read records from a file. Sequential access files are the simplest way of organizing a file. In sequential access files we write the variables continuously one after the other. The length of each record isn’t fixed and can vary (i.e. each record needn’t occupy the same amount of memory). The advantage of this is that we do not waste any memory. The disadvantage is that if you want to access the 3rd record stored in the file, you will have to read the first two records before accessing the third (i.e. you cannot directly jump to the third record). The reason for this is because in sequential access files the record length is not fixed and you cannot predict as to where the third record might be stored. This leads to a few other problems. It is not possible to directly insert a new data in the middle of the file. If a new record has to be inserted, the old record has to be copied into a new file (up to the point where you want to insert), then the new entry should be added to the new file and then the remaining records from the old file have to be copied to the new one. You cannot directly update/modify a record in sequential access files. Let us suppose that we have a disk file containing the data:

Files & Streams - C++

404

This file has been stored sequentially and maybe the name Ajay needs to be modified to Williams. If you attempt to overwrite the existing record the resultant will be: 1 Williams2 Suresh 88

Because data is stored continuously in a sequential file, if the modified entry you make is longer in length than the existing entry then the neighbouring field will get overwritten. Random access files overcome this problem since they have fixed length records. The problem here is that even if we want to store a small sized record we still have to occupy the entire fixed record length. This leads to wastage of some memory space. For example if we are using 10 bytes to store a complete sentence in the file then even if you want to store a single letter (like ‘a’) 10 bytes will also be used up for this. But even though some memory space is wasted this method will speed up access time (because now we know where each record is stored. If a record length is fixed as 10 bytes, then the fifth record will start at byte number 50 and it is easier to jump directly to that location instead of reading the first four records before accessing the fifth). Word processing program usually store files in a sequential format while database management programs store files in a random access format. A simple real life analogy: Audio tapes are accessed sequentially while audio CDs (Compact Discs) are accessed randomly. So, how do we create sequential and random access files in C++? Actually we have already covered both these topics without explicitly using the terms sequential and random access. Whenever you make use of the ‘read’ and ‘write’ functions to write structures/objects to a file, you are actually creating a random access file (because every record will have the size of the structure). Whenever you use the << and >> operator to read and write to disk files, you are accessing the file sequentially (this was the first example program). Whenever you write to a stream (or a file) using << operator, you are writing varying length records to the file. For example: You might first write a string of 10 characters followed by an integer. Then you may write another string of 20 characters followed by a ‘double’. Thus the records are all of varying lengths. To effectively use random access files we make use of the seekp( ) and seekg ( ) functions. Though these can be used on sequential files it will not be very useful in sequential access files (because when you are searching for a data you are forced to read each and every character/byte, whereas in random access files you can jump to the particular record that you are interested in).

Files & Streams - C++

405

Command Line Arguments You know that functions can have arguments. You also know that main ( ) is a function. In this section we'll take a look at how to pass arguments to the main function. Usually filenames are passed to the program. First of all, let us suppose that we have a file by the name marks.cpp. From this file we make an exe file called marks.exe. This is an executable file and you can run it from the command prompt. The command prompt specifies what drive and directory you are currently in. The command prompt can be seen as the ms-dos prompt. C:\WINDOWS> This denotes that you are currently in C drive and in the directory named Windows. (By the way, if you want to go to the MS DOS command prompt from Windows, just go to "Start" and click on "Run". Type "command" in the text box and click "Ok"). Your marks.exe program is in this directory (let us assume it is here. If it isn’t in this directory then you have to change to that particular directory). To run the program you will type: C:\WINDOWS> marks name result You must be thinking that we will type only the name of the program? In this case the C++ program that you wrote is assumed to have arguments for the main ( )function (i.e. in the marks.cpp file you have provided arguments for the main( ) function): int main (int argc, char * argv[ ] ) argc (the first argument - argument counter) stands for the number of arguments passed from the command line. argv (argument vector) is an array of character type that points to the command line arguments. In our example, the value of ‘argc’ is 3 (marks, name, result). Hence for ‘argv’ we have an array of 3 elements. They are: argv[0] which is marks. argv[1] which is name argv[2] which is result Note: argv[0] will be the name that invokes the program (i.e. it is the name of the program that you have written). If you feel a little vague in this section don't worry. In the next section we'll take a look at a simple program. A program using Command Line Arguments // This file is named test.cpp #include int main ( int argc, char * argv[ ] )

Files & Streams - C++

406 { cout<<"The value of argument counter (argc) is: "<test one two three You have to go to the folder in which you have the test.exe file (I assume that your program is in the windows directory in C drive). The output will be: The value of argument counter (argc) is: 4 c:\windows\t.exe one two three There are numerous things you can do with this. You can pass the names of files upon which you want the C++ program to operate, or you could pass the name of a file that you want your program to create, etc. Depending on your application, you can make use of the arguments. For example: if you write a program for zipping files, then the arguments can be used to specify the files that you want to zip.

Recap • • • • • • • •

A stream is an intermediate medium used for accessing other devices (like disk files or printers). The general I/O classes are: istream, ostream and iostream. The predefined streams are: cout, cin, cerr and clog. The stream status flags (or bits) are used to determine the state of the stream. The file I/O classes are derived from the general I/O classes. They are: ifstream, ofstream and fstream. In random access of files two pointers called the ‘get’ and ‘put’ pointers are used. They are also called file position indicator or file pointer. The read ( ) and write ( ) function can be used to read and write structures from a file. Command line arguments are used to pass arguments to the main ( ) function.

Files & Streams - C++

Chapters 9 to 11 (Inheritance, Operator overloading and streams)

Q.) Complete the following tabulation on operator overloading by specifying the return type which one would normally use: Operator overloaded + :: = < += ! == ?:

Return type

Q.) Which form (postfix/ prefix) of the unary operator ++ involve more overhead? Or are they just different in terms of representation alone? A.) When we say: x = ++y; ‘y’ is incremented and the value is assigned to ‘x’ (first increment and then obtain value). Whereas in: x = y++; the value of ‘y’ is first assigned to ‘x’ and then ‘y’ is incremented (so ‘x’ actually has the old value of ‘x’). Here we obtain the value first and then increment. To remember how they work all you need to do is take a look at how we use them; when we say ++y the ++ comes before the ‘y’. Thus we first increment and then obtain the value whereas in y++, we get ‘y’ first and then increment it (it’s just a memory aid since many new programmers tend to get confused with the 2 forms). Next let’s consider the following statement: y++++;

//Error

This is equivalent to: (y++)++;

Q&A - 9-11

Obviously y++ returns an integer, so why is it not permitted? That’s because the return type of the postfix operator is a constant (in this case a constant integer). Thus you can modify the returned value again. Let’s consider the other statement: ++++y;

//no error

You wouldn’t get an error because the prefix operator returns a reference (rather than an object). Why the difference in return types? In ++y, all that needs to be done is to increment the current value and return a reference to the same object. But in y++, we need to create a new object to store the old value of ‘y’, then increment ‘y’ and then return the new object (which is why postfix form means ‘get value and then increment’). Thus the postfix form would be less efficient than the prefix form since it involves an extra object. And the following fragment will work: i=5; ++++++i; would end up incrementing ‘i’ 3 times (‘i’ would have a value of 8). The statement is equal to: (++ ( ++ (++i) ) ); And the prefix form of ++ has associativity from right to left. This works because the prefix form of ++ returns a reference to the same object. But we wouldn’t want to use such a statement because it reduces readability (you will have to keep counting the number of +s each time you go through the code).

Q&A - 9-11

Q.) Why doesn’t the following code compile? class employee { public: employee(int x) {} }; class teacher:public employee { public: teacher( ) {} }; class librarian:public employee { public: librarian(int y):employee(y) {} }; int main( ) { teacher f1; librarian m1(5); return 0; }

A.) When an object of type teacher is created, the compiler will try to call the default constructor of the base class (i.e. of the class employee). But employee doesn’t have a default constructor and thus the following code produces the error: public: teacher( ) {} The class librarian is fine since here we are explicitly calling the parameterized constructor for employee (here the compiler won’t call the default constructor).

Q.) What does “is a kind of” relationship in C++? A.) This term is just another name for the “is a” relation (public inheritance).

Q&A - 9-11

Q.) Why would a programmer place a constructor in the protected region of a class? Or is this an error? class base { protected: base( ) { cout<<"base constructor"; } }; class derived:public base {}; int main( ) { derived d1; return 0; }

A.) This is perfectly legal. By placing the base constructor in the protected region, a user cannot instantiate an object of type ‘base’. The following code would cause a compiler error: base b1;

//error-cannot access protected constructor

But any class derived from ‘base’ will be able to invoke the base class constructor (as done in the question). The output of the program will be: base constructor

Q.) Is it legal to place the constructor in the private region of a class? class base { private: base( ) { cout<<"base constructor"; } };

A.) This would serve no useful purpose because now even a derived class cannot access the constructor of ‘base’ (because private members are inaccessible by the derived class irrespective of how you inherit the base class). And as discussed in the earlier question, neither can we directly instantiate an object of type ‘base’ (this would lead to a compiler error).

Q&A - 9-11

Q.) What does the following code do? What is the purpose of the keyword ‘using’? class base { protected: void b_func( ) { cout<
A.) Any object of type ‘derived’ can now invoke the function b_func( ) just as if b_func ( ) were a member function of class ‘derived’. If the code: public: using base::b_func; was not written then the following would be illegal: int main( ) { derived d1; d1.b_func( ); //error- cannot access protected member return 0; } The general syntax for ‘using’ in such a scenario is: using base-class-name:: base-class-function-name; We shouldn’t specify the parameters. i.e. the following is wrong: using base::b_func( );

//error

Q.) Why don’t we have a virtual constructor? The concept of ‘virtual’ functions is used since the type of object is not known at compile-time. The calling object is determined at run-time instead. But a constructor is used to create/ construct an object and this is almost certainly known while compiling. We can construct something only if we know what we are going to create. Thus C++ doesn’t provide for virtual constructors (but there are some ways of obtaining the effect of virtual constructors- generally not required).

Q&A - 9-11

Q.) What is wrong with the following code (it crashes sometimes and sometimes it gives weird results): class myarray { public: int *ptr; myarray(int val) { ptr= new int; *ptr=val; } ~myarray( ) { delete ptr;

}

void display( ) { cout<
}

}; int main( ) { myarray arr1(10); cout<
A.) • • • • • •

Object arr1 is visible throughout the program but arr2 is visible only within the scope of the inner block. Within the inner block, arr1 is assigned to arr2 (since assignment operator hasn’t been overloaded for the class the compiler provides a default assignment operator which perform bitwise copy operation). Now the pointer of both arr2 and arr1 point to the same memory location. When we exit the inner block, arr2 object will be destroyed (local objects are destroyed at the end of their scope). The destructor of arr2 will free the memory pointed to by ‘ptr’ of object arr2 (which is actually the same memory location as that pointed by ptr of arr1). Now when arr1 tries to retrieve the value stored, it can’t do so because the memory has already been freed.

Remember: It is advisable to overload the assignment operator and copy constructor in a class which uses dynamic memory allocation.

Q&A - 9-11

Q.) What would be the output of the following? Explain the problem as well. class myChar { private: char alpha; public: myChar(char c):alpha(c) {} int operator!= (const myChar &right) { if (right.alpha!=alpha) return 1; else return 0; } }; int main( ) { myChar ch1('a'); int i = 97; cout<<(ch1 != i); return 0; }

A.) The output will be 0. When the compiler encounters: ch1! = i it is equivalent to: ch1.operator!=(i); But the operator!= function requires a character and the compiler will perform an implicit conversion of 97 into a character (97 happens to be the ASCII value for ‘a’). Thus since a= = a, the output will be 0. To avoid this from occurring, we should use an explicit constructor.

Q&A - 9-11

Bonus questions - Units IX to XI

Interview/ viva questions: 1. What is meant by operator overloading? Why is it necessary? 2. What is polymorphism? 3. Explain run-time polymorphism with an example. Differentiate between runtime and static polymorphism. 4. What is the meaning of ‘has a’ and ‘is a’ relationship in C++? 5. What is the need for an abstract class? 6. What are the operators that cannot be overloaded? Can new operators be defined in C++? 7. What are the dynamic memory operators in C++? What are the equivalent of malloc and free in C++? 8. What are streams? How are they useful? 9. Name some of the predefined streams. 10. What is the difference between: •

cin and cout

•

cout and cerr

•

Random access and sequential access

11. Write a simple program to write and read a character from a file. 12. How is the file pointer used for random file access? 13. Write down the syntax of the main function (including its arguments). 14. If we create a class with no member functions, what are the functions which will be automatically created?

Q&A - 9-11

Extra Stuff: Q.) In the complex numbers class that you had created, overload the + and – operators to add and subtract two complex numbers. Q.) In the same complex numbers class, overload the * and / operator to multiply and divide complex numbers. Q.) Create a class called ‘string’ which will consist of a character array (of maximum length 80). Overload the + operator such that two string objects will be concatenated. Q.) In the same string class, overload the ‘= =’ operator such that we can test whether 2 string objects are equal or not (for comparing use ASCII values/you can also use the ‘strcmp’ function. The overloaded operator function should return a Boolean value just like the normal == operator depending on the comparison). Q.) In the same string class, overload the ‘<=’ operator such that we can test whether the left side string object is less than or equal to the right side string object (the function should return a value just like the normal <= operator depending on the comparison). Q.) Create a class called person and then derive two classes for teaching faculty and non teaching faculty (for a school). The person class should be an abstract class. Q.) Create a file using C++ in which we can store an employee’s details (like name, experience and salary). The user should be able to store as many records as he wants. Q.) Write a C++ program to read the employee record file and display the contents. Q.) Write a C++ program to check whether a given word is present in a text document. Q.) Write a program that obtains the file name from the user through command line argument and returns the number of bytes occupied by the file. Q.) Write a program to encrypt a file (using your own algorithm for encryption) and store it in a different file. Write a decryption program that will retrieve the original file contents.

Q&A - 9-11

416

Useful Classes and Functions - I

The following topics are covered in this section: • • •

Manipulators Flushing setw and other manipulators

There are two ways in which we can perform stream-formatting operations: using manipulators or using the stream member functions.

Manipulators There are many stream-formatting functions available but it is a little tedious to use them. Manipulators duplicate these functions and make it easier to carry out stream-formatting operations. Usually it is the output (what we display on the screen) that needs to be formatted to suit our needs. In this case, ‘cout’ is the stream. One of the most commonly used manipulators is ‘endl’. This is used to end the current line and go to the next line. You cannot use ‘endl’ separately. All the manipulators have to operate on streams. Manipulators that do not require any arguments are defined in the iostream.h header (manipulators with arguments are defined in the iomanip.h header file). Let's check out an example program. # include int main( ) { cout<< "Hi, this is a test program"<
You should see three empty lines above this Each ‘endl’ will cause the present line to be terminated and hence, there will be three empty lines in between the two sentences. Remember: Don't use double quotes on endl.

Useful Classes & Funtions

417 The above program can also be written as: cout<< "Hi, this is a test program"<
Useful Classes & Funtions

418 # include #include #include int main( ) { ofstream out("c:\\test.txt",ios::binary); out<<12; system("PAUSE"); out.close( ); return 0; } When the program executes: out<<12; It will not write the number ‘12’ to the file test.txt. To verify this run your program in windows. While the program is running, because of: system("PAUSE"); The program will pause for the user to press a key. Now go to the desktop, open "My Computer" and in C: drive open the file test.txt (or open this file from ‘Notepad’). You will notice that the file is empty. Thus, though we think that 12 has been written to the file, in reality it hasn’t been written as yet. The number ‘12’ is still in the buffer. Close the Notepad and press a key to continue the execution of the program. After execution once again open the file test.txt in Notepad and you will see 12 written in the file. Thus since the buffer was not full (because we wanted to write only a small number to the file) the data was not written immediately. Instead the buffer waited hoping that more data would be entered. But when out.close( ) was encountered it knew that now it had to flush the data from the stream (because the stream is going to be disassociated from the file). To instantly update the file, we can make use of the flush( ) function as shown below: # include #include #include int main( ) { ofstream out("c:\\test.txt",ios::binary); out<<12; out.flush( ); //12 is written immediately to the file system("PAUSE"); out.close( ); return 0; } In the above program we forcefully flush the stream and data is immediately written to the file. Flushing forcefully is useful in situations where you need to update the file continuously (when there is likeliness of frequent power shortages etc.) otherwise you might lose the data present in the buffer.

Useful Classes & Funtions

419

setw( ) This manipulator is used to set the width of the data being displayed. If the data is longer than the width you specify, this manipulator will not truncate your data to fit the width. Instead it will display the entire data but this will lead to misalignment. The setw( ) manipulator defined in the header since it takes arguments. #include #include int main( ) { cout<
Harry Joe

The diagram should make it clear as to how the setw( ) works.

The statement: cout< #include int main( ) { cout<
Useful Classes & Funtions

420 Output is: 3.46 3 You can see that the result gets rounded up to the number of places that you want. 3.456 is displayed as 3.46 because we set the precision to 3 digits only. The other manipulators available in are: Name of the Manipulator

Purpose

ends

Inserts a null character (‘\0’)

dec

Display integer in base 10

oct

Display integer in base 8

hex

Display integer in base 16

ws

Skip whitespace in input stream

flush

Flush the stream

The manipulators available in are (these manipulators require arguments): Name of the Manipulator

Purpose

setiosflags(names-of-flags)

Set formatting flags

resetiosflags(names-of-flags)

Reset formatting flags

setbase(int base)

where base=8,10 or 16

setfill (char c)

Uses ‘c’ as the fill character

setprecision (int n)

Changes precision to ‘n’

setwidth (int n)

Width set to ‘n’

In the table above ‘names-of-flags’ refers to the formatting flags that can be set/reset depending on which manipulator you use. If a formatting flag is set then that particular format will be active (or effective). The formatting flags are tabulated below:

Useful Classes & Funtions

421 Name of the Formatting Flag

Purpose

ios::showbase

display an integer’s base

ios::showpos

indicates positive numbers by using the + sign

ios::skipws

skip whitespaces

* ios::dec

display integers in base 10.

ios::hex

display integer in base 16

ios::oct

display integer in base 8

*ios::fixed

use fixed notation for displaying floating point numbers

ios::scientific

use scientific notation (i.e. using exponential)

*ios::left

align left

ios::right

align right

* indicates that these flags are already set by default. By the way, these flags are usually known as IOS Formatting flags. If you want to play around with these flags, then you should make use of setiosflags(names-of-flags) or resetiosflags(names-of-flags) An example to illustrate the use of these formatting flags is given below: #include #include int main( ) { cout<
Useful Classes & Funtions

422 The output is: +20 +3.004567e+002 Beware: All the formatting flags come under the namespace std::ios:: This is why we have used ios::scientific and ios::showpos. This will be dealt with in the section on ‘namespaces’.

Useful Classes & Funtions

423

Useful Classes and Functions - II

The following topics are covered in this section: • •

Custom Manipulators Strings

Creating New Manipulators (Custom Manipulators) In the previous chapter we dealt with how to overload << and >>. C++ also provides a way to create your own manipulators. You can create your manipulators to work along with ‘cout’ (output stream object) or with ‘cin’ (input stream object). Let us consider an example of a manipulator dealing with ‘cout’. The syntax for creating a manipulator is: ostream& name (ostream &str) { //code to be executed; } In the case of manipulators to be used with input stream, only one modification is necessary. istream& name (istream &str) { //code to be executed; } Remember: You should return the stream at the end of your manipulator definition. Only then can you use your manipulator in cascaded operation. #include ostream& divider (ostream &str) { str<<"--------------------------------"<>x; cout<
Useful Classes & Funtions

424 The output is: -------------------------------Enter an integer value : 98 -------------------------------The value you entered is : 98 In the above program we have created a new manipulator called ‘divider’. This will simply display a series of dashes on the screen as can be seen in the output. This manipulator can be used for objects belonging to ‘ostream’. Since ‘cout’ belongs to ‘ostream’, we can use this manipulator to operate only on output streams. In a similar way you can also create manipulators to operate on input streams as well. The advantage of creating your own manipulators is that you can reduce on the amount of typing and make your code easier to understand. Stream Formatting Member Functions: The alternative to manipulators is to use the member functions available in streams. Manipulators can be used to perform all the stream-formatting that can be done using member functions. Each stream has a set of format flags associated with it (just like what we have seen earlier). There are member functions available to either set/reset these format flags (the information is formatted depending on the setting of these flags). The functions available are: • • • • •

setf (format-flags); unsetf(format-flags); width (int n); precision (int n); fill (char c);

These functions can be called from streams using the dot operators (since they are all member functions). The setf( ) and unsetf( )functions are used to set and reset the format flags respectively. The list of format flags used are the same as those described for manipulators. The bitwise OR operator ( | ) can be used to set or reset more than one flag using setf( ) or unsetf( ).

Strings There are two methods for creating and using strings. A character array terminated in a null character (‘\0’) is called a string but in new compilers you can make use of a class called ‘string’. There are a few reasons why you might prefer to use the existing string class instead of creating a character array. The problem with a character array is that many (in fact none) of the operators will work with character arrays. You cannot use ‘+’ and expect the two

Useful Classes & Funtions

425 arrays to get added (adding in this case would mean concatenation of the two character arrays). You cannot use the assignment operator and assign a value to your character array. Many beginners make this fundamental mistake. int main( ) { char name[40]; name="John"; //wrong cout<>name; cout< // New style headers #include using namespace std; int main( ) { string name; name="John"; cout<
Useful Classes & Funtions

426 string name; //an empty string string name("John"); //initialized to John string name(another-string); //initialized to value of another-string string name(5,’j’); //initialized to "jjjjj" Again there are different ways to assign values to strings: name = "John"; name = another–string; For example: int main( ) { string s1("Jenny"); string s2; s2=s1; cout<
Useful Classes & Funtions

427 The program would be as below: int main( ) { string s1("Jenny"); string s2; s2=s1; s2=s1+s2; cout< or <. How do you think two strings are compared? See the following results: e > bee - True Hello>hello - True dear>bee - True He>HE - False From the above results it is clear that upper case letters are greater than corresponding lower case letters. An alphabet that comes later in A to Z is greater than one that comes before it. Comparison does not depend on the length of the strings. To find the length of a string, you can make use of the length ( ) member function of the string class. If s1 is a string object with the value of "Jenny", then s1.length( ) Will return a value of 5. Extracting strings: You can extract a part of the string by using the substr ( ) function. The syntax is: substr(position-from-where-you-want-to-start, number-of-characters-to-extract);

Useful Classes & Funtions

428 This function can be called only through a string object (because it is a member function of the class ‘string’). int main( ) { string s1("Jenny is a wonderful person"); cout<
is a

Searching in Strings: There are two functions for the purpose of searching for particular characters or strings within strings. These are the find (find) and reverse find (rfind) member functions. Both functions will return the position (an integer) of the place where the particular character/string is located. Remember: The results that you get are always starting from 0. So if your result is 2, it actually means the 3rd character. #include #include using namespace std; int main( ) { string s1("penny is a wonderful person"); cout<
Useful Classes & Funtions

429

Useful Classes & Funtions

430

Useful Classes and Functions - III

The following topics are covered in this section: • •

Character Arrays Mathematical Functions

Some compilers may not permit String Objects The string objects that we discussed above can be created only in new C++ compilers. In older compilers you cannot create an object of type string (this is because the string class is not defined). In such cases you have to use character arrays terminated by a null character for strings. But there are many functions provided for operating on such strings as well. A few of these are discussed below. These functions were part of the standard C library and it has been incorporated into the C++ library as well. To use these functions, if you are using an old C++ compiler, you should include the header file string.h. If you have a new C++ compiler that supports namespaces, then you should use the header Copying strings and concatenating strings: For copying we have a strcpy( ) function and for concatenation we have the strcat( ) function. int main( ) { char s1[20]; char s2[20]; strcpy(s1,"hi"); strcpy(s2,"bye"); strcat(s1,s2); cout<
Useful Classes & Funtions

431 String length: This function will give you the length of the character array. strlen(character-array) String Comparison: The function will return an integer. The syntax for the function is: int strcmp(char-array s1, char-array s2); If s1>s2, then the result will be 1. If s1 char letter = 'a'; letter = toupper(letter); cout<
Useful Classes & Funtions

432

Mathematical Functions In many of your program you might want to perform some special mathematical operations (other than the basic ones). For this purpose it will be helpful if you know about the existing mathematical functions provided in C++. In older compilers you have to make use of the math.h header file. If you are using a new compiler and adding headers through namespaces, then you should include the header Descriptive Name Trignormetric functions (and hyperbolic)

Purpose

Syntax

calculate the cosine of a given angle

double cos(double angle)

Inverse trigonometric functions

returns the value of the angle in radians

double acos(double value)

Hypotenuse

Pass two arguments, this function will find the hypotenuse.

double hypot (double val1, double val2)

Similar functions sin, tan, cosh, sinh, tanh

asin, atan

Remarks Remember to give the angle in radians (and not in degrees). Radians are in terms of the constant ‘pi’ (one radian equal 180 degrees). It is the opposite of the cos, sin and tan functions. Value should be between –1 and 1 when using acos ( ) or asin ( ) functions. For example: if we code: cout<
Square root

Logarithm

Returns the square root of the given number. Functions to calculate natural logarithm and also base 10 logarithms.

Absolute value Two functions to obtain the absolute value of a

double sqrt (double val)

double log (double val) To calculate natural logarithm of ‘val’.

int abs (int val) The abs( ) function will operate on integers and return

Useful Classes & Funtions

double log10 (double val) To calculate logarithm of ‘val’ to the base 10. double fabs (double val)

log10(10) = 1 log(10) = 2.3

fabs(2.1) = 2.1 fabs(-2.1) = 2.1

To retain the decimal

433

Raising to power

Exponent

number. Absolute value means only positive numbers.

integers.

Raise a base to the power of an exponent. If we say, 23, then 2 is the base and 3 is the exponent. This function will raise the natural logarithm base ‘e’ to the power of the argument provided. The value of e is 2.718.

double pow(double base, double exponent)

double exp(double power)

places use the fabs( ) function.

abs (2.1) = 2. abs (-2.1) = 2 abs( ) will ignore decimal places. pow(2,3) is equal to 8.

cout<
Rounding Off values: ceil: The ceil ( ) function is used for rounding up a number to an integer. But it doesn’t exactly do rounding up. It will return the lowest integer that is greater than the number you gave as argument. double ceil (double val) If val=2.1, then the returned value will be 3. If val= -2.1 then the returned value will be –2. Floor: This is again similar to ceil ( ) function except that this will return the highest integer that is less than the value you provided. double floor (double val) Suppose that val=2.1, after the floor ( ) operation you will get a result of 2. If val = -2.1 then the result will be –3.

Useful Classes & Funtions

434 Random Numbers: The rand ( ) function can be used to generate random numbers. The srand( ) function can be used to initialize the random number generator. srand ( ) will not return any value while the rand ( ) will return a random integer. • •

int rand( ) void srand (unsigned int val)

The example below should clarify your doubts about srand ( ). int main( ) { srand(10); cout<
Useful Classes & Funtions

435

Useful Classes and Functions - IV The following topics are covered in this section: • • •

Good Programming Practices Typedef Bitwise Operators

Good Programming Practices First of all, there isn’t any international standard for the purpose of writing C++ programs. You are free to write the way you want to. This section is something like a section of tips that you could use. •

Always before you start coding, it is better to have a rough idea written on paper. This is called a pseudocode or an algorithm. You will realize the advantages of this when you start coding larger programs.

•

Give a good thought before creating classes. Have a clear idea about what data you want to hide and what are the methods you need.

•

Whenever you make use of mathematical calculations in your program, do not use long statements. For instance do not type: x = 3+4*10/5+1-4/2; Writing something like this might make one feel that the person who wrote this was a genius! Avoid such statements (even the programmer himself would have to break his head before he is certain of the answer). Use simple brackets to break the long calculations into smaller parts as shown below: ( 3 + ( 4 * (10/5) ) + 1 - (4/2) ); Now, anyone will be able to say that the result of the above statement is 10. See how a few brackets can make a big difference!

•

Leave adequate whitespaces in your C++ programs. Whitespaces are not taken into consideration by the C++ compiler. So by using whitespaces you can keep your program clean. ( 3 + ( 4 * (10/5) ) + 1 - (4/2) ); is better than (3+(4*(10/5))+1-(4/2));

•

Indent your C++ programs properly. for (i =0; i<10 ; i++) { for (int j = 0 ; j<10 ; j++) { cout<
Useful Classes & Funtions

436 •

Use braces to clearly define your ‘for’ loops, ‘if’ and while blocks. By using braces to define the starting and ending of these blocks, there will be no confusion as to what statements come under the particular block. { for (int i = 0 ; i<5 ; i++) cout<
The statement i*i is not considered as part of the ‘for’ loop itself. This problem can be avoided if you clearly specify the ‘for’ block. int main( ) { for (int i=0;i<5;i++) { cout<
Useful Classes & Funtions

437 Now there is no confusion about what is included in the ‘for’ block. •

Make sure your variable names are not too long and also try to give some meaningful names for variables. The same rule applies for names of functions, classes and objects as well.

•

Use lots of comments throughout your program. You should always write what you are trying to do within comments. This way, even if you continue your work after one week you will know exactly what you were attempting to do. Use comments as frequently as possible (for functions you can describe about the function in short; for classes you can give a brief idea about the class etc.). Don’t use comments for selfexplanatory code.

•

A new line is not a statement terminator. For instance when using ‘cout’, if the line to be displayed seems to be very long in your compiler you can split it up in two lines as follows: cout<<"This is a really really really" " long line that i am typing";

•

In classes, make sure that you provide all the needed constructors. It is always good to provide a no argument constructor that will initialize all your member data.

•

Avoid using macros for constants and functions. Make use of C++ inline function and the const keyword for these purposes.

•

Be very careful while using the ‘new’ operator. Make sure that every ‘new’ has a corresponding ‘delete’ in the program.

•

Use correct data types (particularly whenever using numerical data types like float, int or double). If an ‘int’ is sufficient don’t go in for ‘double’ (since this occupies more memory and also calculations involving double will take longer). Do not rely on implicit type conversions.

•

Minimize the amount of work performed within loops. Perform calculations which do not involve the iteration variable outside the loop.

•

Avoid using function calls within a ‘for’ loop conditional expression. A commonly used for loop is: for (int j=0; j<=strlen(str);j++) { } This forces the strlen ( ) function to be invoked for every iteration (every function call involves a lot of overhead). You can rewrite the above code as: int len=strlen(str); for (int j=0; j<=len;j++) { } Now the strlen( ) function is invoked only once.

Useful Classes & Funtions

438

Typedef Typedef basically stands for type definition. The keyword ‘typedef’ lets you create your own data types; well, not exactly your own data types but your own names for the standard data types. Consider the following: int x; means that x is declared to be an integer variable. Now, using typedef you can give a different name for ‘int’. The syntax for using different names instead of the standard ones is: typedef standard-name new-name; For example: typedef int weight; weight x=50; In this case, we are using the name of ‘weight’ instead of the standard name ‘int’. Thus you can now declare your variables by using ‘weight’ instead of ‘int’. Basically we are just giving ‘int’ a new name called ‘weight’. Remember: By using typedef we are only giving a new name for an existing standard data type. We are not creating a new data type.

Bit-wise Operators This section will explain another set of operators. Bit-wise operators will act on binary digits. Maybe you know that C programming supports assembly level programming. In assembly level programming there is a definite necessity for operating on bits (mind you, not decimal numbers but binary digits). There might be other applications where you would like to manipulate data at the bit level. For example you could use it for hiding data within images (this is called steganography). You can make some bit level manipulations in your image file (such that the image appears to be the same) and hide data within the file. Basically if you want to operate on the individual bits instead of operating on the number as a decimal number, then you should use bitwise operators. Bit-wise operators can also be used to perform some calculations faster or with lesser number of steps. The bit operators are: • • • •

AND (&) OR ( | ) EX-OR (^) NOT (~)

If you’ve done a course in digital electronics you will know about the AND gate, OR gate, EXOR gate and NOT gate. These operators are exactly similar to these logic gates. Let us assume that ‘x’ and ‘y’ are two separate bits (they are binary digits not decimal numbers). The effect of each operation on these bits is shown below:

Useful Classes & Funtions

439 x

y

x&y

0

0

0

0

1

0

1

0

0

1

1

1

AND Operation The AND operator will give a result of 1, only if both ‘x’ and ‘y’ are equal to 1. Similarly, the OR operator will give a resultant value of 1 if ‘x’ or ‘y’ value is 1. EX-OR (stands for exclusively OR). This operator will yield a value of 1 only if ‘x’ alone is 1 or if ‘y’ alone is 1. The NOT operator is also known as the complementary operator. If you give an input of 1, the output will be 0 and vice-versa. x

y

x | y (x OR y)

0

0

0

0

1

1

1

0

1

1

1

1

x

y

x ^ y (x EXOR y)

0

0

0

0

1

1

1

0

1

1

1

0

OR Operation

EX-OR Operation x

~x (NOT x)

0

1

1

0

NOT Operation

Useful Classes & Funtions

440 First of all, you should have an idea about how these operations will work on a group of binary digits. Eight bits make up a byte and we have already seen the process of conversion from decimal to binary format in the first chapter itself. Let us assume that we have two numbers: 128 and 255. Their binary representations will be: 0100 0000 and 1000 0000.

0 1 0 0 0 0 0 0 When you perfom bitwise AND operation, each pair of bits & 1 0 0 0 0 0 0 0 are ANDed individually -----------------0 0 0 0 0 0 0 0 Resultant value (0)

0 1 0 0 0 0 0 0 OR operation performed |10000000 -----------------1 1 0 0 0 0 0 0 Resultant value (192)

0 1 0 0 0 0 0 0 EXOR operation performed ^10000000 -----------------1 1 0 0 0 0 0 0 Resultant value (192)

0 1 0 0 0 0 0 0 NOT operation performed on decimal value of 64 ~ -----------------1 0 1 1 1 1 1 1 Resultant value (191)

Useful Classes & Funtions

441 If you apply the tabulation that was given, you will get the results shown above. We can do obtain the same result using a C++ program. int main( ) { unsigned char x,y; x=128; y=64; cout< The only difference is in the way the compiler searches for the iostream.h file. If you use the double quotes, the compiler will start searching for the header file in the directory where you have your source file. If it doesn’t find it here, it will then search in the directory where the compiler is supposed to search for header files. If you use the angle brackets, the compiler will search in the directory supposed to be having all header files. You usually have an option in your C++ compiler where you can change the default directory used by the compiler (of course don’t change it unless you have specifically made a new directory with the header files). #define: We’ve seen about this in the section on constants. This used to be the method for C programmers to create constants. Constants created using #define are also called as "macros". It is not only used to create constants but can also be used for defining functions. It is equivalent to the inline function option available in C++. Of course in C++ it is not advisable to use #define because you can make use of the inline keyword and also the const keyword. #undef: This is the opposite of #define. It will undefine anything that you defined earlier. For example: #define speed 100 #undef speed #define speed 200

Preprocessor Directives

444 #if….#elif…..#else…..#endif : This is equal to our if….else if….else statement construct. Endif is used at the end to indicate the end of the ‘if’ block. #include using namespace std; #define speed 200 int main( ) { #if speed= =200 cout<<"Speed is 200"; #elif speed = =100 cout<<"Speed is 100"; #else cout<<"I don't know what's the speed!"; #endif return 0; } The output is: Speed is 200 #elif is actually a shortened expression for else if. Instead of mentioning the directives inside the main ( ) function you could use them for defining the value of some other value outside the main ( ) function. #include using namespace std; #define speed 200 #if speed= =200 #define brake 100 #elif speed= =100 #define brake 50 #else #define brake 25 #endif int main( ) { cout<
Preprocessor Directives

445 #ifdef…..#ifndef: #ifdef means if the particular variable is defined do something. #ifndef means if the particular variable is not defined do something. The syntax is: # ifdef variable-name //body #endif This can also be written as: # if defined (variable-name) //body #endif Check out a short program given below: #include using namespace std; #define speed 200 int main( ) { #ifdef speed cout<<"Speed Defined"; #else cout<<"Speed not defined"; #endif #ifndef brake cout<
Preprocessor Directives

446 #line: All your programs have a certain number of lines (depending on the size of your coding). When you get errors, the compiler will inform you about the line number, which has an error. Using the #line line-number you can change the starting line number that is used by the compiler for the program. This might not seem very useful to you but anyway it’s better to know about the various directives that exist. #pragma: This is used to make changes in your compiler settings. The use of this directive is compilerdependent since each compiler will have its own pragma directives. For example the #pragma pack ( ) directive (which we discussed in an earlier chapter with reference to padding of structures) is available in VC++ but not in Turbo C++. The preprocessor also recognizes two operators: # and ##. 1. The String operator (#): When this operator is used in a macro definition, it will convert whatever follows it into a string. #include using namespace std; #define disp(val) cout<<"You passed : " #val int main( ) { disp(20); return 0; } The output is: You passed : 20 Similarly if you write: disp(Hi); the output would be: You passed : Hi Actually, the operator # is equal to inserting two double quotation marks (this makes anything into a string).

Preprocessor Directives

447 2. Concatenation Operator (##): This is used to concatenate the operands. The operands could be anything. #define conc(a,b,c) a ## b ## c int main( ) { cout<
hiandbye

It might seem crazy to use such operators, but it is better to know about the various features that exist. Actually, programmers rarely use these two operators.

Standard defined Macros The compiler already has some defined macros. They are: __FILE__ gives the filename __LINE__ gives the line number __DATE__ gives the date the code was compiled __TIME__ gives the time the code was compiled __cplusplus this is defined when the source code in compiled as a C++ code Check out an example: #include using namespace std; int main( ) { cout<
Preprocessor Directives

448

Namespaces and new headers The programs that we've seen so far are not wrong but they can't be called as 100% C++ programs either. The reason is because we've been making use of header files (such as iostream.h etc...). Making use of these .h files is more similar to C programming. Of course it isn't wrong to use them in C++ but there is a better method provided in C++. This method makes use of namespaces. Instead of # include we shall use the following two lines: #include using namespace std; Firstly take note of the fact that there is no ‘.h’ in the include statement. This is the format of the new style headers used in C++. They do not use .h files. Old C++ compilers may not support namespaces. In case you are using such a compiler then you have to stick to the old method of #include with the ‘.h’ extension. But all the latest C++ compilers will support namespaces and they will also support the old style headers. When C++ was created it used header files like those used in C programming. But then changes were made. Though it still supports the old header files, they are not recommended. You know that iostream.h is a file. C++ created a new style of its own. In this method we do not specify filenames. Instead it is a method that makes sure that appropriate definitions required by the C++ library have been declared. The new style headers are not filenames and hence the .h extension is left out. The tabulation below lists out the various headers we have used and their equivalent new style headers. Old style header name

Equivalent new style header

Purpose

iostream.h



General purpose I/O

fstream.h



File I/O operations

iomanip.h



Manipulators

string.h



character array string operations

math.h



Mathematical Functions

stdlib.h



Memory allocation, numeric and system functions

-

(supports the string class).

String objects

Namespaces & Newheaders

449 If you notice in the tabulation above, some of the new style headers make use of the prefix ‘c’ in the header file. For example: stdlib.h is now: These headers were actually part of Standard C and since C++ supports C these headers were retained. Though these headers are supported they could be eliminated in the future. When using a new style header you can make use of the namespace statement: using namespace std; A namespace is a region of declaration. The purpose of namespace is to avoid collision of identifiers (i.e. to avoid collision of variables or class names or function names etc.). Elements declared in one namespace are different from those declared in another. Always make use of C++ new style headers whenever you write a C++ program. The first.cpp program using namespaces: You can make use of new style headers in all the other programs that we have seen so far. Thus the first program you wrote will become: # include using namespace std; int main( ) { char letter; cout << "Enter any letter" ; cin >>letter; cout << "The letter you entered is : " <
Namespaces & Newheaders

450 The problem can even be extended to function names( ). You could end up having a program that has two functions performing different tasks, having the same name and arguments. For example, both libraries may have the function draw( ). But both may have a different meaning to the function. So when you use the function draw ( ), the compiler would have a problem in deciding which library function it should use. Namespaces were created to solve these problems. What namespace does? Namespace localizes the visibility of names declared within it (the names are only visible within that particular namespace). So when you refer to some name, you can specify the namespace to which it belongs to avoid conflicts. Syntax: General form for creating a namespace is: namespace name { // declarations } Anything defined within a namespace is only within the scope of the namespace and not available outside. Example: #include using namespace std; namespace bact //A namespace called bact { int life; class bacteria //class belonging to namespace bact { private: int step; public: bacteria( ) { cout<<"\nCreated Bacteria"; } }; } //End of bact namespace

Namespaces & Newheaders

451 namespace vir //Another namespace ‘vir’ { int life; class virus { private: int step; public: virus( ) { cout<<"\nCreated virus"; } }; } int main( ) { bact::life=1; vir::life=0; bact::bacteria fever; vir::virus cholera; cout<<"\nThe bacteria has a life : "<
‘life’ is visible within 2 namespaces. So when referring to it, you have to use the scope resolution operator to access it (to indicate which ‘life’ you are referring to).

Similarly when creating an object belonging to the class ‘bacteria’, remember: •

The class ‘bacteria’ is present within the namespace ‘bact’. So you have to specify the namespace and then the scope resolution operator.

But once the object has been created, you needn't keep specifying the namespace (i.e. for calling member functions you needn’t specify the namespace again).

Namespaces & Newheaders

452 The ‘using’ Keyword In the previous section, you must have noticed that each time we refer to a namespace variable you have to make use of scope resolution operator. You also need to specify the namespace. Doing this repeatedly is a tedious job, especially if you are going to make use of a particular namespace frequently. Imagine how a simple program cluttered with the name of the namespace and the scope resolution operator everywhere would look. The best solution is to use the keyword using. What about namespace std? The std namespace is the area in which the entire Standard C++ library is declared. Remember how we start our programs: #include using std namespace; int main ( ) { } The ‘using’ statement informs the compiler that you want to use the ‘std’ namespace. The keywords cout, cin etc. are all present in the std namespace. You can also make use of the following method for writing programs: #include int main ( ) { int x ; std:: cout<< "Enter a number : "; std:: cin>>x; std :: cout<
Namespaces & Newheaders

453 There are two methods to make use of the using keyword: using namespace name; //This is called as the Using Declaration Example: using namespace bact; or using name :: member; //This is called as the Using Directive Example: using bact :: life; In the first case, you don't need to make use of scope resolution when you are referring to any variable or function belonging to namespace ‘bact’. In the second case, only the variable ‘life’ belonging to the ‘bact’ namespace is made visible. Check out the example below: #include //we’ve not specified using namespace std; namespace bact { int life; class bacteria { private: int step; }; } namespace vir { int life; class virus { private: int step; }; } int main( ) { using namespace bact; //the compiler uses bact namespace life=1; //this refers to ‘life’ of ‘bact’ vir::life=0; bacteria fever; vir::virus cholera; std::cout<<"\nThe bacteria has a life : "<
Namespaces & Newheaders

454 In the main ( ) function, we have said using namespace bact; ‘life’ is a variable belonging to ‘bact’ namespace and the class ‘bacteria’ is a class belonging to the ‘bact’ namespace. Since you’ve asked the compiler to use the ‘bact’ namespace, you don't need the scope resolution operator whenever you are referring to something from ‘bact’ namespace. Suppose you want to refer to the ‘life’ variable of the namespace ‘vir’, then you have to explicitly say so (using scope resolution). Note that in the above program we are making use of std::cout because we haven’t mentioned: using namespace std; So, we need to explicitly state the namespace to which ‘cout’ belongs to (otherwise your compiler will say that it doesn’t know what ‘cout’ is). What if we declare a variable outside the namespaces? In C++, if you declare a variable outside the main ( ) function and outside all other functions, then the variable becomes a global variable. If you declare a variable outside all namespaces, then the variable is now present in the global namespace. Check out the example below: #include int life=0; //life in the global namespace namespace bact { int life; //life in bact namespace class bacteria { private: int step; }; } int main( ) { bact::life=1; ::life=0; std::cout<<"\nThe bacteria has a life : "<
Namespaces & Newheaders

455 The output would be: The bacteria has a life : 1 The organism has a life : 0 When we say: ::life it refers to the ‘life’ present in the global namespace. Beware: You cannot create namespaces within functions. Namespaces can be nested (one within the other).

Namespaces & Newheaders

456

Advanced C++ - Part IIIa (Creating Libraries)

Creating Libraries We still haven’t achieved implementation hiding in the real sense. Any user of your class can open the *.cpp files and modify your function definitions. Generally, the creator of a class wouldn’t want to let a user do this. Also, the user will now have to copy the car.cpp file into his project directory and compile it before he can run his program. Wouldn’t it be simpler if the user could just put a #include statement in his project without having to bother about someone else’s *.cpp files? This is where a library comes into the picture. The class creator can create a library file as well. When others want to use his class, they have to just include his header file and also ask the linker to search for the class implementation in the new library. A library is a collection of object files (i.e. the output of the compiler stage). Let’s create a library to make the concept clear. (We’ll look at the process to be followed in VC++. The appendix section will deal with C++ on Unix/Linux). First we’ll need to create a library. Go to File and choose New. In the options tab choose Projects.

Name the project as carlib and click the OK button. The next dialog box will ask if you want to include MFCs or other files. Don’t choose any of these (for this library we don’t require anything extra). Add a new header file (carlib.h) to this project. Include the following code:

Creating Libraries

457 //carlib.h #include using namespace std; class car { private: char color[20]; int speed; public: car( ); void input( ); void display( ); ~car( ); }; Include a source file (named car.cpp) in this project. The code for this will contain the implementation details of the class ‘car’. #include "carlib.h" car::car( ) { cout<>color; cout<>speed; } void car::display( ) { cout<
Creating Libraries

458 If someone wants to use your library then all you need to do is supply them with the carlib.lib file and carlib.h header file. The *.lib file contains the object code while the carlib.h file just contains the interface to your class. Anyone who uses your class can take a look at the *.h file to know what functions are available for them to use (of course for a more complex class you would have to provide some documentation in the header file). Let’s use this library in a program to check if it works. Create a new application project and include a C++ source file into the project. Name it as mycar.cpp and type the following code: //mycar.cpp #include "carlib.h" int main( ) { car mine; mine.input( ); mine.display( ); return 0; } Now compile mycar.cpp and voila! You should have an error saying: c:\tutorial\mycar\mycar.cpp(2) : fatal error C1083: Cannot open include file: 'carlib.h': No such file or directory The error message is self-explanatory. We haven’t told the compiler as to where the file carlib.h is present. You have 2 options at this point: 1. Copy that file into your current project directory and include it in this project. 2. Your compiler will search for include files in particular directories. You can add the name of the directory where your *.h file is present to this list (this is usually present in the Project Settings option). Since we are planning to distribute our library to a 3rd person, we’ll take the first route. Copy the file carlib.h into your current project directory. Then go to VC++ and make sure that you include this file into your current project (otherwise VC++ will not consider this file as part of the project even though it is physically present in the same directory). For doing this go to PROJECT -> Add to Project -> Files and choose the header file. Now compile mycar.cpp. You shouldn’t have any errors this time. The next step is to build the exe file mycar.exe. Go to ‘BUILD -> Build mycar.exe’ option. Well, you should be getting a bunch of errors this time (which might appear weird). The following messages appeared in my computer: Linking...

Creating Libraries

459 mycar.obj : error LNK2001: unresolved external symbol "public: __thiscall car::~car(void)" (??1car@@QAE@XZ) mycar.obj : error LNK2001: unresolved external symbol "public: void __thiscall car::display(void)" (?display@car@@QAEXXZ) mycar.obj : error LNK2001: unresolved external symbol "public: void __thiscall car::input(void)" (?input@car@@QAEXXZ) mycar.obj : error LNK2001: unresolved external symbol "public: __thiscall car::car(void)" (??0car@@QAE@XZ) Debug/mycar.exe : fatal error LNK1120: 4 unresolved externals Error executing link.exe. Don’t panic on seeing the strange symbols. From the error messages we can deduce that this is a linker error (compiling went fine but linking failed). Why? If you look at the individual messages you’ll realize the problem. The linker hasn’t been able to resolve references to certain function definitions (car::~car( ), car::display( ) etc.). They are not present in carlib.h, not in mycar.cpp and certainly not in #include. So, should we add car.cpp to this file (but then we are not using the power of libraries). Car.cpp contains the definitions of these functions but carlib.lib contains the object code for all these functions. The linker only requires the object code for the functions and hence we should include the library carlib.lib in our current project. Then the linker will search carlib.lib and find the required object code for all the definitions. To do this, there are 2 settings you have to change in your project: 1. Tell VC++ the path where to search for the libraries. 2. Tell VC++ the name of the library. For step 1 go to TOOLS-> OPTIONS. You’ll get a pop-up box with lots of tabs at the top (as shown below):

Creating Libraries

460 We need to tell the path for the Library files. So change the SHOW DIRECTORIES FOR option as shown below:

Now add the pathname where you have the file carlib.lib (click the new icon present in the options dialog box to add a new path).

In my case it is in the current project directory itself. Click OK. Next we need to tell VC++ the name of the library we want to use. Go to PROJECT-> SETTINGS and you’ll see a dialog box as shown below:

Creating Libraries

461

In the object/Library modules text field, enter our library name carlib.lib at the end of the list. This will automatically get added in the Project Options textbox at the bottom. Click OK and now build the exe file. You shouldn’t encounter any errors this time since the linker will be able to obtain the object code for all the function definitions. What have we achieved by using a library? The class user is now totally unaware about the implementation details of your function. Since the library is in object code, no user would try to manipulate the contents of the library file (you could open the library file in Notepad to view the contents which would appear cryptic). The library file would be something like this (the snapshot is only part of the file):

This isn’t something that a user would want to play around with! What we created is called a static library. There are 2 types of libraries: • Static • Dynamic (or shared). Static is simple to create but has a major disadvantage. If many programs make use of static libraries and if all of them are being run at the same time, then each program will have a copy of the library in memory. Shared libraries (or dynamic link libraries) overcome this problem.

Creating Libraries

462

Advanced C++ - Part IIIb (Creating libraries)

The programs that we've seen so far are not wrong but they can't be called as 100% C++ programs either. The reason is because we've been making use of header files (such as iostream.h etc...). Making use of these .h files is more similar to C programming. Of course it isn't wrong to use them in C++ but there is a better method provided in C++. This method makes use of namespaces. Instead of # include we shall use the following two lines: #include using namespace std; Firstly take note of the fact that there is no ‘.h’ in the include statement. This is the format of the new style headers used in C++. They do not use .h files. Old C++ compilers may not support namespaces. In case you are using such a compiler then you have to stick to the old method of #include with the ‘.h’ extension. But all the latest C++ compilers will support namespaces and they will also support the old style headers. When C++ was created it used header files like those used in C programming. But then changes were made. Though it still supports the old header files, they are not recommended. You know that iostream.h is a file. C++ created a new style of its own. In this method we do not specify filenames. Instead it is a method that makes sure that appropriate definitions required by the C++ library have been declared. The new style headers are not filenames and hence the .h extension is left out.

Multiple File C++ Programming So far we’ve been writing programs within one source file. The entire program (including class declarations, functions etc.) was written in one single *.cpp file. This file was compiled and run to check the output. In this section I would like to explain the process by which an executable file is created from our C++ source file. Let’s assume that we’ve written a source file called test.cpp. What are the steps involved after that? Broadly you can say that four people are involved: • • • •

Preprocessor Compiler Assembler Linker

As mentioned earlier, the preprocessor will search for the preprocessor directives. It will convert these directives into C++ coding. In other words, the include header files will be

Creating Libraries

463 inserted into your source file. If you have used macros, they will be substituted in the corresponding places. Next, the compiler takes over. The compiler will read through the whole program, and in case it finds any problems while compiling, it will display compile time errors. Otherwise it will convert your source code into assembly language code. The assembler will finally convert your assembly language code into machine language (i.e. into language that your computer can understand). What is produced by the assembler is known as an object module (or a single translation unit because the source code has been translated into object code). Is the process over? Even in a most basic C++ program we make use of other library functions and objects. Thus there are a few other object modules that are related to your C++ program. Only when these modules are linked with your object module, can the program work. The linker takes care of this aspect. All the different units are linked together to form the final executable program. So, nowadays when we say a compiler, for example the Turbo C++ compiler, it usually contains all the required parts (a compiler, preprocessor, linker and assembler). Thus you needn’t worry about these individual parts of the compiler. But when you do create a multiple file C++ program, you should beware that just because all your individual files compile successfully doesn’t mean that they will be linked properly. You can get linker errors (possibly you forgot to include some header file or something like that). The question arises, why should we go in for multiple file programming? When a program is very complex it is always advisable to break up the program into smaller units. In C programming, we would define the functions in a separate header file and then include this header file in our source file. In C++ we are bothered with classes. So, instead of functions, we will define classes separately. What we will do is to define the class in a header file. We will not define the member functions in this file (we will only declare all the member functions). The definitions will be done in a *.cpp file using the scope resolution operator. Now when you want to write a program using that class, you will simply include the header file in your source code. What about compiling? Header files cannot be compiled. But now you have two *.cpp files (one with the member function definitions and the other is your source file). We will compile both files separately and then when you build your project the linker will link up both the object modules together. Might seem a bit confusing but an example should make things easier to understand. One more point to remember: Member functions are defined in a separate *.cpp file. This is usually referred to as the implementation. The idea is to keep the implementation of the class separate from the declarations.

Creating Libraries

464 Creating a Multiple File Program The example demonstrated below has been tried in Turbo C++ as well as in VC++. Other compilers will also have similar options available. First of all we shall take a look at how to create a multiple file program in Visual C++ (later we’ll deal with Turbo C++). Click on File and then choose New. You’ll have a lot of options like (File, Project, Workspace etc…). Choose the Projects tab and in that you’ll have numerous choices available. Choose Win 32 Console Application from the list and give a suitable name. Let us assume that the name is given as carcheck. Choose the option which says "Create New Workspace" and then click on Finish/Ok. If you are using Visual C++ 6.0, another menu will pop up asking what type of application you want to create (whether you want an empty project or whether you want a "Hello World" application etc.). Choose "Empty Project". The new workspace will be created with the name as "carcheck". You will have two tabs with the labels "Class View" and "File View". This will give you an idea as to what are the classes and files present under your current project. Click on the FileView tab and you’ll see that there are no files there. Now again go to "File" and choose "New". This time create a new C++ header file. Give a suitable name (here we have named it as ‘car’). Now you’ll have a new header file called car.h within the "FileView". This file will be empty and we shall now declare our class within this file. //car.h #include using namespace std; class car { private: char color[20]; int speed; public: car( ); void input( ); void display( ); ~car( ); }; As you can see, all the functions have only been declared in the file car.h (we have not defined them here). Next, go to "File", "New" and create a new C++ source file. Name this file as car.cpp. Open the file in your editor window and type in the following:

Creating Libraries

465 //car.cpp – we will define the various functions in this file. #include "car.h" car::car( ) { cout<>color; cout<>speed; } void car::display( ) { cout< using namespace std; was used in the car.h file. car.h is a header file created by us. So, it is present in the directory where we are doing our project. But is present in the compiler’s include directory. Hence for car.h we include it using the double quotation and for iostream we use the angle brackets.

Creating Libraries

466 //main.cpp #include "car.h" int main( ) { car mine; mine.input( ); mine.display( ); return 0; } Now, compile this file (main.cpp). After compilation, you can go to "Build" and choose "Build carcheck.exe". It is now that the linker will work and link up everything. After this, go back to "Build" and choose "Execute carcheck.exe". The output will be: New car created. Enter the color : red Enter the top speed : 300 The color is : red The top speed is : 300 Your car is destroyed. Remember: The header car.h already include , so there is no need for you to include again in the file main.cpp. Beware: When you are linking many object modules together, only one of them should have the main ( ) function. In the above case we created two object files from car.cpp and main.cpp but only main.cpp had the main ( ) function. By the way, in Visual C++ workspace files are stored with the extension *.dsw. Preventing multiple inclusions of Header files in a program: Usually when creating header files, the programmer will provide a provision so that the header file is not included in the source code more than once. To do this, we can make use of the preprocessor directives. The modified ‘car.h’ file will be: #ifndef CAR_H #define CAR_H #include using namespace std; class car { private:

Creating Libraries

467 char color[20]; int speed; public: car( ); void input( ); void display( ); ~car( ); }; #endif The header file be included within the source code only if CAR_H has not been defined. This prevents multiple inclusions of the ‘car.h’ in a program. CAR_H actually stands for ‘car.h’ (you cannot use the dot in preprocessor directives and thus have to use an underscore). You can use car_h or CAR_H (programmers usually prefer to use the latter). If you are using Turbo C++ In Turbo C++, the above process is much easier. First of all create 3 files as done previously (car.h, car.cpp and main.cpp). Next you have an option that says "Project". Click on that and choose "Open Project". Since you still haven’t created a project, just type in some name for the project (ex: carcheck.prj) and click open. (In Turbo C++, project files have a *.prj extension). You’ll see a new project window at the bottom of the screen. Again click on "Projects" and choose "Add new item". A list of all the files will pop up on your screen. Locate the two files (car.cpp and main.cpp) and click on "Add". After adding both the files, choose "Done". Now both your *.cpp files have been added to the project. Next, you have to compile both these files. Do the compiling as you normally would. Open the file car.cpp and then click on "Compile". Then open main.cpp and compile this file also. Now if you look at the project window at the bottom of the screen you’ll notice that there are two items listed: car.cpp main.cpp Once you compile the two files, the project window will also display the number of lines in each file, whether they have any data etc. Next choose "Build All" from the "Compile" option menu. Once successfully done, you can choose "Run" and your program will execute. To summarize the concept of multiple file programming:

Creating Libraries

468 All C++ classes can be divided into two main parts: Class Declaration: This is also called as the interface of the class. It just contains information about the data members and the various functions that are available in the class. This is usually in the header file (in our case it was in car.h). Class Implementation: This defines all the member functions that were declared in your header file (in our case it is car.cpp). This will help you to hide the implementation from the user. Even though you may change your implementation, the class interface will remain the same.

The keyword ‘extern’ The ‘extern’ keyword was briefly mentioned in the chapter on data types. This is basically another storage class specifier (the others are static, auto and register) which you can use with your data types when you declare them. When you develop a project consisting of many separate files there is a good possibility that you will be using global variables. The question arises, "Should we declare and define global variables in each of the files?" (because each *.cpp file will be compiled separately). This is not allowed in C++ and it is bad programming practice to declare and define the same global variable in more than one place. Hence in C++ we have ‘extern’. This will only declare a variable, it will not define it. Only when we define a variable will the compiler allot memory for the variable. Usually declaration and definition of a variable occur at the same time. But when we use the extern specifier (which stands for external), we tell the compiler that this is only a declaration (the definition of the variable is done in some other file). Thus usually all global variables are defined in one separate file and in all the other places we only declare the variable. The syntax is: extern data-type variable-name; The linker will take up the responsibility of resolving all the references made to the external variable. Another use of Extern: By default, C++ compilers will link all your functions as C++ functions. All C++ compilers make use of name mangling. When the compiler reads through the source code and encounters a function name, it stores the details about the function in a table (called a symbol table). For example if we have a function: void sub (int, int);

Creating Libraries

469 the compiler will store this function in its symbol table. But functions in C++ are name mangled, i.e. the function name stored by the compiler is not the same one as given by us. The compiler may store it as: sub_int_int Thus whenever the compiler encounters a function call to sub ( ) it will retrieve the appropriate definition for the function at compile-time. Name mangling permits C++ to implement function overloading. Let us say we have another function with the same name ‘sub’: void sub (double,double); The compiler will store this as sub_double_double Thus whenever there is a statement calling the function sub ( ), the compiler will check the data types of the arguments and call the correct function. C compilers do not implement name mangling and thus they do not support functionoverloading. Different C++ compilers (supplied by different vendors) may implement name mangling in a different way but the bottom-line is that all C++ compilers implement name mangling. Other languages mostly do not use name mangling (C compilers do not mangle names). Let us suppose that you have written a few functions in C and have compiled them using a C compiler. Now in your C++ program you want to use those C functions. Is it possible? C++ will mangle all the function references and the mangled names will not be the same as the original C function name. Thus the linker won’t be able to match the function call (compiled in C++) to the function definition (compiled in C). To overcome this problem we need to tell the C++ compiler, "Do not mangle this function since it is not a C++ function". The extern keyword can be used for this purpose. The syntax is: extern "name-of-the-language" function Beware: You cannot use this within a function (it wouldn’t make any sense to do so). Always make such declarations global. Example: extern "C" int display ( ); //global declaration

Creating Libraries

Creating Libraries

The C++ compiler now knows that the function display( ) is a C compiled function and so it won’t mangle the function name display( ). Sometimes if you have many functions that you want to link as a different programming function then you can do it as follows: extern "name-of-language" { //function declarations/headers can also be included here }

470

471

Advanced C++ - Part IV The following topics are covered in this section: • • •

Exception Handling Templates Template Classes

Exception handling Older C++ compilers will not support exception handling. This feature is used for dealing with certain specific situations (these situations are not supposed to occur and if you don’t provide some way of dealing with them then your program could simply freeze when the conditions really occur). To implement exception handling, C++ provides us with three keywords: o Try o Catch o Throw How do they work? First you try (or execute) the coding and in case some special situation is encountered, then the program will throw an exception. The exception that is thrown will be caught by the catch part of the program. #include using namespace std; int main( ) { float a,b; try { cout<<"\nEnter a number : "; cin>>a; cout<<"\nEnter the denominator : "; cin>>b; if (b= =0) { throw 0; } cout<<"\nResult of division : "<
Advanced C++ - IV

472

The output if you enter two non-zero numbers will be: Enter a number : 5 Enter the denominator : 4 Result of division : 1.25 Suppose the second number you enter is zero, the following will result: Enter a number : 5 Enter the denominator : 0 Error - You entered : 0 You should note that once the program throws something, it will not execute what follows it within the try block. It will go directly to the catch block and execute the underlying statements. The catch block that you write should immediately follow after the try block. Even if you add one display statement between the try and catch blocks it will lead to errors. Can I have more than one catch? Yes but each catch should catch a different exception (meaning that the argument types for each one should be different). You can write one catch block to catch integers, one to catch strings etc. Suppose you want to catch everything that is thrown, there is a simple way to do it. Just use: catch(…) { //body of the catch } The 3 consecutive dots imply that this ‘catch’ block will catch anything that is thrown. Uncaught Exceptions What will happen if we throw a string but we have programmed only for catching integers? This is what is called as an uncaught exception and if you try it out, your compiler will display the message: Abnormal Program Termination Actually, the compiler executes the terminate ( ) function. The terminate ( ) function will in turn call the abort ( ) function. Usually, if there is some problem with the exception handling, then the compiler would either go to the terminate ( ) function or it would invoke the unexpected ( ) function. The unexpected ( ) function will call the terminate ( ) function. Hence, ultimately the program will call the abort ( ) function. You can create your own version of the terminate function (in other words, you can set the terminate function) using: set_terminate(your-function);

Advanced C++ - IV

473

For using this, you would need to make use of the header file. #include #include using namespace std; void myterminate( ) { cout<<"\nMy Terminate Function"; abort( ); } int main( ) { float a,b; try { set_terminate(myterminate); cout<<"\nEnter a number : "; cin>>a; cout<<"\nEnter the denominator : "; cin>>b; if (b= =0) { throw "zero"; } cout<<"\nResult of division : "<
Advanced C++ - IV

474

want the program execution to continue once the compiler encounters some problem in exception handling. The also defines some standard exceptions that are thrown. For example: bad_alloc - thrown if some problem is encountered using ‘new’ bad_exception - thrown when exception doesn't match any catch

Just check out the following program: #include #include using namespace std; int main( ) { int *p; try { p = new int; } catch(bad_alloc) { cout<<"\nError in Allocation "; return 1; } return 0; }

Templates This section is intended to provide a brief idea about templates rather than going too deep into the topic. Again this is a new feature incorporated in C++. First of all, you should know the reason behind the need for templates. Suppose you are writing a program in which you want to compare two numbers (finding out which one is greater or whether they are equal). Maybe in your program, once you want to compare integers and once you want to compare float quantities. As you know, you could write two separate functions to perform the task (of course you might in fact even feel that functions are not needed but let’s assume that you want to use functions). It seems odd that we’d have to write separate coding for integers and floating points (the process will be the same and only the data type is going to be different). Hence, instead of creating a specific function (for each data type), we can use a template function (or a generic function) to write a general function that would work with any data type.

Advanced C++ - IV

475

The syntax for creating a template function would be as follows: Template return-data function-name (parameters) { //body of function written using mytype as the data type } or Template return-data function-name (parameters) { //body of function written using mytype as the data type } To make it generic we have to write the entire function using mytype as the data type. What is mytype? Have a look at the example that follows. In this program we want to compare two numbers (a and b) and return 1 if a>b, return 0 if a=b and return –1 if a using namespace std; template int compare(mytype x,mytype y) { if (x>y) { return 1; } else if (x
Advanced C++ - IV

476

cout<<"\nComparing integers a and b the result is : "< using namespace std; #define max(a,b) (a>b?a:b) int main( ) { int a,b; double i,j;

Advanced C++ - IV

477

a=5; b=10; i=1.45; j=1.35; cout<(--b) ? (a++): (--b) The end result is that it decrements ‘b’ two times. You won’t have this sort of problem when you make use of C++ inline function. And you also won’t have the problem when you make use of template functions.

Template Classes In this case, we make the member data types of generic type. This is done whenever the functions performed by the class are the same (irrespective of the data type of the members). For instance, if you take the working of a stack the working is the same whether the data are integers or characters. Hence in such cases you can create a generic stack class that can operate on any type of data.

Advanced C++ - IV

478

The syntax to create a class similar to creating a template function. template class name-of-class { //body of class }; To create an object belonging to the class: name-of-class object-name; An example should make it clear; here we are just going to pass two different types of data to a class and use a member function to display the two member data. #include using namespace std; template class display { private: mytype1 a; mytype2 b; public: display(mytype1 x, mytype2 y) { a=x; b=y; } void show( ) { cout< ob1(12,'d'); display ob2(20,12.123); ob1.show( ); ob2.show( ); return 0; }

Advanced C++ - IV

479

The output is: The values are : 12 , d The values are : 20 , 12.123 The above program shouldn’t pose much difficulty for understanding. You might be wondering as to where class templates might be really useful? Consider the problem we have with arrays in C++. When you create an array of a fixed size and in your program if you exceed the limit of the array, the compiler will not issue any error message. Instead it will continue and your results will be ambiguous. The problem is that there is no array boundary checking in C++ as there is in some other languages (like MATLAB – in MATLAB the compiler will never let you exceed the boundary limits and will produce an error message saying so). Thus, in C++ you can make your own generic array class and overload the [ ] operator such that it will check to see whether the index number specified lies within the size of the array. Else it should display an error message and terminate the program. Try it out.

Advanced C++ - IV

480

Advanced C++ - Part V The following topics are covered in this section: • •

Casting An intro to STL

Casting Casting basically means forcing something into something different. For instance if you have an integer division, you can change (or rather force) it into a floating type division through casting. The general form of cast is: (new type) expression; Casting might also be referred to as typecasting (because we are casting between data types). The following example should make the concept clear: int main( ) { int i=5; cout<
Advanced C++ - V

481

Otherwise using the C type of casting a programmer can indiscriminately cast and it could lead to unexpected results or errors. The general syntax for using these casting operators is as below: operator_cast (expression/variable) where operator_cast is replaced by one of the 4 casting operators.

dynamic_cast: This is used to cast a base class pointer/reference to a derived class pointer/reference and vice-versa. It is dynamic because it will determine at runtime whether a base class pointer refers to an object of the base class or whether it points to an object of a derived class (this is known as downcasting-going from base to derived). The opposite is known as upcasting. In upcasting, we can cast a pointer of a derived class to a pointer of base class (we go from derived to base). This will work only on polymorphic classes (polymorphism means that at least one of your base class functions should be a virtual function). This operator will check at runtime to make sure that the casting was properly carried out. Suppose you are casting a pointer and if the casting is unsuccessful (i.e. it wasn’t cast to the requested type), then the value returned will be NULL. If you are using references and if the casting fails, then a bad_cast exception will be thrown. This must be confusing you so let’s take up an example. class car { public: virtual void disp( ) {} }; class ferrari : public car { }; int main( ) { car *cp1, *cp2; ferrari *fp; cp1 = new ferrari; cp2 = new car; fp = dynamic_cast(cp1); // successful if (fp) { cout<<"successful cast-base points to derived object";

Advanced C++ - V

482

} else { cout<<"casting failed"; } fp = dynamic_cast(cp2); // will fail fp value is NULL if (fp) { cout<<"successful casting"; } else { cout<<"casting failed-base points to base object"; } return 0; } The output is: successful cast-base points to derived object casting failed-base points to base object Take note of the following points (regarding cp1, cp2 and dynamic_cast): 1.) The casting will be successful if the base class pointer points to a derived object type. ‘cp1’ points to an object of type ‘ferrari’. Hence, fp = dynamic_cast(cp1); will be successful. 2.) The casting will fail if the base class pointer points to a base class object. ‘cp2’ points to an object of type ‘car’ (which is the base class). Hence, fp = dynamic_cast(cp2); will fail. 3.) You base class should be polymorphic (it should contain a virtual function). Otherwise you’ll get an error while using dynamic_cast.

Advanced C++ - V

483

static_cast: This is similar to the C type of casting discussed earlier. The syntax is: static_cast (expression/variable) A simple program is written below: int main( ) { int i=5; cout<(i)/2; return 0; } Basically we are casting ‘i' into a floating type. The expression i/2 will be equal to dividing a floating value by 2. Beware: What would happen if we write it as: cout<(i/2); Do you think there will be any change in output? Well, in fact the output will now be 2 and not 2.5. The reason is because the compiler would already have divided i/2, the result would be 2 (because of integer division) and the value of 2 will be forced into floating type (which makes no difference because you have already lost the decimal place). So be very careful while casting. Static_cast performs no run-time check. This cast operator is not used only for standard data types; it can be used for casting pointers to classes.

Advanced C++ - V

484

reinterpret_cast: The reinterpret_cast can be used to convert between two totally different types. It is used in situations where none of the other operators can be used. It can cast pointers of one type into another type or it can also convert from pointer to integer and vice-versa. Since you can cast pointer from one type into another type, using reinterpret_cast we can cast from between two pointers pointing to totally unrelated classes. class bacteria { public: void disp( ) { cout<<"\nThis is bacteria"; } }; class car { }; int main( ) { bacteria *bp; car *cp; car mine; cp=&mine; reinterpret_cast(cp)->disp( ); return 0; } The output is: This is bacteria Just go back to this line in the program: reinterpret_cast(cp)->disp( ); ‘cp’ is actually a pointer to the class ‘car’. Here we have forced this pointer to point to the class bacteria and using this pointer we call the bacteria member function disp ( ). The output illustrates that the casting was successful.

Advanced C++ - V

485

const_cast: None of the other 3 casting operators that we’ve seen can get rid of the constant-ness of an object. For example: we discussed about constant objects and these objects can access only constant functions. Constant functions cannot modify member data (unless the data is mutable). Using the const_cast operator we can get rid of the constant-ness of the object; thus permitting it to modify member values. Constant objects are usually not supposed to change member data values but sometimes there are member data which are hidden from the user (but necessessary for all objects-irrespective of whether the object is a constant object or not). In such cases, there has to be a mechanism to modify the data (even by constant objects). One way is to use the ‘mutable’ method and the other method is to use the const_cast operator. #include using namespace std; class bacteria { private: int life; public: bacteria( ) { life=0; } void set( ) const { cout<<"The original bacteria life is : "<(this)->life=1; cout<
Advanced C++ - V

486

An introduction to STL (Standard Template Library) This section will give you a brief introduction into STL. We learnt about templates earlier and the STL provides us with general-purpose template classes and functions to implement some common data structures and algorithms. The major types are stacks, queues, lists and vectors. As you know, templates can be used for any type of data and the STL is a generic library. It not only defines the general structure but also provides with some useful functions that can be used to operate on them. The three main aspects of STL are: • • •

Container classes Algorithms Iterators

Container Classes: These are classes that will contain/hold other objects. The various containers available are stacks, deque (double ended queue), lists, vectors, maps etc. I’ll just give you an idea as to what these containers generally mean. Stacks: This is a way to store data such that whatever data you put in first can be taken out last. In other words, just imagine that you are piling up books one on top of the other. This forms a stack of books. The book that you kept at the bottom was the first book that you kept. The book that was kept at last will be right on top of the stack When you want to retrieve the books, the topmost book will be the first to be retrieved (hence what went in last will come out first). This is known as the last-in-first-out (LIFO) principle. Queues: This is similar to our real life queues. The first person who enters will be the first person to leave the queue. The principle here is first-in-first-out (FIFO). Now the container classes will contain functions to operate on them. In the case of the stack you will usually come across the terms ‘push’ and ‘pop’. If you add a new item to the stack, you are said to ‘push’ into the stack. When you retrieve a data from the stack you are said to ‘pop’ from the stack. Thus these operations are modeled into functions. Algorithms: Algorithm basically means how you are going to operate on a container class. For instance, there are algorithms for sorting values in a container (sorting in ascending order), there are algorithms to reverse the order of elements present in a container and so on. Algorithms will operate on the containers.

Standard Template Library

487

Iterators: Iterators are similar to pointers. They can be used to access particular elements of a container. The relation between iterator and container is similar to the relation between pointer and array. Either you can access a particular element of the container or you can go through all the elements. There are different types of basic iterators: Forward iterator – this will move in a forward direction from one element to the next. It can be used for storing as well as retrieving values. Random Access – This is used to access elements randomly. Bidirectional – This is similar to the forward iterator except that this can move in both directions. Let’s take a look at a simple program to illustrate vectors (and STL in general). Vectors: Vector container is similar to the C++ array type. It can hold objects of the same data type. Vector container permits random accessing and it is dynamic (i.e. it can keep increasing in size as and when needed). The vector will allocate the required memory space whenever the vector grows in size. #include #include using namespace std; int main( ) { vector vec; //creating an object of vector vec.push_back(1); //push_back will put a value into the vector vec.push_back(2); vec.push_back(3); vec.push_back(4); cout<<"Size of the vector : "<
Standard Template Library

488

The output is: Size of the vector : 4 The elements are: 1 2 3 4 Size of the vector after erasing: 2 The elements are : 1 4 Size of the vector after clearing: 0 The various functions that have been used in the program will be explained (the various function syntaxes will not be dealt with since this program is to give you a feel of STL). vec.size( ); This will return the size of the vector (how many elements are contained in the vector). vec.clear( ); The clear ( ) function will delete all the value present in the vector object. Thus the size after clearing is 0. You would have noticed that we can access the vector elements by using index numbers (just like we do for arrays): vec[0]; Another function that has been used is the erase function: vec.erase(vec.begin( )+1,vec.end( )-1); This function is used to selectively delete particular values from your vector object. Deleting doesn’t simply delete the values, but it also reorders the vector. In the above example the vector initially had 4 values: 1234 Using the erase function we asked the compiler to delete the values from the second element to the second last element (which means that 2 and 3 have to be deleted). The compiler will delete 2 and 3 and then it will put the value 4 in the second position of the vector. Hence the vector now contains: 14 and the size of the vector is now 2. Some of the functions like size ( ) and push_back ( ) are available to the other container classes as well. This section was intended to just give you an idea about STL.

Standard Template Library

489

Question and Answers Time This chapter is meant to answer some of the questions that were not discussed in the earlier. Q.) What is a process? Every instance of a program is called a process. Suppose in Windows we open “Notepad” ten times, then we’ll have ten Notepad windows on our screen. There is only one Notepad executable file in the system but we’ve invoked this executable ten times (we have ten instances). Each instance is called a process.

• In some operating systems, many processes can run at a time (like Windows). Actually it appears to us as if many processes are running simultaneously. The operating system will allocate a small time slot to each process and keep switching from one to the other rapidly (it is so fast that we don’t notice this switching).

• In other operating systems like DOS, only one process is executed at a time (i.e. a process can be started only after the current one has completed execution). Processes are also called ‘tasks’.

Q.) What is an OS? OS (Operating System) is the software which acts as an interface between application programs (programs we write) and the hardware. It the OS which will execute our programs; in other words, our programs aren’t fed directly to the microprocessor. The OS takes care of this. There are many reasons why an OS is needed as an intermediary.

• If 10 processes are running then all these processes will compete for memory. Someone needs to ensure that memory is allocated properly to each of these processes. • All the running processes will want to use the CPU for themselves. • Each program running would require input-output services and there needs to be someone to synchronize this efficiently.

• When many processes are running, every process should get some timeslot where it can use the resources (otherwise one process could hijack the processor and prevent all other processes from running).

• Some processes might need to be assigned higher priority. • One process shouldn’t be able to manipulate the data of another process. These are some of the functions that an OS does (scheduling, memory management, setting priorities, I/O management etc).

FAQ

490 Q.) More info on linkers and loaders? To execute a program, the processor needs the executable machine code to lie in main memory (RAM). Whereas when we create an executable file we create this on our hard-disk (secondary storage) which cannot be directly accessed by the CPU. Someone needs to copy or load the program into main memory for execution and this job is performed by the loader. When a code is compiled, or when a code is assembled, the equivalent object code produced assumes that the program will be placed at memory location 0 (zero) of main memory (because the linker can’t predict beforehand where the OS will place the program in memory). But the OS won’t load programs at memory location 0. And even if it did load the program at location 0 we would still have problems. If we have 10 programs, and we want to run all 10 programs at the same time, obviously all 10 programs cannot occupy memory location 0! Which brings out another important point: not only don’t we know at which location a program will begin but we also don’t have the entire main memory available for use. If our PC were designed such that at a time only 1 program can run, then it is fair to assume that the program which is running will have the entire main memory to itself. But this isn’t the case; in fact the OS itself needs to occupy some part of main memory. So no program would be able to occupy the main memory completely. Absolute loader: One method to solve this problem is to use some memory address other than 0 at the time of linking. For example the linker could decide to use 1500 as the starting memory address (or some provision could be provided such that the programmer can specify a starting address in the program itself). The loader would now simply attempt to place the program at main memory location 1500. If that memory location is currently occupied then it’ll have to try again later. This is an absolute loader. It just takes the code and loads it into main memory. Relocating Loader: Let’s go back to the initial problem: all programs can end up anywhere in main memory. But since they are created with the assumption of starting at location 0, there needs to be someone who will change the starting value; or in other words someone needs to offset the entire program from memory location 0 by some fixed amount. This is known as relocation. Let’s take an example: You may wonder why we need to worry so much about this but it helps to understand how things work in the background. In a high-level language, we would say:

FAQ

491 int x = 1; x = x + 5; The compiler, when converting to object code would write something like this: 1. Allocate a memory address for the variable x (say location 1500). 2. Move 1 to location 1500. 3. Add 5 to the value stored at location 1500 and store the result in location 1500. If you note, everything is written in terms of a memory address (in fact we’ve ended up with just memory locations and constants). It is quite possible that the memory location for data (variables) is allocated just after the code.

Memory used for storing the code Memory allocated for variables

We could customize the diagram as:

int x = 1; x = x + 5; Memory space for ‘x’

Let’s assume that each of the instructions occupies 5 bytes. Thus:

Position in memory (in terms of bytes) 0

6

10

Instruction

Move 1 to location allotted for x (location 10) Add 5 to the value stored at location allotted for x and store the result in the same location (location 10). Memory allotted for variable ‘x’.

Since the compiler will create code assuming that the starting address is location 0, the first instruction is placed at byte 0. Memory for ‘x’ is byte number 10 onwards. Let’s assume that this is the executable file (which has been created by the linker). The OS wouldn’t permit the program to start at memory location 0 (that location might be reserved for

FAQ

492 something else). Thus now the program needs to start elsewhere. To start somewhere else, we’ll need to offset all memory locations in the program. Let’s say that the memory location from 8000 onwards is vacant. The loader will now offset the entire program by 8000 and then load the program into main memory. Thus our table will effectively become:

Position in memory (in terms of bytes) 8000

8006

8010

Instruction

Move 1 to location allotted for x (location 8010) Add 5 to the value stored at location allotted for x and store the result in the same location (location 8010). Memory allotted for variable ‘x’.

This kind of a loader is called a relocating loader; it relocates the code in main memory (the problem is that the loader has to check each instruction of the code and perform the required offsetting). Relocating using a hardware register: To reduce the burden of a relocating loader, we can use the CPUs internal registers for relocating. In our example the first program instruction should be: “Move 1 to location allotted for x (register value + 10)”. Similarly every instruction will depend on the value held in the register. So if the code has to be relocated to 8000, then the value 8000 needs to be placed in this base register. We’ve so far discussed how loaders work in simple operating systems (like the old version of MSDOS etc). Modern operating systems (like the latest version of Windows, Unix/Linux) make use of virtual memory (which involves activities like paging and segmentation). Discussing this topic is beyond the scope of this book (for reference you could use a book dealing with computer system architecture or a book on operating systems). In these systems, the loader will need to perform some more additional work in loading a program into main memory. To sum up: the loader is part of the operating system and it is responsible for loading an executable file into main memory. Our program is stored in the hard-disk (secondary storage) which is not directly accessible by the processor. A program can be executed only when it is loaded into main memory and the loader is responsible for this.

FAQ

493 Q.) What is system software and application software? A.) Software which acts as an interface to computer hardware is system software. Software used to develop applications is also system software. Example: Operating system, loaders, compilers etc. Software used for other purposes like text editors, music players etc. are called application software. Example: web browsers, calculator, word processors etc.

Q.) Is the hard-disk directly accessible by the CPU? A.) No. Secondary memory (which includes the hard disk; floppy disk; CD-ROM) cannot be accessed directly by the processor. The processor can only access main memory directly (i.e. main memory can be directly accessed because it is directly connected to the main memory via an address bus) whereas the processor is not connected to the hard disk directly. This is the reason why a program that has to be executed needs to be first loaded into main memory at the time of execution. The number of address lines in the processor determines the maximum amount of main memory which can be accessed by the processor. A CPU with 8 address lines can access up to 28 memory locations (or 256 bytes of main memory).

Q.) If secondary storage is not accessible then how does the processor access it? The illustration below would help understand the relation between the CPU, main memory and secondary storage.

FAQ

494 A bus is nothing but a group of wires; each wire can be used to transmit one bit and the system bus consists of address and data bus. As the name suggests, addresses are sent on the address bus and data is sent/received on the data bus. Processor and main (primary) memory: The processor and main memory are connected to the same bus. Let’s say the processor wants to access memory location 1500.

• It would say (through the control bus): “Send me the data at this memory location” • And it would pass the memory location 1500 on the address bus. • On receiving the control signal the main memory will respond by placing the data at 1500 onto the data bus. Then the processor can read the data from the data bus. All this is possible because the CPU and RAM are connected to the same system bus. Processor and hard disk: The problem is obvious; hard disk and CPU are not directly connected. An intermediary device called an I/O controller is in charge of the hard disk and it is this mediator who can be accessed by the CPU. There are many reasons why we use I/O controllers; if we didn’t have them then the CPU would need to worry about directly interacting with these devices (and each I/O device behaves and operates differently). Just like the operating system hides the low-level processor details from us, an I/O controller specific internal details of the I/O device from the CPU (isn’t it easier to program in C++ than in machine language!). The diagram also explains why the CPU can access the primary memory faster than secondary storage (primary memory is directly connected). Q.) Is a program divided into different regions? A.)

• · Text - the program code is present here • · Data - contains initialized global variables • · BSS - contains uninitialized global variables • · Heap - dynamically allocated memory is stored in the heap • · Stack - local variables are allocated on the stack

FAQ

495 Q.) If I were to make a declaration and definition as follows: int i=4; Now in which part of memory will the value of ‘i' be stored in? Will it be in the RAM?? And they say that when we use the ‘new’ operator, memory is taken from the ‘heap’…Is the heap made use of only when the ‘new’ operator is used or can a program make use of the heap in any other way? How does heap differ from stack? Or are they the same? And what is free-store? When you say memory, we always refer to the RAM. If you have done a course in microprocessor programming you will learn about it. The stack is basically part of the RAM and whenever the program has to branch elsewhere, it will store the return address in the stack. There are many other uses for the stack as well. Now when a parent process asks the operating system to create a child process, the OS allocates space for the child process's code, stack, and data (variables, whose values are given in the program itself). These regions are just memory blocks. The orders in which these blocks exist and the amount of memory purely depends on the OS implementation. Hence a programmer should not be bothered about it. The 'stack' is used to allocate temporary variables. All local variables are temporary variables. All global variables are allocated in the 'data' region. So where did this term 'heap' come from? Heap is a region of memory which is used by 'malloc' (this is an operator similar to ‘new’ and was used in C) and 'new' to allocate memory. When the OS allocates memory, it usually doesn’t do so in a count of bytes. Usually the OS allocates memory to a process in terms of 4KB. Hence when a process needs 100 bytes, the OS gives it 4KB. The 'malloc' and 'new', consider this as the 'heap'. They allocate memory from the 'heap'. When the heap gets over, again the OS is requested for more memory. All this happens transparently; so it is hard to see it before your eyes. Actually this term 'heap' is kind of getting wiped away. It got introduced in MSDOS where the 'heap' referred to all the memory from the last block allocated to a process to the end of memory. This was so because, MSDOS was not a multitasking OS and it didn’t have any protection from user processes. So that was some background information. Coming back to the question, int i = 4; If the above declaration was done locally (i.e. within a function), then the allocation is done on the stack. If it is done globally it is in the 'data' section. There is another section called 'bss' which is the un-initialized data, which is similar to 'data'. There is one more point to note. Sometimes we have a region of memory called as ‘free store’. Sometimes this would be the same as the ‘heap’ but sometimes it could be different. If they are different then there are certain things you have to note. When you use the C++ dynamic memory operators (new and delete), these will operate on the free store. When you use the C operators (malloc and free) they will operate on the ‘heap’. What you have to take care of is not to mix up ‘new’ with ‘free’ and ‘malloc’ with ‘delete’. Suppose the ‘heap’ and ‘free store’ are different, then you

FAQ

496 will be allocating space in one region and freeing up memory elsewhere. So always use ‘new’ along with ‘delete’ and ‘malloc’ along with ‘free’. One more important thing; C Standards doesn’t document what I've explained to above. Though this is the convention that is generally followed by most of the C/C++ compilers, a programmer should never wonder where in memory his variable is living. Rather he should think, “what is the scope of a variable?”. That is better programming practice. Usage of global variables should be only after thorough review of the problem.

Q.) Executable formats, what are they and are there many formats? Just as we have different operating systems, we have different executable formats. What does a format mean? An executable file is not directed at the microprocessor but rather at the operating system. Remember that the operating system is the one which acts as an interface between our program and the hardware. So the OS expects its input to be in a specific format. Each OS expects an executable file to be in a specific format. In DOS it’s the exe format, in Windows the PE (portable executable) format, in Linux/Unix the ELF (executable and loadable file format) or the a.out format (which was the initial format in Unix). Why bother about this? Actually we don’t need to bother about them but it is one reason why a DOS executable file won’t run on Linux. Linux expects the executable format to be in a structure different from that of DOS.

Q.) Who decides on the size of the stack? This is again operating system dependent. Every operating system has a specific executable file format. Like in MSDOS you have EXE file format. The old executable format of Linux was 'a.out'. Now the native format is ELF for most of the Unixes. So at the time of compilation, the compiler computes the amount of stack you'd need and it puts in the respective fields of these executable files. Mind you, these executable files are not fully executable. They have a header part, which says where the 'code' section is, where the 'data' section is, how much stack is needed, how much memory to allocate, what are the regions that need not be loaded into memory and so on. As a rule, a C/C++ programmer when writing for a Standard implementation should not be bothered about setting the stack and such. These were an issue only in MSDOS. But still some compilers provide you non-standard features to control the size of the stack. Like the variable 'extern int _staklen' in Turbo C/C++. Supposing you set _staklen = 0x1000; then the compiler after compilation, when generating the EXE file, will write in the EXE header that you need a stack of '_staklen' bytes. When you execute the executable, the OS will read this

FAQ

497 header first to load your program. It'll see how much space you need and will allocate it. Then it'll load the respective sections of your program into the respective regions of memory. So, usually it is better not to bother about changing stack settings. Q.) Can I call a function from within a function? The main ( ) function does call other functions. Similarly you can call other functions also from within a function. See the example below: #include using namespace std; void sum(int a, int b) { cout<>x>>y; sum(x,y); } int main( ) { input( ); return 0; } The code will compile and run properly. You will get errors if you try to define a function within another function. The compiler will say that local function definitions are illegal. For instance in the above program you cannot define the function input ( ) within the main ( ) function.

Q.) Assume that I am declaring a constant using #define (say something like PI). Does the #define act like a function? Will the #define take up memory space itself? No, the #define's will not occupy any space in memory. They are preprocessor directives. i.e they are processed before compilation. When you compile a program, there are different stages; the first

FAQ

498 one is pre-processing where directives such as these can be expanded. So these are decided at compile time and not at run time. Check out the following code: #define X 100 int main( ) { const int mark = 20; int y,z; y = X; z = X + mark; return 0; } In the above code, at the time of compilation all occurrences of 'X' will simply be replaced by '100'. But on the other hand when I define 'const int mark', it means that 'mark' is a variable whose value won’t change. So the compiler allocates some memory for the 'const int'. After preprocessing the code would look as below: int main( ) { const int mark = 20; int y,z; y = 100; z = 100 + mark; return 0; }

Q.) What is a library? Is it a collection of header files? A library file contains functions, which can be called from your code. The header files usually contain only the function declarations (function header) while their implementation is present in the library files. Just have a look at stdio.h or conio.h.; they contain tons of functions but their internal coding (function definition) will not be present. The actual functions exist in the library, which is precompiled but not linked. All functions like printf, scanf, gets, puts, etc. are present in the library. We call them in our programs but we can’t include the library just like that. We have to link our file with the library. If you are using Turbo C++, the compiler automatically does this for you (it might be a file called CS.LIB). But you can also do this manually. In some compilers we will have an option in Project Settings to mention the library files that want to link.

FAQ

499

Q.) Where should the ‘const’ keyword be placed? const int i=5; int const j=4; Which one is correct? Both are acceptable. You can place the ‘const’ keyword before the data type or after the data type. But be careful about placing the ‘const’ keyword when you are using pointers. int x,y; int *const p1=&x; //constant pointer int const *p2; //not a constant pointer x=y=5; p2=&y; *p2=6; //Not allowed - we cannot modify the value at p2. p2=&x; //Allowed because p2 is not made a constant pointer The placement of the ‘const’ keyword will determine whether the pointer is a constant pointer or not.

Q.) I get the following errors when attempting to compile my program (‘Time’ is a class that has private members called ‘hours’ and ‘minutes’): 'hours' cannot access private member declared in Class 'Time' 'minutes' cannot access private member declared in Class 'Time' and, 'operator << is ambiguous' These errors point to the line "ostream & operator<<(ostream & os, const Time & t)" in my source code. The << operator has been overloaded using friend functions. Why can’t a friend function access the private members of the class? I am currently using Microsoft Visual C++. A.) If you use some other compiler (other than VC++) you won’t have this problem. Actually this is a bug in Microsoft VC++ version 6.0. They have released a service pack to rectify this problem.

FAQ

500 The problem (the bug) is because of ‘using namespace std;’ If you avoid this statement and use iostream.h you won’t have the problem. Another option is to define the overloaded operator << within your class itself (instead of defining it outside the class using the scope resolution operator). Check out the following website for details about the problem as well as an explanation about the bug and the service pack. http://support.microsoft.com/default.aspx?scid=kb;EN-US;q192539

Q.) What is name-mangling? All C++ compilers make use of name mangling. When the compiler reads through the source code and encounters a function name, it stores the details about the function in a table (called a symbol table). For example if we have a function: void sub (int, int); the compiler will store this function in its symbol table. But functions in C++ are name mangled, i.e. the function name stored by the compiler is not the same one as given by us. The compiler may store it as: sub_int_int Thus whenever the compiler encounters a function call to sub ( ) it will retrieve the appropriate definition for the function at compile-time. Name mangling permits C++ to implement function overloading. Let us say we have another function with the same name ‘sub’: void sub (double,double); The compiler will store this as sub_double_double Thus whenever there is a statement calling the function sub ( ), the compiler will check the data types of the arguments and call the correct function. C compilers do not implement name mangling and thus they do not support function-overloading. Different C++ compilers (supplied by different vendors) implement name mangling in a different way but the bottom-line is that all C++ compilers implement name mangling.

FAQ

501

Linked List 1 Introduction: Data structure refers to the way we arrange data or the way in which data is stored in memory. There are different types of data structures. Array is a simple data structure that we have already seen. We come across data structures in everyday life as well. When we go shopping, it is common practice to prepare a shopping list. Might be something like below: Noodles

- 2 packets

Tomatoes

- 1 kg

Cornflakes

-1

Chocolate Bread A data structure is simply a way of organizing data and we have organized data in our shopping list as well. From what we’ve learnt so far we would categorize this as an array perhaps. The information isn’t sorted and we simply keep increasing the list when we think of more things to buy. But the problem with arrays is that they are fixed. You can’t keep on increasing their size as and when you feel like it. So we have a better data structure called a vector to serve this purpose. Similarly, we witness queues everyday (either while shopping, booking tickets, waiting in the canteen etc.). A queue is based on the principle of first come first serve. A queue is another data structure. When writing applications depending on the requirement we would need to use an appropriate data structure to organize information. In this chapter we’ll take a look at some common data structures.

Introduction: What is a linked list? If you have read books on memory then you would have come across a concept similar to linked lists. All these books usually explain one method for remembering the names of random objects in order. For example, your friend might read out the following list to you just once: Sheep, carpet, bottle, cigar, tent

Data Structures

502 and throw a challenge. The challenge is that after a few minutes you should be able to recollect the five names in the same order. Not a big deal, right? Try it with 20 and you’ll realize the difficulty. Memory experts suggest that we associate each object with the next one in the list; or in other words create a link between every neighbouring object. In our case we might say, “A sheep was born on a carpet, the carpet was rolled into a bottle, the bottle smoked a cigar, the cigar was resting in a tent!” The idea is to form comical associations between two objects since these associations are retained in our memory longer. The beauty of this technique is that if your friend names any object from the list, you will be able to say what is the next object in the list (irrespective of the object’s position in the list). The linked list data structure is very similar to this (except for the comical association!); and instead of object names, we call the elements of a linked list as nodes. A linked list consists of a series of nodes with each node pointing to the next node in sequence. A node has 2 parts: • •

Data Address of the next node

Some points to note about linked lists: • • • • • •

In terms of coding, linked lists are more complex than arrays. It is easy to increase or decrease the size of a linked list (i.e. you can easily manipulate the size of a linked list). In the case of an array this is a problem. New nodes in a linked list are created as and when required. Insertion of new elements (or nodes) is easier. In an array it is quite difficult to insert an element in the middle of the array. Deletion of a node is easy since only the address part of the previous node needs to be changed. Every node contains data and also has an address that points to the next node (this part is basically a pointer).

Diagrammatic representation of a linked list:

To distinguish the last node of the linked list from the other nodes, the last node will point to NULL (address 0). The very first node is called the 'head'. It doesn't have a data part and only points to the next node (basically the 'head' indicates the starting position of the linked list).

Data Structures

503

Creating a linked list: To aid in the understanding of the linked list concept, let's write a little program which will simulate a linked list. The program should do the following: • • • • •

Store a set of integers. It should be possible to delete a particular element. Permit insertion of a new node (element). Deletion of a particular node. A way to display the entire contents of the list.

Let's do this program the OOPs way. First of all we need to have an idea about how we are going to represent a single node of the linked list. The simplest way is to use a structure for a node. struct node { int data; node *next; }; 'data' is used to hold the data. In this case we are creating a linked list to store only integers (so 'data' is of type int). Every node contains a pointer to the next node. For this we create a pointer pointing to an object of type 'node'. Thus the pointer 'next' will contain the address of the next node. So, we now have a way to represent a node in our linked list. Let's now model a class to simulate the Linked list itself. //A class to simulate a Linked List class list { private: struct node { int data; node *next; }; node *head; public: list ( ) { head=NULL; } void addnode (int); void display( ); };

//to represent the 'head' of the linked list

//initially the linked list is empty; initialize head to NULL

'head' is used to store the starting location of the linked list (we need the starting point of the linked list). When you create an object of type 'list', your new linked list will be empty (which means that 'head' should point to a NULL location since there are no nodes in the linked list).

Data Structures

504 This is why we make use of the constructor to initialize the 'head' value to NULL. The last node is also called the 'tail'.

Adding a new node to the linked list: First let's see how to add a new node to our linked list. The following steps are involved in adding a new node: • •

If the 'head' has a value of NULL it means that the node we are going to add is the first node. If 'head' is not NULL, then identify the last node of the linked list and add the node at the end.

void list::addnode ( int num ) { node *newnode, *pointer; newnode = new node; newnode->data = num; newnode->next = NULL;

//creating a new node //assigning the data to the new node //the new node will be the last node, so point to NULL

if (head = = NULL) { head = newnode; //'head' now contains the pointer to point to the newly added node } else { pointer = head; //initialize pointer to the 'head' while (pointer->next != NULL) //move from one node to the next till we reach the tail { pointer = pointer->next; } pointer->next=newnode; //make the last node point to the new node } } The logic might initially seem confusing. The addnode( ) function is called with an integer argument (this integer is the data that we want to store in the new node). We create a new node saying: node *newnode; newnode = new node; 'newnode' is a pointer which points to the structure 'node'. Thus you can access 'data' and 'next' using this pointer (by using the arrow operator). Next we set the elements of the newly created node. newnode->data = num; newnode->next = NULL;

Data Structures

//assigning the data to the new node //the new node will be the last node, so point to NULL

505 Supposing the linked list is empty, then the 'head' value will be NULL. Thus there is no need to scan the list and locate the last node. So, if (head = = NULL) { head = newnode; added node }

//'head' now contains the pointer to point to the newly

'head' will now point to the first node of the linked list. In case we want to add more nodes then we need to find out the last node of the list (the last node will be the one which points to NULL). Once we identify this node, all we have to do is assign the address of the newly created node to the 'next' value of the last node. else { pointer = head; while (pointer->next != NULL) tail { pointer = pointer->next; } pointer->next=newnode; }

//initialize pointer to the 'head' //move from one node to the next till we reach the

//make the last node point to the new node

Displaying the contents of the linked list: This is relatively simple. All we need to do is traverse through the entire list (from the header to the tail) using a loop. Within the loop we can display the data stored in that node. void list::display( ) { node *pointer; pointer = head; while (pointer != NULL) { cout<data; pointer = pointer->next; } }

//start from the 'head'

The above code should be quite self-explanatory.

Data Structures

506

Whenever you use 'new' use a 'delete': After using your linked list you will want to destroy all the nodes (i.e. free all the memory allocated using the 'new' operator). For this purpose you could write the code for destroying the list in the destructor as shown below: ~list( ) { node *current,*temp; current = head; temp = current; while(current != NULL) { cout<next; delete current; current = temp; } }

The following section provides the complete program for a linked list.

Linked List (Part 2) The complete program will be as below (along with the output): //A class to simulate a Linked List #include using namespace std; class list { private: struct node { int data; node *next; }; node *head; public: list ( ) { head=NULL; } ~list( ) { node *current,*temp; current = head; temp = current;

Data Structures

//to represent the 'head' of the linked list

//initially the linked list is empty; initialize head to NULL

//Destructor

507 while(current != NULL) { cout<next; delete current; current = temp; } } void addnode (int); void display( ); }; //Function to add a new node to the end of the linked list void list::addnode ( int num ) { node *newnode, *pointer; newnode = new node; newnode->data = num; newnode->next = NULL;

//creating a new node //assigning the data to the new node //the new node will be the last node, so point to NULL

if (head = = NULL) { head = newnode; //'head' now contains the pointer to point to the newly added node } else { pointer = head; //initialize pointer to the 'head' while (pointer->next != NULL) //move from one node to the next till we reach the tail { pointer = pointer->next; } pointer->next=newnode; //make the last node point to the new node } } //Function to display the contents of the linked list void list::display( ) { node *pointer; pointer = head; while (pointer != NULL) { cout<data; pointer = pointer->next; } }

Data Structures

//start from the 'head'

508 int main( ) { list x; x.addnode(2); x.addnode(1); x.addnode(12); x.addnode(10); x.display( ); return 0; } The output will be: 2 1 12 10 destroying node destroying node destroying node destroying node

Assignments: There are some more things you can do to your linked list class. You can write an insert statement to insert a new node in a particular location. You can write a function to delete a node (while deleting you have to physically remove the node using the 'delete' operator and you have to change the address stored in the previous node). Create a template for a linked list (so that the linked list can be used to hold any type of data).

Singly linked lists: What we have discussed so far are called singly linked lists (because they contain the address of only the next node – i.e. they can be used to traverse the list in one direction alone). Doubly linked lists: These linked lists contain nodes having 2 pointers (one points to the next node and one points to the previous node). Thus you can traverse the linked list either forward or backwards. Circular linked list: In this type of linked list the last node (i.e. the ‘tail’) will point to the first node (instead of pointing to the NULL address).

Continue learning linked lists in the next topic: Linked Lists using STL

Data Structures

509

Linked List using STL The standard template library provides a container for lists (it is a doubly linked lists). There are many functions available and the following program shows a few of them: //A program to illustrate the STL container for linked lists #include #include using namespace std; int main( ) { list intlist; list::iterator ptr; int i; //checking whether the list is empty if (intlist.empty( )= =true) { cout<
Data Structures

510 cout< intlist; list::iterator ptr; Here we are creating a linked list named ‘intlist’ and we are also creating an iterator named ‘ptr’. An iterator is similar to a pointer and it is used to store addresses. intlist.empty( ) This functions returns a bool value (true or false) depending on whether the list is empty or not. intlist.push_back(i); push_back(data) is used to insert an element to the end of the list. There is also a pop_back ( ) function to remove the last element of the list. Or you can use the push_front (data) to insert data at the start of the list. ptr = intlist.begin( ) This function returns a reference to the first node of the linked list. In our program we have stored this value in the iterator ‘ptr’. The function intlist.end( ) is the converse of begin( ). intlist.unique( ); The unique( ) function removes any duplicate values occurring later on in the list. There are lots of in-built functions that you can try out on linked lists. This program was meant to give you an idea of how to use these functions.

Learn in the next section about Stacks. Data Structures

511

Stacks and STL Introduction: If you have understood the working concept of a linked list, understanding a stack shouldn’t be difficult. Stack is another kind of data structure in which we store data one on top of the other. An analogy in real life would be a stack of plates (i.e. a set of plates kept one on top of the other). The main feature in such an arrangement is that the last plate to be kept will be at the top of the stack. So, when you want to remove a plate from the arrangement, the last one will be removed first. This is termed as ‘last-in-first-out’. What goes last comes out first. Similarly you cannot add a plate in between the stack; you can only keep placing plates at the top. The advantage of this kind of arrangement is that you can ensure that everything flows in a proper order (you cannot randomly remove/insert elements in the middle of a stack). The two operations (of adding an element to a stack and removing an element) are called ‘pop’ and ‘push’. • •

Popping is the process of removing the topmost element from the stack. Pushing is the process of adding an element to the top of the stack.

Thus it follows that popping will reduce the size occupied by the stack while pushing will increase the size of the stack. There is a particular area of memory also which is called the ‘stack’. Whenever you create local variables in your functions, these variables get allocated memory in the stack. And this stack memory also follows the same principle of the stack. When variables are created they are pushed into the stack and when the function terminates, all the corresponding variables are popped out of the stack. This concept is used in recursion.

Implementation: A stack can be implemented using arrays (dynamically allocating the size of the array) or you can make use of linked lists. In fact if the linked list is slightly modified you will get a stack. You will have two functions to pop and push elements on to the stack. Just like we created our own linked list, you can create a stack implementation as well. This is left as an assignment for you to try out. The STL has a stack template class available in it. The basic two functions needed are pop ( ) and push ( ). There is another function empty ( ) to check whether the stack is empty. Below is a simple program to illustrate the STL stack.

Data Structures

512 //Program to illustrate the stack container of STL #include #include using namespace std; int main( ) { stack intstack; int i; //Adding 5 values to the stack (100 101 102 103 104) for( i=100; i<105; i++ ) { intstack.push(i); } //Displaying the size of the stack cout<
Data Structures

513 Notice in the output that 104 is the first element to be popped (it was the last element to be pushed into the stack). The member function size( ) is used to determine the size of the stack (i.e. the number of elements present in the stack). The function

top( )

can be used to retrieve the value of the last element pushed into the stack (i.e. you can find out the value of the element lying at the top of the stack). Beware: If you attempt to pop the stack after the stack has become empty, you will get runtime errors. Use the empty ( ) function to check whether the stack is empty or not.

Queues A queue is similar to a stack but it is based on the saying ‘First come first serve’. In a stack the principle is ‘last come first serve’. The concept is termed as FIFO (first-in first-out). Queues are just like queues in everyday life. The person who comes late has to stand at the end of the queue. Similar to a stack you cannot enter in between an existing queue (i.e. you cannot insert elements into a queue); you can only keep adding to the end (back) of the queue. The two operations (of adding an element to a queue and removing an element) are called ‘pop’ and ‘push’. The only difference between the pop and push of stacks is that the elements popped and pushed are different from that of the stack. • •

Popping is the process of removing the first element of the queue (i.e. the element which entered the queue first). Pushing is the process of adding an element to the back of the queue.

Diagrammatically a stack can be represented as shown below: Order in which elements enter

TOP

Order in which elements are serviced/removed

4 3 2 1

BOTTOM

0

Stack

Data Structures

514 FRONT

0 1

Order in which elements are serviced/removed

2 3 4

BACK

Order in which elements enter

Queue

The STL has a queue template class available. The functions available are similar to those available for a stack. The basic functions needed are pop( ) and push( ). There is another function empty( ) to check whether the stack is empty. Below is a simple program to illustrate the STL queue: //A program to illustrate the STL container for queues #include #include using namespace std; int main( ) { queue intqueue; int i; //adding 5 values to the queue (0 1 2 3 4) for(i = 0; i < 5 ; i++) { intqueue.push(i); } cout<
Data Structures

515 cout<
A closer look into STL We’ve already had an introduction about STL. Having learnt about data structures you will be in a better position to appreciate the use of STL. Data structures are used frequently by programmers for various applications. Every programmer could keep creating his own model of the data structure and use them in his application. But the idea of OOP is reuse. Since data structures are used frequently it was felt that creating a common standard would greatly benefit programmers. This led to the development of STL. The programmer can reuse the existing code and need not waste time in developing the data structures or algorithms (like sorting and searching). How STL was developed? An example might help you appreciate the concept behind development of STL. Let us suppose that we want to write 2 algorithms: one for sorting and one for searching. Let us say that we want to operate on two data types: integers and float. Sorting and searching is not applied to a single element. We will be needing a sequence of elements and let us restrict ourselves to arrays and linked lists.

Data Structures

516 Thus we are attempting to write programs to: • •

Sort Search

They have to work on 2 containers: • •

Arrays Linked List

The data types we will use are: • •

Integer Float

So, how many codes do you think we have to write? We’d have to write 2*2*2 (2 algorithms * 2 data structures * 2 data types = 8) sets of codes. The combinations would be: 1. 2. 3. 4.

Searching an array of integers Searching an array of float Searching a linked list of integers Searching a linked list of float

Similarly you’ll need to have 4 more codings for sorting. The problem with the above methodology is that our basic algorithm is going to be the same things. It’s only the data types and data structures that will vary. To reduce on this template functions were created. With template functions we could use the same function across any data type. Thus the data type factor was eliminated from the equation and the number of codings needed was reduced to 4 (2 algorithms * 2 data structures). The next logical step was to write code that could be used across different containers. This would mean that ultimately you only need to write an algorithm for each operation and needn’t worry about what data structure was used. This is the basis for STL. STL was developed by Stepanovs and Ming Lee and it has been drafted into the standard ANSI C++ standards. Hence all C++ compilers (the latest ones) will support STL. We have already dealt with the terms used in STL: containers, iterators and algorithms. We use pointers to access objects in C++. When using STL we use iterators instead of pointers. Containers are basically the data structures, a few of which we have already discussed. They are designed as template classes and can be used to hold any data type. Containers can be divided into different categories: 1. 2. 3. 4.

Sequence containers Associative containers Container Adapters Specialized/ Near containers

There are 3 types of sequence containers namely vectors, lists and deque. Algorithms are used to perform some operation on the elements held within these containers. These algorithms are implemented as functions and whenever you want to use them you will usually have to pass iterators to the function. For example by passing 2 iterators we can specify the elements on which we want the algorithm to act upon.

Data Structures

517 There are 5 types of iterators: 1. Input - used to read elements from a container. They can move in only the forward direction (i.e. from the first element to the last) and they can pass only once through the container. 2. Output - used to write elements to a container. They are similar to input iterators. 3. Forward - they are a combination of the input and output iterators. They can be used to pass multiple times through the container. 4. Bidirection - they have the properties of the forward iterator and they can be used to move in the backward direction also. 5. Random access - They have the properties of the bidirectional iterator and also permit random access of container elements. There is a hierarchy for the 5 types of iterators and the ones at the top of the hierarchy are considered ‘weaker’ than those at the bottom of the hierarchy. The lower levels in the hierarchy support all the functions that are performed by the ones above it (thus they are stronger than the ones above them). input

output

forward

bidirectional

random access Containers and iterators are related. Every type of container will support particular types of iterators. Also each container has a set of member functions and some of these functions will return iterators. The following member functions are a few of the common functions available in almost all STL containers (including vectors). Function/operators

Use

bool empty( )

Returns true if container is empty.

size_type size( )

Returns the number of elements present in the container.

void clear( )

Clears the contents of the container.

const_pointer/pointer begin( )

Returns reference to the first element of the container.

Data Structures

518 const_pointer/pointer end( )

Returns a reference to the end of the container.

reverse_iterator rbegin( )

Returns a reverse iterator.

reverse_iterator rend( )

Returns a reverse iterator.

erase( )

Used to erase a particular element or a range of elements (needs to be passed iterator arguments).

Overloaded operators = =,<,<=,>,>=

All return a Boolean value depending on the result of comparison.

Overloaded assignment operator =

Used to assign one container to another.

Note: Italics denote the return data type of the functions. We’ll use some of the overloaded operators in programs to illustrate their working. Some of the return data type might appear to be new. These are actually typedef’s which have already been defined. Some typical typedefs you might encounter in STL are: Typedef

Description

size_type

Data type used to count the number of elements in a container.

const_iterator

An iterator that can be used to only read elements of a container.

reverse_iterator

This is used to pass through a container in the reverse order (from the last element to the first).

const_reverse_iterator

A constant reverse iterator used for reading the elements of the container in reverse order.

Next we’ll take a look at each of the container types in a little more detail.

Learn about Sequence Containers (Vectors)

Data Structures

519

Sequence Containers As the name implies, these containers will have elements arranged in a linear manner. There are 3 types of sequence containers: • • •

Vectors Deque List

There are many functions which are common to all sequence containers while a few are specific to some of them.

Vectors A vector is basically an array, which can grow dynamically in size as and when required. The programmer does not need to worry much about memory management since this is taken care of automatically. The following are some interesting points to note regarding vectors: •

•

• •

•

Though vectors can grow dynamically in size, they still need to occupy contiguous memory locations (just like arrays). So, suppose you increase the size of your vector from 4 elements to 5 and if there isn’t contiguous memory space available at the current location then the vector will be moved to some other memory location where contiguous space for all the elements are available (effectively it will copy the elements to the new location and then destroy the old one). This process brings to light one disadvantage of using vectors. Another problem is when you are inserting an element in the middle of a vector. In this case, all the elements that should follow the inserted element have to be shifted before the element can be inserted. Vectors are useful when random access to elements is needed. This can be done using subscripts (just like arrays). Vectors provide boundary checking also (something that isn’t available in arrays and which generally leads to a lot of errors in programs). Boundary checking means that you cannot attempt to reference a vector element outside the defined range (for example if your vector can hold 100 elements then you cannot attempt to access the 105th element. This was a problem in arrays since such checking is not available). Vectors are recommended if your program is going to add elements to the end of the vector and if random access is required. Function

Use

*front( )

Returns the value of the first element stored in the vector.

*back ( )

Returns the last element value stored in the vector.

*push_back( )

Pushing a new element (specified by the

Data Structures

520 argument) into the container *pop_back( )

Pops out the element at the end of the container (no arguments for this function).

*assign( )

Assign values to elements of the container

capacity( )

Returns the maximum elements that can be stored in the vector before automatic resizing

Note: * denotes that these functions are available in all sequence containers.

Capacity and Size of a vector: Vectors keep resizing automatically as they increase in size. Thus memory is allocated automatically when needed as demonstrated in the program below: #include #include using namespace std; int main( ) { vector intvector; intvector.push_back(1); cout<<"Size is:"<
Data Structures

521 The output is: Size is:1 Capacity : 1 Size is:2 Capacity : 2 Size is:3 Capacity : 4 Size is:4 Capacity : 4 Size is:5 Capacity : 8 Size is:6 Capacity : 8 Size denotes the amount of memory space currently being used by the vector and capacity denotes the amount of memory allocated for the vector (as more space is needed this will keep increasing). It can be observed Thus memory is allocated as follows: •

•

If the size of the vector is less than the capacity (i.e. the vector can still accommodate more elements without more memory being wanted) and if you insert an element, extra memory will not be allocated. If the size is equal to the capacity and if you insert an element then the capacity (i.e. the space occupied by the vector) will be doubled.

Using overloaded operators on STL containers: Let’s take a look at the overloaded operators which are available in all containers using a simple program. //illustrating the use of overloaded operators in STL vectors #include #include using namespace std; int main( ) { vector intvec1; vector intvec2; vector::const_iterator ptr; //declaring a constant iterator intvec1.push_back(10); intvec1.push_back(20); intvec2.push_back(20); if (intvec1
Data Structures

522 intvec1=intvec2; } cout<::const_iterator ptr; is used to declare a constant iterator which can be used to only read the elements of a container. When using the overloaded operators on containers, take note of the following points: •

The 2 containers being compared should be of the same type (i.e. if we have a vector containing integers then it can be compared or assigned to another vector of type integer).

•

The relational operators work on an element by element comparison. In the above program: VECTOR 1

10

VECTOR 2

20

20

Even though the size of vector 1 is more than vector 2, the first element of vector 2 is greater than that of vector 1 (20 > 10).

Go to the next section on Subscripts and Vectors

Data Structures

523

Subscripts and Vectors Subscripts in Vectors: You can use the subscripts just like in arrays. The following is the method for using subscripts: vector intvec1; intvec1.push_back(10); intvec1.push_back(20); intvec1[0] = intvec1[1] + 5; After executing this piece of code, the vector intvec1 will contain 2 elements with the values 25 and 20. Using subscripts in vectors helps in random access of the elements.

Boundary Checking in Vectors: When you use subscripts to access vector elements boundary-checking is not performed. For example the following code fragment will cause a run-time error: vector intvec1; vector::const_iterator ptr; //declaring a constant iterator intvec1.push_back(10); intvec1.push_back(20); intvec1[2]=30; //element does not exist cout<
Data Structures

524 Now when the program is run, an exception will be thrown and this can be caught to prevent crashing. A simple program is illustrated below: //Demonstrating the use of 'at' in vectors #include #include #include using namespace std; int main( ) { vector intvec1; vector::const_iterator ptr;

//declaring a constant iterator

intvec1.push_back(10); intvec1.push_back(20); try { intvec1.at(2)=30; cout< subscript When this code: intvec1.at(2)=30;

Data Structures

525 is executed it will check the boundary limit of the vector. Since the vector currently has only 2 elements, it will throw an ‘out_of_range’ exception. By catching this you can prevent the program from crashing. In the above program ‘exc’ is an object of type out_of_range and it has a member function what( ). exc.what( ); This will give a short description about what caused the problem.

More functions for Vectors Using various functions available in Vectors: //A program using various vector functions #include #include using namespace std; //Function to display the contents of a vector void display(vector &vec) { vector::const_iterator ptr; for (ptr=vec.begin( ); ptr!=vec.end( ); ptr++) { cout<<" "<<*ptr; } } int main( ) { vector intvec1; int i; intvec1.assign(4,7); cout<
Data Structures

526 intvec1.erase(intvec1.begin()); cout<
Data Structures

527

STL Lists 1 We’ve already written a program that makes use of the STL list container. Let’s take a deeper look into the list container in this section. The STL list container is a doubly linked-list. Thus each node has the element as well as two pointers pointing to the next and previous node of the list. Lists are advantageous if there are going to be many insertions and removals from the middle of the list (since all you need to do is modify the pointers). Lists do not support random access. Thus the list container supports the bidirectional iterator (not the random access iterator which is supported by the vector container). Before going into an example program let’s take a look at the insert member function. The insert function is available in all the sequence containers and it has three forms: intlist.insert(intlist.begin( ), val); will insert the value ‘va’ at the beginning of the container. intlist.insert(intlist.begin( ), n, val); will insert the value ‘val’ n times at the beginning of the container. intlist.insert(intlist.begin( ), iterator/pointer, iterator/pointer); will insert the elements from the first pointer to the second pointer at the beginning of the container. Note: You needn’t always insert at the beginning of a container. The first argument for the function insert ( ) specifies the location where you want to insert the values. By changing this iterator you can insert at different positions.

Member functions for the List container: These two functions are available in the list and deque containers but not in the vector container: push_front( ) pop_front( ) The following functions are available only in the list container: splice( ) merge( ) unique( )

Data Structures

528 sort( ) reverse( ) remove( ) Note: The sort( ) function is available as an algorithm and also as a member function in a few containers. The algorithm sort form can be used across any container (but it requires a random access iterator). If the container you are using has a specific member function sort( ), then it is more efficient to use this function than the generic sort because member functions have been written knowing the internals of that particular container. The generic sort will not take advantage of the internal structure of the container since it has to work on all containers.

STL Lists 2 (program) //A program to illustrate the list functions #include #include using namespace std; //Function to display the contents of the list void display(list &list1) { list::const_iterator ptr; for (ptr=list1.begin();ptr!=list1.end();ptr++) { cout<<" "<<*ptr; } } int main( ) { list intlist1,intlist2; const int SIZE=4; int arr[SIZE]={5,8,4,2}; //adding 4 values to the list (1 2 3 4) for(int i=1;i<5;i++) { intlist1.push_back(i); }

Data Structures

529 intlist1.push_front(8); intlist1.push_back(1); intlist1.push_back(1); cout<
Data Structures

530 The output will be: List 1 : 8 1 2 3 4 1 1 List 1 after unique : 8 1 2 3 4 1 List 2 : 5 8 4 2 List 1 after splicing : 8 1 2 3 4 1 5 8 4 2 List 2 after splicing : List 1 after sorting : 1 1 2 2 3 4 4 5 8 8 List 2 after sorting : 2 4 5 8 List 1 after merging : 1 1 2 2 2 3 4 4 4 5 5 8 8 8 List 2 after merging : List 1 after unique : 1 2 3 4 5 8 List 1 (5 removed) : 1 2 3 4 8 List 1 after swapping : List 2 after swapping : 1 2 3 4 8 We’ll take a look at the function individually. intlist1.unique( ); As you can see from the output of the above program, this function is effective only when the values in the list are sorted (otherwise there is a good chance that the same value might still have duplicates in the list). intlist2.insert(intlist2.begin( ), arr, arr+SIZE); This is the 3rd form of the insert ( ) function which we discussed earlier. Here ‘arr’ is a pointer (pointer to the first element of the array ‘arr’). Adding SIZE gives the second pointer (which will point to the last element of ‘arr’). Thus the array ‘arr’ will be inserted before the beginning of the list intlist2. intlist1.splice(intlist1.end( ),intlist2); Splice will remove the elements of the second container and add them to the first container after the position referred to in the first argument. There are 2 more forms of the splice ( ) function available. void splice (iterator, 2nd list, iterator-to-element); This 3 argument form of splice will move a single element to the list container that called the splice function. void splice (iterator, 2nd list, iterator-to-1st element, iterator-to-2nd element); The 4-argument form of splice can be used to move a range of elements from the 2nd list. intlist1.sort( ); This is a member function sort ( ) which is specific for the list container. It takes advantage of the fact that when dealing with lists we don’t need to copy or move the objects (it is sufficient to change the linking pointers). This function arranges the elements in ascending order.

Data Structures

531 intlist1.merge(intlist2); The merger( ) function will remove elements from the 2nd list (i.e. the list specified as an argument) and insert them into the first list. For the merge( ) function to work properly both the lists should be sorted (the results otherwise will be ambiguous). intlist1.remove(5); The remove( ) function removes all occurrences of the specified element from the list. Beware: remove( ) will eliminate all occurrences of the element (not just the first occurrence but all). intlist1.swap(intlist2); The swap( ) function swaps the specified lists.

STL Deque The deque (short form for double-ended queue) is similar to a vector. It has random access capability using subscripts but does not have the limitation of needing contiguous memory. Memory for a deque is allocated in terms of many storage blocks. Deque is efficient in insertions and deletions at its front and back. Unlike a vector it has the member functions push_front( ) and pop_front( ). It does not have the capacity( ) and reserve( ) functions available in vectors. The reserve( ) function in vectors can be used to specify how many elements you will store in the vector (this will reduce the amount of reallocations in a vector). Generally a vector is advisable if you have an idea about the number of elements you will need to store. A deque is efficient in situations where you need to do frequent insertions and deletions at the front. There are no exclusive deque member functions. All of the member functions are available in other containers (unlike the list container which has exclusive functions).

Data Structures

532 Let’s take a look at a simple program to illustrate a deque. //Program to use the deque STL container #include #include using namespace std; void display(deque &deq) { deque::iterator ptr; for (ptr=deq.begin( );ptr!=deq.end( );ptr++) { cout<<" "<<*ptr; } } int main( ) { deque deqint; deque::reverse_iterator rptr; for (int i=1;i<5;i++) { deqint.push_front(i); } cout<
Data Structures

533 The functions are pretty much the same as we have seen earlier. We have used the reverse iterator to illustrate its working. Basically the reverse iterator can be used to pass through a container from the back to the front. rbegin( ) will position the iterator at the end of the container. Whenever the reverse iterator is incremented it will move towards the beginning.

Associative Containers Associative containers are effective in searching for elements based on keys. For example: You may want to obtain the name of an employee using his ID number. In this case, ID number is the key based on which you will search and retrieve the name. These containers will store the elements based on the value of the key (i.e. they may store the elements in ascending order of their keys). This is what permits efficient searching of associative containers. Since they depend on the key value, generally you cannot modify the value of the key itself. Associative containers can be divided into two types: • •

Simple associative Pair associative

Pair associative is the example we discussed about employee ID and employee name. In this case the part of the element which is the key (i.e. the ID number) cannot be modified but the other part (i.e. the employee name) can be changed. In simple associative containers we store the entire element as the key. Thus you cannot modify the elements of a simple associative container. Again within the simple and pair associative containers, we have two more sub divisions: • •

Unique key Multiple key

In the unique key type, the key cannot be repeated (i.e. no two elements can have the same key). In multiple key type, many elements can have the same key value. For example: in a college, each student will take up lots of courses. Thus the student ID number is the same but there will be many subjects under that ID. To permit quick retrieval of data, the elements are arranged in a tree structure (the binary tree structure aids in quick retrieval of data).

Data Structures

534 Some common functions available in all associative containers are listed below. Member function

Use

void erase ( )

3 forms available - Erases a particular element based on key value or based on a reference or a range of elements.

void clear( )

Erases all the elements of the container.

iterator find (x)

The value of the key to be searched is passed as argument.

size_type count(x)

Returns the number of elements with the key value ‘x’.

pair equal_range(x)

Returns a pair of iterators specifying the range of elements having the key value as x.

Note: italics denotes the return data type. Sorted associative containers contain some more member functions in common. The 4 containers we will discuss about are: • • • •

Set Multi-set Map Multi-map

All four are sorted containers.

Data Structures

535

Set Container Set is a simple, sorted, unique associative container. Attempting to insert a duplicate key will not lead to an error; it will simply be ignored by the container. If you are creating a word game in which you want to check whether a particular word exists in the list then you only need to store the words (i.e. you only need to keep track of the keys since you won’t be needing anything else). Whenever the user forms a word, all you need to do is use the find( ) member function to see if the word exists in the container. There are many algorithms which you can use on containers but we’ll be dealing with algorithms later on. Let’s check out an example program that uses the set container. //Program using the 'set' container #include #include #include using namespace std; int main( ) { typedef set > stringset; stringset strset1; stringset::const_iterator ptr; string a("test"); strset1.insert(a); strset1.insert(a); strset1.insert("testing"); strset1.insert("apple"); strset1.insert("sun"); cout<
Data Structures

536 The output will be: The container has the following words: apple sun test testing Found the word test Size of the container: 4 To make use of the set and multiset containers you need to include the header file. A typedef has been used to avoid retyping the entire set declaration again. typedef set > stringset; stringset strset1; The part set > says that we are declaring a set which will contain strings and is arranged in ascending order based on the string value. The data type of elements you use in the set container should support the < comparison operator. Hence if you are using a set container to hold your own user-defined data types, then you should have provided with an overloaded < operator function for that data type. The code: strset1.insert(a); strset1.insert(a); should insert the same string twice but as you can see in the output this string is stored only once in the container. Such an operation does not cause an error. The code: ptr = strset1.find("test"); if (ptr!=strset1.end( )) checks to see if the string "test" is present in the container. If it is found in the container then the find( ) function will return the iterator corresponding to the position where the element was found. If the element is not present in the container then find( ) will return a reference to end of the container (i.e. a reference to a position beyond the last element of the container). Remember: the end( ) function does not return an iterator to the last element; it returns an iterator past the last element. The rest of the program uses the normal member functions that we have already discussed. Do take note of the output of the program. As you can see, the words are stored in ascending order (irrespective of their order of insertion).

Data Structures

537

MultiSet Container The main difference between set and multiset is that in multiset we can use duplicate key values. In multiset containers, the member function equal_range( ) will have some use. Let’s see a program using multiset container. #include #include using namespace std; int main( ) { typedef multiset > intset; intset intset1; intset::const_iterator ptr; pair p; intset1.insert(9); intset1.insert(3); intset1.insert(9); intset1.insert(1); for (int i=0;i<3;i++) { intset1.insert(8); } cout<
Data Structures

538 The code: pair p; will create an object ‘p’ of belonging to the class ‘pair’. Pair objects will contain a pair of values. The reason we have to use a pair in this program is because the equal_range( ) member function will return a pair of iterators. The function is: pair-iterators equal_range(value) The following diagram illustrates the iterators that are returned by equal_range(8).

To access the two iterators separately you can use the dot operator. The two parts are referred to as .first and .second. Hence in our program since the pair object is named ‘p’, we can refer to these two iterators as p.first and p.second. Suppose you don’t want to get the pair of iterators and instead you just want one of them, you can use the member functions: const_iterator lower_bound(value) const_iterator upper_bound(value) to yield the same results. The function lower_bound( ) returns an iterator pointing to the first occurrence of the ‘value’ element and upper_bound( ) returns an iterator past the last occurrence of the element with ‘value’.

Go to the next section on: Container Map

Data Structures

539

Container Map In a map you can store the key along with a separate value (of course to make logical sense the key and value should be related). It is a pair associative container. For example: Every employee has an employee ID number as well as a name. The ID will form the key while the value will be the employee name. In a map we call the relationship between the key and the value as one-to-one relationship (i.e. every key has a corresponding single value). //Program using the 'map' container #include #include