Computer Hardware, Architecture and Distributed Computing

Summary

Overview

The memory that is allocated at the time of compilation of a program is called as static memory. The compiler allocates the memory for all the variables, arrays, and objects created by the programmer, hence the memory allocation is by default static in C++. One of the major limitations of the static memory allocation is that, the amount of memory required by the program must be exactly known at the time of compilation, to avoid over allocation or under allocation of the required space. However, in many cases the programmer might not know the exact amount of memory to be allocated for implementing the functionality. Hence, in the case of static memory allocation the programmer might overestimate the actual amount of memory required by the program at run time. Therefore, the programmer may end up allocating the memory which is much higher than the actual amount of memory required when the program runs. This will result into large wastage of storage space in the primary memory of the computer system. On the other hand, it is also possible that the programmer underestimates the amount of memory required by the program at run time, then the program may crash at run time because of lack of storage space allocated by the programmer in the primary memory, thereby resulting into an ‘out of memory’ error.

As an example to understand static memory allocation, let us create an array of size 3 by using the following statement:

float a[3];

As each floating point element requires 4 bytes in memory, compiler will allocate the memory for array a as 4 × 3 = 12 bytes. Recall that, we cannot create an array by indirectly specifying the size of array in terms of another variable. For instance, let us create a variable n initialized to a value 3 and then create an array a with the size of array specified in terms of n as follows:

int n=3;

float a[n]; /*ERROR: value of n is not known at the time of compilation*/

Logically, the statements float a[3]; and float a[n]; will have a same meaning because the value of variable n is initialized as 3.

Summary

Overview

Inheritance is a relationship between classes wherein one class is derived from another class. The derived class is called child class, and the class from which it is derived is called parent class. Inheritance is also called as parent–child relationship between classes such that child class gives a specialized implementation of parent class. Reusability of the code is the key principle of inheritance because the properties defined in the parent class are borrowed by the child class. Inheritance is one of the most important features of object oriented programming, wherein the classes are organized in a hierarchical form. The class at the top of hierarchy is called parent class, whereas the class at the bottom of the hierarchy is called child class. Advantage of inheritance is that the members (variables and functions) defined by the parent class are also made available into the child class. This saves the programmers efforts to redevelop logic in child class, which is already implemented in parent class. Along with the properties defined in parent class, the child class can also have additional properties of its own as shown in the Figure 14.1. Hence the parent class is also called Base class/Super class/Generalized class and the child class is also called Derived class/Sub class/Specialized class.

As seen from the Figure 14.1, the member1 and member2 are defined in the parent class, which are available by default, in the child class. Also, child class can define additional members such as member3 and member4. This means that if you create an object of parent class, it will contain only two members: member1 and member2; whereas, if you create an object of child class, it will contain four members: member1, member2, member3, and member4. Therefore, a parent class should define the common properties that are required by all the child classes, whereas each of child class should define the specialized properties applicable only for that child.

As an example, let's assume that we need to store data about students and professors in a particular institute in computer memory. The requirement is that for every person(a student or a professor)we need to store name, date of birth, and gender.

Summary

Overview

A program is a set of instructions, which are followed by the machine so as to generate a desired output. This means that writing a computer program is giving instructions to a processor, so as to delegate a particular job to the hardware of the computer system. Every instruction is a command given to the computer hardware to perform a specific job. Computer hardware is a digital system (collection of functional switches) and hence every instruction must be converted into the form of 0's and 1's (where a symbol 0 represents open switch and a symbol 1 represents closed switch). As an example, let us assume that we want the computer system to perform the addition of two numbers say 15 and 25. The instruction to perform addition of two numbers could be written in the machine language as shown below:

10000011 00001111 00011001

