Skip to main content Accessibility help

We use cookies to distinguish you from other users and to provide you with a better experience on our websites. Close this message to accept cookies or find out how to manage your cookie settings.

Close cookie message
×
  1. Home
  2. Browse subjects
  3. Computer Science
  4. Programming Languages and Applied Logic
  5. Content listing

Refine search

Refine search

Access:
Content type:
Publication date:
Apply   From and To filters
Subject: Show more
Journals Show more
Publishers: Show more
Societies Show more
Series: Show more
Collections: Show more

Actions for selected content:

Select all | Deselect all
  • View selected items
  • Export citations
  • Download PDF (zip)
  • Save to Kindle
  • Save to Dropbox
  • Save to Google Drive

Save Search

You can save your searches here and later view and run them again in "My saved searches".

Please provide a title, maximum of 40 characters.
Cancel
×

5570 results in Programming Languages and Applied Logic

Page 68 of 279

Introduction to Coalgebra
  • Towards Mathematics of States and Observation
  • Bart Jacobs
  • Published online:
    22 December 2016
    Print publication:
    27 October 2016
  • The area of coalgebra has emerged within theoretical computer science with a unifying claim: to be the mathematics of computational dynamics. It combines ideas from the theory of dynamical systems and from the theory of state-based computation. Although still in its infancy, it is an active area of research that generates wide interest. Written by one of the founders of the field, this book acts as the first mature and accessible introduction to coalgebra. It provides clear mathematical explanations, with many examples and exercises involving deterministic and non-deterministic automata, transition systems, streams, Markov chains and weighted automata. The theory is expressed in the language of category theory, which provides the right abstraction to make the similarity and duality between algebra and coalgebra explicit, and which the reader is introduced to in a hands-on manner. The book will be useful to mathematicians and (theoretical) computer scientists and will also be of interest to mathematical physicists, biologists and economists.

  • 17 - Exception Handling in C++

  • from PART-II - Object Oriented Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 969-993

  • Summary

    Overview

    Exception is an abnormal situation in the program that can terminate the program if it is not handled by the programmer. Some examples of exception are as follows:

  • 1. If you accidently perform division by zero in the program, then it is called division by zero exception

  • 2. If you access array elements beyond the specific boundaries of an array index, then it is called array index out of bounds exception. For example, if the size of array a is 5 and if you accidently try to access a[7] that does not exist, then it could give logically incorrect results, which is an exception

  • 3. If your program is required to take salary of an employee as input from the user and by mistake the user inputs a negative number, then it is called an invalid input exception

  • 4. If your program is writing to a file but the file is read-only, then there is an access rights violation in performing the output operation, which is also an example of exception

  • 5. In network communication, if you are writing your own C++ client to communicate with the server on the same network and if server is down when you are sending messages through the client program, then it is called ‘Resource Not available’ type of exception

    • There are many more specific types of exceptions that may occur in your program from case to case. What is important is to understand what exceptions are and how effectively we can handle them to ensure that the program does not terminate abruptly when exception occurs. It is the programmer's responsibility to create robust programs that do not fail abruptly even if any abnormal situation occurs.

    NOTES

    There is a difference between an exception and an error. If there is an error in the program, the program will certainly fail. For example, a semicolon missing after a statement is an example of syntax error; program going out of memory while running a large loop is an example of memory error and so on. Errors cannot be handled and hence the program will certainly fail when an error occurs. Whereas, exception is something that can be handled in the program thereby avoiding the abrupt failure of the program. Exception handlers in C++ are used to handle exceptions (not errors).

  • 5 - Iterative Control Statements: Loops

  • from PART-I - Structured Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 146-215

  • Summary

    Introduction

    Often we come across requirements where same set of operations need to be executed multiple times to generate the required output. For example, we need to repeatedly perform multiplication to calculate factorial of a number; we need to repeatedly draw lines to construct a polygon and so on. Each time the operation may use different data sets for evaluation; hence, results of each of the individual operations may be different, but the expression that defines the operation is always the same. To give an example, although lines are drawn repeatedly to construct a polygon, the [x,y] coordinates (data values) giving start and end of a line may be different each time. Immaterial of the data used in each stage, we will still consider this as an repetitive execution of the same operation. We can form an expression to draw line from (x1, y1) to (x2, y2) in terms of variables x1, y1, x2 and y2. We can change the value of these variables each time before repeating draw line operation so as to ensure that each line is created at a different position and the consolidated result is a polygon.

    To elaborate what we just said, let us try to construct a triangle using a series of drawLine operations. A triangle can be visualized as a consolidated effect of three lines drawn at correct positions. Hence, the execution of the drawLine operation must be repeated thrice. Before we proceed further, readers are requested to note that the detailed study of computer graphics is out of the scope of this textbook, however, we still give an example to draw a triangle using some abstract operation drawLine to understand the concept of loops in C/C++.

    Let us assume that the expression to draw a single line from point (x1, y1) to point (x2,y2) be as shown below:

    drawLine[(x1,y1),(x2,y2)]

    Drawing a triangle using this operation will now be a three-step process, which is elaborated as below:

    Stage 1: Initialize variables x1=50, y1=0, x2=0, y2=50 and execute the operation

    drawLine[(x1,y1),(x2,y2)]

    The line drawn in this step is shown in Figure 5.1.