In this case, the first eight bits represent the code informing the hardware that the addition of the two numbers is to be performed. This is called as an opcode (operational code) of the instruction. Different instructions would have different opcodes and their purpose is to convey the meaning of the instruction to the internal hardware circuitry. In this case, we have assumed an arbitrary opcode of ADD instruction as 10000011. Different processors have different decoders and internal designs, hence the length and format of the opcode will certainly differ from processor to processor. Some processors have eight bit opcodes (e.g., intel 8085), some have 16 bit opcodes (e.g., intel 8086). Today's generation processors have 32 bit/64 bit opcodes or even 128 bit opcodes. We need not look into the hardware configurations and designs at this stage, but the key point to understand is that every instruction has an opcode and in this case, we just assume an arbitrary opcode of 8 bits as 10000011, which represents ADD operation. A different combination of 8 bits, say 11001010, may represent subtraction and so on. In theory, the variety of instructions any processor can offer is indirectly dependent on the length of its opcode. A processor with an opcode length of 8 bits can just offer 28 = 256 distinct instructions whereas a processor with an opcode length of 16 bits can offer 216 = 65536 distinct instructions.

Summary

Overview

C++ is an extension of C. This means that all the features of C are also available in C++. Furthermore, C++ has certain additional features of object-oriented programming, which makes it superior to the conventional C language. The details of object orientation and other features of C++ are covered in the later chapters of this text book.

In this chapter, we will study some fundamentals, which build the foundation to understand the advanced features of C and various object-oriented features supported by C++.

The First C/C++ Program

Recall from Chapter 1 that every C/C++ program has to be compiled and linked so as to convert the high-level language into the machine code. All the instructions written in the program are executed one-by-one by the processor in a sequence as they appear in the program file. Therefore, it is the job of the programmer to inform the processor about the exact starting point from which the execution of the program should begin. The main() function in C/C++ is used to represent the start and end points of the program execution. Hence, every program must have exactly one main() function, which is shown in Figure 2.1.

CPU will execute all the instructions where we write inside the body of the main()function in a sequence as they appear. The presence of empty round parenthesis after a special word main() informs the compiler that the function main() does not take any arguments. By default, every function in C/C++ is expected to return a value to the one who invokes the function. We can use a keyword void if we do not want to return any value to the calling function. The complete details of functions with arguments and return values are discussed in Chapter 7 of this text book and hence the details about ‘function arguments’ and ‘return types’ can be ignored at this point of time.

At this stage, we need to understand that a main() function is to be created using a template shown in Figure 2.1.

Summary

Overview

Creation and maintenance of the program becomes difficult when the lines of code in the program increase. As the size of the program increases, the code becomes more prone to errors and the debugging of the program becomes difficult. The line of code (LOC) is considered as one of the metrics to determine the logical complexity of the program in the software development life cycle. Any program is a sequence of instructions and there can be a situation where a subsequence needs to be repeatedly executed at different places in the program. Repeating the subsequence at each place will not only increase the LOC but also make the program bulky and hamper its readability, thereby making change management cumbersome. Imagine a situation wherein a certain operation (say performing addition) is repeatedly written in the program at 100 different places, and suddenly you realize that you need to perform subtractions instead of additions. Making this change is going to be difficult because you need to ensure that all the addition operations at 100 different places need to change to subtraction. And what if you miss one of them to change? Or what if you change something else by mistake in a rush to make these 100 changes? The problem is that there is a lot of duplication of code (redundancy of code), and hence making one change requires making multiple changes.

In C/C++, it is possible to split a large program into multiple independent pieces. Each independent piece is called a function or a method. A function can define a single operation or a sequence of operations. You can invoke a function whenever you need to execute the operations it defines. Hence, the idea is to define an operation only once within the function and invoke the same function at multiple places where you need to perform the operation. A function can have multiple inputs (called arguments) and generate a single output (called return value) as shown in Figure 7.1.

Summary

Overview

Structure is a template used to create a user-defined data type. This means that, as we create the variables of built-in data types, such as int, float, and double, we can now, also create the variables of user-defined data types, provided that the template for this data type are defined by creating a structure in the program. Structure is a way to combine the logically related data elements into a single unit. Each of the data elements defined inside the structure, are called the members of a structure. The members defined inside the structure can be of a same or different data types. Hence, a structure can be defined as a template which is created for storing heterogeneous values in physically adjacent memory locations.

What is a “user-defined” data type?

C/C++ has a built-in set of primitive data types like int, float, char, double etc, which we can be directly used in the program. We can create variables of built-in types and perform operations with the values stored in these variables. Along with using built-in data types, we can also create customized data types in a program. “User-defined data type” is a “customized” data type that the programmer can create as per the requirements to store data in computer memory.

Structures are used to create user-defined data types.

What is the need to create user-defined data types in the program?

Let us assume that you need to store data about the vehicles assembled in an automobile industry. The relevant information that you wish to maintain for each vehicle is “colour”, “no of seats”, “type of fuel” and “mileage” of the vehicle. As and when a new car is assembled you will need to create 4 different variables to store its information in computer memory. Instead, it would be easy if the programmer has an ability to create a variable of type Car using the statement,

Car c1;

where cl stores all the required information about the car in a real world. The variable cl can internally store the 4 attributes “colour”, “no of seats”, “type of fuel” and “mileage” of the vehicle.

Summary

A computer program is a set of instructions which is followed by a machine to generate the required output. The language in which a computer program is written is called a computer programming language. Several computer programming languages are in use in the IT industry today, for developing diverse software applications.

The study of C and C++ is considered an important step towards mastering computer programming fundamentals. Hence, C and C++ are included in the syllabus of any computer science course.

This textbook provides in-depth explanations of C and C++ programming languages along with the fundamentals of the object oriented programming paradigm.

About the Book

This book will be of use to anyone who is a beginner and aspires to learn the fundamentals of computer programming using C and C++. It has been primarily written for students of academic courses which include the study of C, C++ and object oriented programming paradigm. Simple and lucid language has been used to facilitate easy comprehension of complex topics.

Salient Features

• Example-driven approach illustrates application of theoretical concepts

• Theme of a conversation interspersed in the text, elucidate essential themes of the subject

• Each program includes necessary comments to explain the logic used to implement a particular functionality

• Several line diagrams and flow charts facilitate easy comprehension of theoretical concepts

• Student-friendly pedagogical features include:

Summary

Overview

Templates in C++ are used to facilitate generic programming by giving the programmer an ability to create generic classes/functions in the program. A component of the program is said to be generic if its functionality remains the same irrespective of data type of the values it operates on. A generic function is a function that can work with arguments of any data type, whereas a generic class is a class that can work with members of any data type. In this chapter, we will learn creation of generic functions using function templates and creation of generic classes using class templates.

NOTES

The objective of templates is to create generic components in the program, which can work with different data types. This saves programmers effort to define the same component multiple times and replicating same logic for different type of data values.

Function Templates

Function templates in C++ enable the programmer to create generic functions. These functions are adaptable to multiple data types and can execute in the same way immaterial of the data type of the values passed to it.

The functions we have written so far in the previous chapters are strictly bonded to specific types. For example, consider the function add() as shown below:

int add(int a,int b)

﹛

int c = a+b;

return c;

﹜

The function takes two arguments of type integer and returns the resultant integer, which gives addition of two numbers. This function works well if integer values are passed to it, however the function will not produce correct results if any other type of values are passed to it.

For instance, if we call the function add() by passing float values

float k = add(10.2,11.5);

the value returned in variable k will not be correct rather truncated. As per the default behaviour of C++, value in variable k will be 21.00 and not 21.7. This means that the function has performed truncation of the resultant value resulting in loss of data. And hence, the function cannot work for float type values.

At times, it is required to implement the same logic for multiple type of values. In such cases, you can use function templates in C++.

Summary

Overview

All the operators in C++ are designed to operate with the basic data types only. For example, an arithmetic operator + can be used to perform addition of integers, floats, doubles etc. but cannot be used to perform addition of user-defined objects. Let's say if we create a class Point to represent points in Cartesian coordinate system, we are not able to perform addition of two Point objects using operator + like we do it for primitive types. Recall from Chapter 11 section 11.10 that addition of Point objects P1 and P2 is performed using a function add() defined inside the class. We performed the addition of two points P1 and P2 by making a call to add() as follows:

P3=P1.add(P2);

The function is invoked by P1 passing P2 is passed as an argument, the result of addition is stored in object P3, which gives the x and y coordinate values of the resultant point. The addition of Point objects is performed using a member function add(), merely because the arithmetic operator + cannot be used to perform addition of user-defined objects. The basic principle of operator overloading is to extend the capability of C++ operators in order to use them with user-defined types in the same way and with the same syntax as with basic types. When we say that classes are used to create user-defined data types, it is a fair expectation that the operation with user-defined objects should be performed in the same way as they are performed with primitive types.