Computer Programming with C++
  • Kunal Pimparkhede
  • Published online:
    28 May 2018
    Print publication:
    18 October 2016
  • This textbook provides in-depth coverage of the fundamentals of the C and C++ programming languages and the object-oriented programming paradigm. It follows an example-driven approach to facilitate understanding of theoretical concepts. Essential concepts, including functions, arrays, pointers and inheritance, are explained, while complex topics, such as dynamic memory allocation, object slicing, vtables, and upcasting and downcasting, are examined in detail. Concepts are explained with the help of line diagrams, student-teacher conversations and flow charts, while other useful features, such as quiz questions and points to remember, are included. Solved examples, review questions and useful case studies are interspersed throughout the text, and explanations of the logic used to implement particular functionality is also provided. This book will be useful for undergraduate students of computer science and engineering, and information technology.

  • 15 - Input and Output Streams in C++

  • from PART-II - Object Oriented Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 881-927

  • Summary

    Overview

    A program is a set of instructions that perform operations on the data to generate a desired output. The data is generally provided to the program from external sources. These sources are called inputs, which are given to the program to attain the required results. On receiving the input data, the C++ code must perform necessary computations to generate the results. These results are called the outputs, which are either to be stored somewhere or rendered to the user.

    It is important to note that a program can take inputs from multiple sources like keyboard, mouse, files, database, and so on. Along the same lines, a program can distribute its output to multiple destinations like computer screen (for rendering), files, database, speaker, and so on. The selection of input sources and output destinations purely depends upon the business requirements on the basis of which the code is designed.

    Given a variety of inputs and outputs possible in today's world, it is important that the programming language makes it easy for the programmer to write a program that can take input from any required source(s) and distribute output to any required destination(s) using a consistent approach. What this means is that, a programming language should offer a layer of abstraction to the programmer, so as to hide the complexities of differences in each of the input/output devices. The programmer's job is to only think towards the core business logic of the program and not to worry about the communication with I/O devices. The only way to make this possible is, the programming language must provide a rich application programming interface (API) that can handle inputs and outputs in the same way for any I/O device. This API is called a stream. An input stream is the one that takes data from any of the input devices and transfers it to the program. Whereas, the output stream is the one that transfers data/results generated by the program to any of the output devices. By definition, stream is a series of bytes that are transferred between the program and the I/O device. Figure 15.1 shows the role of input and output streams to transfer data between program and external devices.

  • 10 - Dynamic Memory Allocation in C++

  • from PART-I - Structured Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 497-530

  • 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.

  • 14 - Inheritance

  • from PART-II - Object Oriented Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 770-880

  • 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.

  • 1 - Introduction

  • from PART-I - Structured Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 3-22

  • 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.

  • 2 - Fundamentals

  • from PART-I - Structured Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 23-70

  • 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.

  • 7 - Functions

  • from PART-I - Structured Programming
  • Kunal Pimparkhede
  • Book:
    Computer Programming with C++
    Published online:
    28 May 2018
    Print publication:
    18 October 2016, pp 299-370

  • 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.

Page 68 of 279