If we overload operator + in class Point, we will be able to perform addition of Point objects as follows:

P3=P1+P2;

Making use of operator + to add Point objects makes the statement very easy to read and understand when compared to the former statement. Operator overloading is essentially used by the programmers to create programs with a friendly syntax. Clearly it is not a necessity, but it provides great luxury to the programmers to read and maintain the program.

Summary

Overview

We understand from Chapters 1 and 2 that instructions in a program are executed in a sequence in which we write them in the main() function. Such an execution is called a sequential execution. In many cases it is required to change the sequence of executing instructions based on some condition. The statements that can be used to alter the sequence of executing instructions at run time of the program are called branching or decision making control statements.

C/C++ supports a following branching/decision making control statements:

Summary

Overview

C/C++ has a dedicated set of special characters which can be used to perform operations on the data items. Each of these special characters represent as a specific operation to be performed to the compiler. For example, a symbol + is used to perform addition, and the symbol * is used to perform multiplication and so on. There are two properties associated with each of the operators so as to define the approach used for its evaluation:

Summary

Any software system to be developed (using any of the programming languages) must go through a series of steps before the system is deployed and released on to the production environment. The software development life cycle (SDLC) defines the stages involved in the software development process, so as to develop a particular application. One of the models that are followed in the development of a software application is called as a ‘waterfall’ model, which is shown in Figure A3.1.

The figure shows a series of steps that we must follow in the software development process. The meaning of each of the phases is as explained below:

Analysis: This is a phase in software development where the software engineer understands the exact requirements of the software to be developed. The requirements of the application to be developed are captured from the end users of the application and a ‘Business requirements document’ is prepared, which describes the answers to the following questions:

Summary

Factoring a state machine is the process of splitting the machine into two or more simpler machines. Factoring can greatly simplify the design of a state machine by separating orthogonal aspects of the machine into separate FSMs where they can be handled independently. The separate FSMs communicate via logic signals. One FSM provides input control signals to another FSM and senses its output status signals. Such factoring, if done properly, makes the machine simpler and also makes it easier to understand and maintain – by separating issues.

In a factored FSM, the state of each sub-machine represents one dimension of a multidimensional state space. Collectively the states of all of the sub-machines define the state of the overall machine – a single point in this state space. The combined machine has a number of states that is equal to the product of the number of states of the individual sub-machines – the number of points in the state space. With individual sub-machines having a few tens of states, it is not unusual for the overall machine to have thousands to millions of states. It would be impractical to handle such a large number of states without factoring.

We have already seen one form of factoring in Section 16.3 where we developed a state machine with a datapath component and a control component. In effect, we factored the total state of the machine into a datapath portion and a control portion. Here we generalize this concept by showing how the control portion itself can be factored.

In this chapter, we illustrate factoring by working two examples. In the first example, we start with a flat FSM and factor it into multiple simpler FSMs. In the second example we derive a factored FSM directly from the specification, without bothering with the flat FSM. Most real FSMs are designed using the latter method. A factoring is usually a natural outgrowth of the specification of a machine. It is rarely applied to an already flat machine.

Computer Hardware, Architecture and Distributed Computing

Refine search

Refine search

Actions for selected content:

705 results in Computer Hardware, Architecture and Distributed Computing

PART-I - Structured Programming

10 - Dynamic Memory Allocation in C++

Summary

14 - Inheritance

Summary

Bibliography

1 - Introduction

Summary

2 - Fundamentals

Summary

Contents

7 - Functions

Summary

9 - Structures and Unions

Summary

Preface

Summary

16 - Templates in C++

Summary

11 - Classes and Objects

13 - Operator Overloading

Summary

4 - Decision Making Control Statements

Summary

3 - Operators and Type Casting

Summary

Software Development Life Cycle

Summary

8 - Pointers

Acknowledgements

12 - Constructors and Destructors

17 - Factoring finite-state machines

Summary

Computer Hardware, Architecture and Distributed Computing

Refine search

Refine search

Actions for selected content:

Save Search

705 results in Computer Hardware, Architecture and Distributed Computing

Summary

Summary

Summary

Summary

Summary

Summary

Summary

Summary

Summary

Summary

Summary

Summary

Summary