Handout_Problem_Solving_and_C_Programming_v1[1].0

Handout: Problem Solving and 'C' Programming

Version: PSC/Handout/1107/1.0 Date: 16-11-07

Cognizant 500 Glen Pointe Center West Teaneck, NJ 07666 Ph: 201-801-0233 www.cognizant.com

Problem Solving and C Programming

TABLE OF CONTENTS About this Document ....................................................................................................................6 Target Audience ...........................................................................................................................6 Objectives .....................................................................................................................................6 Pre-requisite .................................................................................................................................6 Session 2: Introduction to Problem Solving and Programming Languages ...........................7 Learning Objectives ......................................................................................................................7 Problem Solving Aspect ...............................................................................................................7 Program Development Steps .......................................................................................................8 Introduction to Programming Languages ...................................................................................14 Types and Categories of Programming Languages ...................................................................15 Program Development Environments ........................................................................................18 Summary ....................................................................................................................................19 Test your Understanding ............................................................................................................19 Session 3: Introduction to C Programming Language .............................................................21 Learning Objectives ....................................................................................................................21 Introduction to C Language ........................................................................................................21 Evolution and Characteristics of C Language ............................................................................21 Structure of a C Program ............................................................................................................23 C Compilation Model ..................................................................................................................24 C Fundamentals .........................................................................................................................25 Character Set..............................................................................................................................25 Keywords ....................................................................................................................................26 Identifiers ....................................................................................................................................26 Data Types .................................................................................................................................26 Variables .....................................................................................................................................28 Constants....................................................................................................................................29 Operators ....................................................................................................................................30 Expressions ................................................................................................................................32 Type Casting...............................................................................................................................33 Input and Output Statements......................................................................................................35 Try It Out .....................................................................................................................................39 Summary ....................................................................................................................................39 Test your Understanding ............................................................................................................39 Page 2 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


Session 5: Selection and Control Structures ............................................................................41 Learning Objectives ....................................................................................................................41 Basic Programming Constructs ..................................................................................................41 Sequence....................................................................................................................................42 Selection Statements ..................................................................................................................42 ‘if’ Statement ...............................................................................................................................42 Conditional / Ternary / ?: Operator .............................................................................................44 Switch Statement ........................................................................................................................45 Iteration Statements ...................................................................................................................46 ‘for’ statements ...........................................................................................................................46 ‘while’ statement .........................................................................................................................48 ‘do - while’ statement ..................................................................................................................48 Break, Continue Statements.......................................................................................................49 Try It Out .....................................................................................................................................50 Summary ....................................................................................................................................51 Test your Understanding ............................................................................................................51 Session 7: Arrays and Strings ....................................................................................................53 Learning Objectives ....................................................................................................................53 Need for an Array .......................................................................................................................53 Memory Organization of an Array...............................................................................................53 Declaration and Initialization.......................................................................................................54 Basic Operation on Arrays..........................................................................................................55 Multi-dimensional Array ..............................................................................................................56 Strings.........................................................................................................................................58 String Functions ..........................................................................................................................59 Character Functions ...................................................................................................................61 Try It Out .....................................................................................................................................61 Summary ....................................................................................................................................63 Test your Understanding ............................................................................................................63 Session 9: Functions ...................................................................................................................65 Learning Objectives ....................................................................................................................65 Need for Functions .....................................................................................................................65 Function Prototype .....................................................................................................................66 Function Definition ......................................................................................................................67 Function Call ...............................................................................................................................69 Passing Arguments ....................................................................................................................70 Functions and Arrays ..................................................................................................................73 Page 3 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


Try It Out .....................................................................................................................................75 Summary ....................................................................................................................................77 Test your Understanding ............................................................................................................77 Session 10: Functions/Structures and Unions..........................................................................79 Learning Objectives ....................................................................................................................79 Storage Classes .........................................................................................................................79 Command Line Arguments .........................................................................................................82 Introduction to Structures and Unions ........................................................................................83 Declaration and Initialization.......................................................................................................84 Structures and Arrays .................................................................................................................87 Structures and Functions ............................................................................................................88 Try It Out .....................................................................................................................................89 Summary ....................................................................................................................................90 Test your Understanding ............................................................................................................90 Session 14: Structures and Unions / Files and Preprocessor directives ...............................92 Learning Objectives ....................................................................................................................92 Unions.........................................................................................................................................92 Union of Structures .....................................................................................................................93 Enumeration ...............................................................................................................................94 Typedef Statement .....................................................................................................................95 Introduction to Files ....................................................................................................................95 File Operations ...........................................................................................................................96 Character I/O ..............................................................................................................................98 String I/O...................................................................................................................................100 Numeric I/O...............................................................................................................................100 Formatted I/O............................................................................................................................101 Block I/O ...................................................................................................................................102 Try It Out ...................................................................................................................................104 Summary ..................................................................................................................................106 Test your Understanding ..........................................................................................................106 Session 15: Files and Preprocessor directives / Pointers .....................................................108 Learning Objectives ..................................................................................................................108 Random File Operations ...........................................................................................................108 Preprocessor Directives ...........................................................................................................109 Introduction to Pointers .............................................................................................................115 Declaration and Initialization.....................................................................................................115

Page 4 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


Pointer Arithmetic .....................................................................................................................116 Pointers and Arrays ..................................................................................................................117 Try It Out ...................................................................................................................................123 Summary ..................................................................................................................................125 Test your Understanding ..........................................................................................................125 Session 17: Pointers ..................................................................................................................127 Learning Objectives ..................................................................................................................127 Functions and Pointers .............................................................................................................127 Structures and Pointers ............................................................................................................129 Dynamic Memory Allocation .....................................................................................................130 Try It Out ...................................................................................................................................133 Summary ..................................................................................................................................136 Test your Understanding ..........................................................................................................136 Syntax Summary ........................................................................................................................138 References ..................................................................................................................................151 Websites ...................................................................................................................................151 Books ........................................................................................................................................151 STUDENT NOTES: ......................................................................................................................152



Introduction

About this Document This document provides the following topics:

Problem solving concepts

An introduction to C programming language

Basic concepts of C programming language

Target Audience In-Campus Trainees

Objectives

Explain the concepts of problem solving

Explain the concepts of C programming language

Write effective programs using C programming language

Pre-requisite This module does not require any pre-requisites



Session 2: Introduction to Problem Solving and Programming Languages Learning Objectives After completing this session, you will be able to:

Explain the Problem Solving Aspect

Identify the steps involved in program development

Know about the Programming Languages and it’s types and categories

Understand the Program Development Environments

Problem Solving Aspect Problem solving is a creative process. It is an act of defining a problem, determining the cause of the problem, identifying, prioritizing, and selecting alternatives for a solution and implementing a solution.

A problem can be solved successfully only after making an effort to understand the problem. To understand the problem, the following questions help:

What do we know about the problem?

What is the information that we have to process in order the find the solution?

What does the solution look like?

What sort of special cases exist?

How can we recognize that we have found the solution?

It is important to see if there are any similarities between the current problem and other problems that have already been solved. We have to be sure that the past experience does not hinder us in developing new methodology or technique for solving a problem. The important aspect to be considered in problem-solving is the ability to view a problem from a variety of angles.

There is no universal method for solving a given problem. Different strategies appear to be good for different problems. Some of the well known strategies are:

Divide and Conquer

Greedy Method

Dynamic Programming

Backtracking

Branch and Bound



Program Development Steps The various steps involved in Program Development are: o

Defining or Analyzing the problem

o

Design (Algorithm)

o

Coding

o

Documenting the program

o

Compiling and Running the Program

o

Testing and Debugging

o

Maintenance

Analyzing or Defining the Problem The problem is defined by doing a preliminary investigation. Defining a problem helps us to understand the problem clear. It is also known as Program Analysis. Tasks in defining a problem: o

Specifying the input requirements

o

Specifying the output requirements

o

Specifying the processing requirements

Specifying the input requirements Determine the inputs required and source of the data. The input specification is obtained by answering the following questions: o

What specific values will be provided as input to the program?

o

What format will the values be?

o

For each input item, what is the valid range of values that it may assume?

o

What restrictions are placed on the use of these values?

Specifying the output requirements Describe in detail the output that will be produced. The output specification is obtained by answering the following questions: o

What values will be produced?

o

What is the format of these values?

o

What specific annotation, headings, or titles are required in the report?

o

What is the amount of output that will be produced?

Specifying the Processing Requirements Determine the processing requirements for converting the input data to output. The processing requirement specification is obtained by answering the following questions: o

What is the method (technique) required in producing the desired output?

o

What calculations are needed?

o

What are the validation checks that need to be applied to the input data?



Example 2.1 Find the factorial of a given number Input: Positive valued integer number Output: Factorial of that number Process: Solution technique which transforms input into output. Factorial of a number can be calculated by the formula n! = 1*2*3*4….*n

Design A design is the path from the problem to a solution in code. Program Design is both a product and a process. The process results in a theoretical framework for describing the effects and consequences of a program as they are related to its development and implementation. A well designed program is more likely to be:

Easier to read and understand later

Less of bugs and errors

Easier to extend to add new features

Easier to program in the first place

Modular Design Once the problem is defined clearly, several design methodologies can be applied. An important approach is Top-Down programming design. It is a structured design technique which breaks up the problem into a set of sub-problems called Modules and creates a hierarchical structure of modules. While applying top-down design to a given problem, consider the following guidelines:

A problem is divided it into smaller logical sub-problems, called Modules

Each module should be independent and should have a single task to do

Each module can have only one entry point and one exit point, so that the logic flow of the program is easy to follow

When the program is executed, it must be able to move from one module to the next in sequence, until the last module is executed

Each module should be of manageable size, in order to make the design and testing easier

Top-down design has the following advantages:

Breaking up the problem into parts helps us to clarify what is to be done

At each step of refinement, the new parts become more focussed and, therefore, easier to design

Modules may be reused

Breaking the problem into parts allows more than one person to work on the solution simultaneously



Algorithm (Developing a Solution technique) An algorithm is a step-by-step description of the solution to a problem. It is defined as an ordered sequence of well-defined and effective operations which, when carried out for a given set of initial conditions, produce output, and terminate in a finite time. The term “ordered sequence” specifies, after the completion of each step in the algorithm, the next step must be unambiguously defined. An algorithm must be:

Definite

Finite

Precise and Effective

Implementation independent ( only for problem not for programming languages)

Developing Algorithms Algorithm development process is a trial-and-error process. Programmers make initial attempt to the solution and review it, to test its correctness. The errors identified leads to insertions, deletions, or modifications to the existing algorithm.

This refining continues until the programmer is satisfied that, the algorithm is essentially correct and ready to be executed. The more experience we gain in developing an algorithm, the closer our first attempt will be to a correct solution and the less revision will be required. However, a novice programmer should not view developing algorithm as a single-step operation Example 2.2: Algorithm for finding factorial of a given number Step 1: Start Step 2: Initialize factorial to be 1, i to be 1 Step 3: Input a number n Step 4: Check whether the number is 0. If so report factorial is 1 and goto step 9 Step 5: Repeat step 6 through step 7 n times Step 6: Calculate factorial = factorial * i Step 7: Increment i by 1 Step 8: Report the calculated factorial value Step 9: Stop

Pseudo Code Pseudo code is an informal high-level description of an algorithm that uses the structural conventions of programming languages, but omits language-specific syntax. It is an outline of a program written in English or the user's natural language. Example 2.3: Pseudo Code for finding factorial of a given number Step 1: START Step 2: DECLARE the variables n, fact, i Step 2: SET variable fact =1 and i =1



Step 3: READ the number n Step 4: IF n = 0 then Step 4.1: PRINT factorial = 1 Step 4.2: GOTO Step 9 Step 5: WHILE the condition i<=n is true, repeat Step 6 through Step 7 Step 6: COMPUTE fact = fact * i Step 7: INCREMENT i by 1 Step 8: PRINT the factorial value Step 9: STOP

Flowchart Flowchart is a diagrammatic representation of an algorithm. It uses different symbols to represent the sequence of operations, required to solve a problem. It serves as a blueprint or a logical diagram of the solution to a problem. Typical flowchart symbols are given below: Represents Start, End

Represents Input, Output data

Represents Process (actions, calculations)

Represents Decision Making

Represents Pre-defined Process / module Represents off page connector which are used to indicate that the flow chart continues on another page. Page numbers are usually placed inside for easy reference. Connector Symbol represents the exit to, or entry from, another part of the same flow chart. It is usually used to break a flow line that will be continued elsewhere.

The Document Symbol is used to represent any type of hard copy input or output (i.e. reports).



Represents control flow

Example 2.4: Flow Chart for finding factorial of a given number

START

Declare the variables n, fact, i

Initialize fact =1,i =1

Read n

True

If n=0 0

Print 1

False

If i<=n

False

True

fact = fact * i i=i+1

Print fact

STOP Coding Page 12 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


An algorithm expressed in programming languages is called Program. Writing a program is called Coding. The logic that has been developed in the algorithm is used to write the program. Documenting the Program Documentation explains how the program works and how to use the program. Documentation can be of great value, not only to those involved in maintaining or modifying a program, but also to the programmers themselves. Details of particular programs, or particular pieces of programs, are easily forgotten or confused without suitable documentation. Documentation comes in two forms:

External documentation, which includes things such as reference manuals, algorithm descriptions, flowcharts, and project workbooks

Internal documentation, which is part of the source code itself (essentially, the declarations, statements, and comments)

Compiling and Executing the Program Compilation is a process of translating a source program into machine understandable form. The compiler is system software, which does the translation after examining each instruction for its correctness. The translation results in the creation of object code. After compilation, Linking is done if necessary. Linking is the process of putting together all the external references (other program files and functions) that are required by the program. The program is now ready for execution. During execution, the executable object code is loaded into the computer’s memory and the program instructions are executed. Testing Testing is the process of executing a program with the deliberate intent of finding errors. Testing is needed to check whether the expected output matches the actual output. Program should be tested with all possible input data and control conditions. Testing is done during every phase of program development. Initially, requirements can be tested for its correctness. Then, the design (algorithm, flow charts) can be tested for its exactness and efficiency. Structured walk through is made to verify the design. Programs are tested with several test criteria and the important ones are given below:

Test whether each and every statement in the program is executed at least once (Basic path testing)

Test whether every branch in the program is traversed at least once (control flow)

Test whether the input data flows through the program and is converted to an output (data flow)

The probability of discovering errors through testing can be increased by selecting significant test cases. It is important to design test cases for abnormal input conditions.



The Boundary (or Extreme) Cases How does the algorithm perform at the extremes of the valid cases? The Unusual Cases What happens when the input data violates the normal conditions of the problem or represent unusual condition? The Invalid Cases How does the algorithm react for data which are patently illegal or completely meaningless? An algorithm should work correctly and produce meaningful results for any data. This is called foolproof programming. Debugging Debugging is a process of correcting the errors. Programs may have logical errors which cannot be caught during compilation. Debugging is the process of identifying their root causes. One of the ways to ensure the correctness of the program is by printing out the intermediate results at strategic points of computation. Some programmers use the terms “testing” and “debugging” interchangeably, but careful programmers distinguish between the two activities. Testing means detecting errors. Debugging means diagnosing and correcting the root causes. On some projects, debugging occupies as much as 50 percent of the total development time. For many programmers, debugging is the hardest part of programming because of improper documentation. Maintenance Programs require a continuing process of maintenance and modification to keep pace with changing requirements and implementation technologies. Maintainability and modifiability are essential characteristics of every program. Maintainability of the program is achieved by:

Modularizing it

Providing proper documentation for it

Following standards and conventions (naming conventions, using symbolic constants etc)

Introduction to Programming Languages What is a Programming Language? Computer Programming is an art of making a computer to do the required operations, by means of issuing sequence of commands to it. A programming language can be defined as a vocabulary and set of grammatical rules for instructing the computer to perform specific tasks. Each programming language has a unique set of characters, keywords and the syntax for organizing programming instructions. The term programming languages usually refers to high-level languages, such as BASIC, C, C++, COBOL, FORTRAN, Ada, and Pascal.



Why Study Programming Languages? The design of new programming languages and implementation methods have been evolved and improved to meet the change in requirements. Thus, there are many new languages. The study of more than one programming language helps us:

to master different programming paradigms

to enhance the skills to state different programming concepts

to understand the significance of a particular language implementation

to compare different languages and to choose appropriate language

to improve the ability to learn new languages and to design new languages

Types and Categories of Programming Languages Types of Programming Languages There are two major types of programming languages:

Low Level Languages

High Level Languages

Low Level Languages The term low level refers closeness to the way in which the machine has been built. Low level languages are machine oriented and require extensive knowledge of computer hardware architecture and its configuration. Low Level languages are further divided in to Machine language and Assembly language. (a) Machine Language Machine Language is the only language that is directly understood by the computer. It does not need any translator program. The instructions are called machine instruction (machine code) and it is written as strings of 1's (one) and 0’s (zero). When this sequence of codes is fed in to the computer, it recognizes the code and converts it in to electrical signals. For example, a program instruction may look like this: 1011000111101 Machine language is considered to be the first generation language. Because of it design, machine language is not an easy language to learn. It is also difficult to debug the program written in this language. Advantage

The program runs faster because no translation is needed. (It is already in machine understandable form)

Disadvantages

It is very difficult to write programs in machine language. The programmer has to know details of hardware to write program

It is difficult to debug the program



(b) Assembly Language In assembly language, set of mnemonics (symbolic keywords) are used to represent machine codes. Mnemonics are usually combination of words like ADD, SUB and LOAD etc. In order to execute the programs written in assembly language, a translator program is required to translate it to the machine language. This translator program is called Assembler. Assembly language is considered to be the second-generation language. Advantages:

The symbolic keywords are easier to code and saves time and effort

It is easier to correct errors and modify programming instructions

Assembly Language has utmost the same efficiency of execution as the machine level language, because there is one-to-one translation between assembly language program and its corresponding machine language program

Disadvantages:

Assembly languages are machine dependent. A program written for one computer might not run in other computer.

High Level Languages High level languages are the simple languages that use English like instructions and mathematical symbols like +, -, %, /, for its program construction. In high level languages, it is enough to know the logic and required instructions for a given problem, irrespective of the type of computer used. Compiler is a translator program which converts a program in high level language in to machine language. Higher level languages are problem-oriented languages because the instructions are suitable for solving a particular problem. For example, COBOL (Common Business Oriented Language) is mostly suitable for business oriented applications. There are some numerical & mathematical oriented languages like FORTRAN (Formula Translation) and BASIC (Beginners All-purpose Symbolic Instruction Code). Advantages of High Level Languages

High level languages are easy to learn and use

Categories of programming languages Numerical Languages Early computer technology dates from the era just before World War 2 in the late 1930s to the early 1940s. These early machines were designed to solve numerical problems and were thought of as ELECTRONIC CALCULATORS. Numerical calculations were the dominant form of application for these early machines.



Business Languages Business data processing was an early application domain developed after numerical applications. In 1959, the US department of Defense sponsored a meeting to develop COMMON BUSINESS LANGUAGE (CBL), which would be a business-oriented language that used English as much as possible for its notation. This, in turn, led to the formation of a Short Range Committee to develop COBOL. Artificial Intelligence Languages (AI) The first step towards the development of AI languages commenced with the evolution of IPL (Information Processing Language) by the Rand Corporation. The major breakthrough occurred, when John McCarthy of MIT designed LISP (List Processing) for the IBM 704. Later, more AI languages like SNOBOL & PROLOG were designed. Systems Languages Because of the need of efficiency, the use of assembly language held on for years in the system area long after other application domains started to use higher-level languages. Many systems programming languages such as CPL & BCPL were designed, though not widely used. The major landmark here is the development of UNIX, where high level languages also proceed to work effectively. What makes a Good Language? Every language has its strengths and weaknesses. For example, FORTRAN is a particularly good language for processing numerical data, but it does not lend itself very well to organize large programs. PASCAL is very good for writing wellstructured and readable programs, but it is not as flexible as the C programming language. C++ embodies powerful object-oriented features, but it is complex and difficult to learn. The choice of which language to use depends on the type of computer used, type of program, and the expertise of the programmer. Following are the most important features that would make a programming language efficient and easy to use: Clarity, Simplicity and Unity: A programming Language provides, both a conceptual framework for thinking about algorithms and a means for expressing these algorithms. The syntax of a language should be such that programs may be written, tested and maintained with ease. Orthogonality: This refers to the attribute of being able to combine various features of a language in all possible combinations, with every combination being meaningful. Orthogonality makes a language easy to learn and write programs, because there are fewer exceptions & special cases to remember. Naturalness for the application: A language needs syntax that when properly used allows the program structure to reflect the underlying logical structure of the algorithm. The language should provide appropriate data structures, operations, control structures and natural syntax for the problem to be solved.



Support for abstraction: Even with the most natural programming language for an application, there is always a substantial gap remaining between the abstract data structures & operations that characterize the solution to a problem and the particular data structures and operations built into a language. Portability of Programs: Portability is an important criterion for many programming projects which essentially indicates the transportability of the resulting programs from the computer on which they are developed to other computer systems. A language whose definition is independent of the features of a particular machine forms a useful base for the production of transportable programs. Cost of use: Cost of use is measured on different languages like:

Cost of program execution: Optimizing compilers, efficient register allocation, design of efficient run-time support mechanisms are all factors that contribute towards cost of program execution. This is highly critical for large programs that will be executed continuously.

Cost of Program creation, testing & use: This implies design, coding, testing, usage & maintenance solutions for a problem with minimum investment of programmer time & energy.

Cost of Program Maintenance: The highest cost involved in any program is the total life-cycle costs including development costs & the cost of maintenance of the program while it is in production use.

Program Development Environments The environment under which a program is designed, coded, tested & debugged is called Host Environment. The external environment which supports the execution of a program is termed as Operating or Target Environment. Host and Target environment may be different for a program or application. Programming Environments (Host Environment) It is the environment in which programs are created and tested. It tends to have less influence on language design than the operating environment in which programs are expected to be executed. The production of programs that operate reliably and efficiently is made much simpler by a good programming environment and by a language that allows the use of good programming tools and practices. Target Environments Target environments can be classified into 3 categories – Batch Processing Environment, Interactive Environment, and Embedded System Environment. Each poses different requirement on languages adapted for those environments. Batch-Processing Environments In batch-processing environments, the input data are collected in ‘batches’ on files and are processed in batches by the program. For example, the backup process on an organization. The transaction details of all the departments are collected for backup at one place and the backup is done at a time at the end of the day.



Interactive Environments In interactive environment, a program interacts directly with a user at a display console, by alternately sending output to the display & receiving input from the keyboard or mouse. Examples include database management systems, word processing systems etc. Embedded System Environments An embedded computer system is used to control part of a larger system such as an industrial plant (computerized machineries) or an aircraft. The computer system will be an integral part of the larger system, failure of which would imply failure of the larger system as well.

Summary

Program development life cycle involves analysis, algorithm development, coding, documenting, compiling and running, testing, debugging, and maintenance.

Top-down program design, divides the problem into smaller logical sub problems, called Modules.

An algorithm is a sequence of unambiguous instructions for solving a problem.

A programming language is a vocabulary and set of grammatical rules for instructing a computer to perform specific tasks.

Two major types of programming languages are Low Level Languages and High Level Languages.

The environment under which a program is designed, coded, tested & debugged is called Host environment (programming environment)

The environment under which a program is executed is called Target environment.

Target environments can be classified into 3 categories. o o o

Batch processing environment Interactive environment Embedded System environment

Test your Understanding 1. Represent the following problem in top-down design.

Planning a tour.

2. Give the algorithm, pseudo code and flowchart for the following problem:

Sort a list of numbers in ascending order.

3. Distinguish between testing and debugging. 4. State whether the following is True or False : a) Assembly language is a second generation language. b) Programs written in high Level languages needs translation for executing them.



5. What is meant by portability of programs? a. Easy to carry from place to place b. Transportability of resulting program within machine folders c. It can run on any machine d. The program needs to be compiled in every machine Answers: 3. Testing is to find errors in programs and debugging is to correct their root causes 4. True, True 5. c (it can run on any machine)



Session 3: Introduction to C Programming Language Learning Objectives After completing this session, you will be able to:

Explain the Evolution of C Language

Describe the Structure of a C Program

Know about the Compilation Model

Explain the Basic elements of C language

Introduction to C Language C is a general purpose high level programming language. Because of its flexibility and efficiency it is widely used for software development. Its features allow the development of well-structured programs. The data types and control structures are directly supported by most computers, resulting in the construction of efficient programs.

Evolution and Characteristics of C Language Evolution of C Language ALGOL was the first computer language to use a block structure. In 1967, Martin Richards developed a language called BCPL (Basic Combined Programming Language) primarily, for writing system software. In 1970, Ken Thompson created a language using many features of BCPL and called it ‘B’. ‘B’ was used to create early versions of UNIX operating system at Bell Laboratories. Both BCPL and B were “typeless” system programming languages. C was developed by Dennis Ritchie at Bell Laboratories in 1972. It was evolved from ALGOL, BCPL, and B. C uses many concepts of these languages and new features like data types. UNIX operating system was coded almost entirely in C. During 1970s, C had evolved into what is now known as “traditional C”. The popularity of C led to the development of different versions of the language that were similar but often incompatible. To assure that the C language remains standard, in 1973, American National Standards Institute (ANSI) appointed a technical committee to define a standard for C. The committee approved a version of C in 1989 which is now known as ANSI C. It was then approved by the International standards Organization (ISO) in 1990. The standard was updated in 1999. Prior to C, there are two broad types of languages:

Applications languages: Basic and COBOL, which are portable but inefficient.

Systems languages: Low Level and Assembly language, which are efficient but nonportable.



‘C‘ is developed in such a way that it is efficient and portable. C++, Java, C# conserve C syntax. The following figure depicts the history of languages:



Characteristics of C Language The increasing popularity of C is due to its various desirable qualities:

C language is well suited for structured modular programming

C is a robust language with rich set of built-in functions and operators

C is smaller which has minimal instruction set and programs written in C are efficient and fast

C is highly portable (code written in one machine can be moved to other)

C is highly flexible

C allows access to the machine at bit level (Low level (Bitwise) programming)

C supports pointer implementation - extensive use of pointers for memory, array, structures and functions

Structure of a C Program A C program can be viewed as a group of building blocks, called functions. A function is a subroutine that includes one or more statements designed to perform a specific task. preprocessor directives global declaration section main() { : } user-defined function definitions; The preprocessor directives provide instructions to the preprocessor, to include functions from the system library, to define the symbolic constants and macro. The prototype of the user-defined functions (function declaration) is specified after the preprocessor directives. The variables that are used in common by more than one function are called Global Variables and are declared in global declaration section. This section can have declarations for all the user-defined functions. Every C program must have one main() function. This function contains two parts: declaration part and executable part. The declaration part declares all the variables used in the executable part. These two parts must appear between the opening and the closing braces. The program execution begins at the opening brace and ends at the closing braces. The closing brace of the main function is the logical end of the program. The executable portion of the main function will have three types of statements: Input, Output and Processing statements. All the statements in the declaration and executable parts end with a semicolon.

C program can have any number of user-defined functions and they are generally placed immediately after the main() function, although they may appear in any order.

All sections except the main() function may be absent when they are not required. C is a case sensitive language. Comments are enclosed within /* and */. C program can be documented using these comment lines.



Example 3.1 /* Program to accept 2 integers from the keyboard as input, calculate and print their sum */ #include main( ) { int num1,num2,sum; printf (“\n Program to find the sum of two numbers\n”); printf(“\n Please enter 2 integer numbers”); scanf(“%d%d”, &num1,&num2); sum = num1+num2; printf (“\n The following data was input: %d & %d ”, num1, num2); printf(“\n The sum of two numbers is = %d”, sum); }

C Compilation Model The C Compilation model describes the program development process in terms of language. The key features of the C compilation model are as follows:

The Preprocessor The preprocessor accepts source code as input and interprets preprocessor directives denoted by #. It removes comments and empty lines in the program.



Example 3.2 #include -- includes contents of a named file. These files are usually called header files. #include -- standard library maths file. #include -- standard library I/O file #define -- defines a symbolic name or constant, macro definition #define MAX_ARRAY_SIZE 100 C Compiler The C compiler translates the preprocessed code (user written program) to assembly code (machine understandable code). Assembler The assembler creates the object code. [On UNIX, file with a.o suffix and on MSDOS files with .OBJ indicates object code files.] Link Editor If a source file references library functions or functions defined in other source files, the link editor combines these functions with main(), to create an executable file. External variable references are resolved here.

C Fundamentals Basic elements of C language constitute Character set, Identifiers, Operators and Expression.

Character Set Character set defines the characters that are used to form words, numbers and expressions. The characters in C are grouped into the following categories:

Letters o Uppercase A….Z o Lowercase a….z

Digits o

Special characters o

All decimal digits 0…9 =, +, - , % , ? , Blank spaces etc.

Escape Sequences: Escape sequences are non printable characters, which begin with backward slash and followed by one or more special characters. The frequently used escape sequences are given below:

o

Horizontal tab ( \t ) Vertical tab ( \v ) Carriage return (\r ) New line ( \n ) Form feed (\f ) Back Space ( \b ) Back Slash ( \\ )

o

Null ( \0 )

o o o o o o



Keywords Keywords have standard, predefined meanings in C. These keywords can be used only for their intended purpose and they cannot be used as programmer-defined identifiers. Keywords serve as basic building blocks for program statements. All keywords must be written in lowercase. ANSI C supports 32 keywords. The following table shows the list of keywords.

auto

double

int

Long

break

else

long

Switch

case

enum

register

typedef

char

extern

return

Union

const

float

short

unsigned

continue

for

signed

Void

default

goto

sizeof

volatile

do

if

static

While

Identifiers Identifiers are names given to various programming elements such as variables, constants, and functions. It should start with an alphabet, followed by the combinations of alphabets and digits. No special character is allowed except underscore (_). An Identifier can be of arbitrarily long. Some implementation of C recognizes only the first eight characters and some other recognize first 32 characters.

Example 3.3 Valid identifiers :

sum_2_nos

basic_pay

_amount

Invalid identifiers:

5subjects

emp name

#ofstudents

Data Types Data types are used to indicate the type of value represented or stored in a variable, the number of bytes to be reserved in memory, the range of values that can be represented in memory, and the type of operation that can be performed on a particular data item. ANSI C supports two classes of data types:

Primary / Fundamental / Basic / Primitive data types

Derived / Compound data types



Primary / Fundamental / Basic / Primitive data types C uses the following basic data types: o

int

Æ integer quantity

o

char

Æ character (stores a single character)

o

float

Æ single precision real (floating point) number

o

double Ædouble precision real (floating point) number

Typical memory requirements for these data types are given below: o

int

Æ 2 bytes

o

char

Æ 1 byte

o

float

Æ 4 bytes

o

double Æ 8 bytes

The actual number of bytes used in the internal storage for these data types depends on the machine being used.

The basic data types can be augmented by the use of data type qualifiers. Type Qualifiers Data type qualifiers add additional information to the data types. They are, o

short

o

long

o

signed

o

unsigned

A number of qualifiers or modifiers may be assigned to any basic data type to vary the number of bits utilized and the range of values represented by that data type. Here, short int may require less space than an int or it may require the same amount of memory. Similarly, a long int may require the same amount of memory as an int or it may require more memory, never less than int. For example, int = 2 bytes, short int may be 1 byte or 2 bytes int = 2 bytes, long int may be 2 bytes or 4 bytes Range of values represented by data types on 16-bit machine Type unsigned char signed char char

Meaning

Size

Unsigned character (positive)

8 bits

Represents single character. 8 bits

unsigned int

Represents positive

unsigned short int

integer numbers

16 bits

Range 0 to 255

-128 to 127

0 to 65,535



Type

Meaning

Size

Range

Short signed short short int signed short int int

represents both positive and 16 bits negative integer quantity

-32,768 to 32,767

unsigned long

represents positive long integer

32 bits

0 to 4,294,967,295

long signed long long int signed long int

Represents both positive and negative long integer

32 bits

-2,147,483,648 to 2,147,483,647

Float

Floating Point Number.

32 bits

3.4 * (10-38) to 3.4 * (10+38)

Double

A more accurate floatingpoint number than float

64 bits

1.7 * (10-308) to 1.7 * (10+308)

long double

Increases the size of double. 80 bits

void

Defines an empty data type which can then be associated with some data types. It is useful with pointers.

3.4 * (10-4932) to 1.1 * (104932)

Derived Data Types Derived data types are a combination of primitive data types. They are used to represent a collection of data. They are:

Arrays

Structures

Unions

Enumerated

Pointers

Variables A variable is an identifier that represents a value. The value represented by the identifier may be changed during the execution of the program. Variable names must be chosen in such a way that it should be a valid identifier satisfying all the basic conditions. Variable names are case sensitive (ex: variable EMPNAME is different from variable empname). The variable name can be chosen by the programmer in a meaningful way so as to reflect its function or nature in the program.



Declaration of a variable Declaration is used to specify the variable names used in the program and the type of data that the variable can hold. General form: var_data_type

list variables;

Example 3.4 int i, j, k; float x, y, z; char ch;

Initialization Variables can be initialized in the declaration statement itself or within the program using assignment statement. General Form: [data type] variable name = value;

Example 3.5 int total=0, ct=1; float sum = 0.0; int tot, ct=1; tot = 0;

Constants A constant in C refers to the fixed values that do not change during the execution of a program. There are two types of constants:

Symbolic constants

Constant variables, also called read-only variables.

Symbolic Constants A symbolic constant is defined in the preprocessor area of the program and is valid throughout the program. The preprocessor directive #define is used to define symbolic constants in a program. Symbolic constants are usually represented in upper case letters. A symbolic constant is defined as follows: #define MAX 100 #define PI 3.14



Each reference to ‘MAX’ in program will cause the value of 100 to be substituted. This value cannot be changed by the program. Constant Variables A constant variable is declared and initialized in the variable declaration section of the program and cannot be modified thereafter. The type of value stored in the constant must be specified in the declaration. Keyword ‘const’ is used to declare constant variables.

Example 3.6 const int size = 100; const float pi=3.14; const char ch = ‘a’; const long a = 50000L; or const long a = 50000l; const int a = 0567;

(Octal representation – prefix 0)

const int a = 0Xa92

(Hexadecimal representation – prefix 0x or 0X)

Operators C supports a rich set of operators. An operator is a symbol that tells the computer to perform mathematical or logical operations. Operators are used in programs to manipulate data. C operators can be classified into a number of categories. They include: Arithmetic operators + Addition Subtraction * Multiplication / Division (second operand must be nonzero) % Modulus (both operands must be integer and second operand must be non zero) Relational operators < Less than <= Less than or equals to > Greater than >= Greater than or equals to == Equals to != not equals to These operators are used to form relational expressions, which evaluates to either true or false. (true – 1, false – 0) Logical operators && || !

Logical AND (true only if both the operands are true) Logical OR (true if either one operand is true) Logical NOT (negate the operand)



Expressions which use logical operators are evaluated to either true or false. Assignment operators = Assignment operator which assign a value to an identifier. +=, *=, -=, /=. %= Compound assignment operators are used whenever, left hand side identifier is used in the right hand side expression. (a = a+b equals to a+=b) Unary operators + Unary plus - Unary minus

Increment and decrement operators ++ may be in the form of pre increment or post increment (++ k: pre increment, k++: post increment) Example: int i=5; printf(“%d”, ++i); printf(“%d”, i++); printf(“%d”, i);

/*prints 6 - pre increment */ /* prints 6 - post increment */ /* prints 7 */

-- may be in the form of pre decrement or post decrement (-- k: pre increment, k--: post increment) Conditional operator (ternary operator) ?: used to carry out simple conditional checking Example: big = (a>b)? a: b In the above statement, if condition is evaluated to true, the value of variable a will be assigned to variable big else b will be assigned. Bitwise operators & | << >>

Bit wise AND Bit wise OR Left shift Right shift

These operators are used to access machine at bit level. Special operators & Address operator * Indirection operator comma Comma operator sizeof() Size of operator (sizeof(int) = 2 bytes) Page 31 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


Order of Precedence All the operators have its own precedence and associativity. High priority operators are evaluated prior to lower priority ones. Operators of the same priority group are evaluated from left to right fashion. The expression a + b – c is evaluated as (a + b) – c. It is necessary to be careful of the meaning of expressions such as a - b / c because we may want the effect as either (a - b) / c or a - (b / c). From high priority to low priority the order for all C operators is given below:

Operator

Name

Association

( ) [ ] -> .

Parentheses, Index, member access operators

Left to Right

! – sizeof() (Typecast) * &

Logical NOT, unary minus, indirection, address

Right to Left

++ --

Increment and decrement operators.

Right to Left

*/%

Multiplicative operators.

Left to Right

+-

Additive operators.

Left to Right

< > <= >=

Inequality comparators.

Left to Right

== !=

Equality comparators

Left to Right

&&

Logical AND.

Left tot Right

||

Logical OR.

Left to Right

?:

Conditional.

Right to Left

Assignment.

Right to Left

Comma

Left to Right

=

op=

,

Example 3.7: Operators Let a=1, b=2, c=3 (1) a* b%c+1 is equivalent to

((a*b) %c)+1

which is equal to 3

(2) ++a*b – c-is equivalent to

((++a)*b) - (c--) which is equal to 1

Expressions Expression is a combination of operands, operators, function calls that evaluates to a value. The three types of expressions are Arithmetic expression (uses arithmetic operators), Relational expression (uses relational operators), and Logical expression (uses logical operators). Page 32 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


Assignment Statement Assignment statement is used to assign a value to a variable. In C, the assignment operator is “=”. The left side of the “=” is always a variable, whose address specifies where to store the data on the right side. For example, the statement x = y + z; computes the value of y+z and store the result in the variable x. However, x + 3 = y; is not legal because x + 3 is an arithmetic expression (i.e.) not a storage location. C allows multiple assignment statements using =. For example: a = b = c = d = 3; ...which is the same as, but more efficient than: a = 3; b = 3; c = 3; d = 3; Example 3.8 (1) a = (b = 2, c=3, b+c);

5

(2) a = (b=2, c=3, b+c, b-c);

-1

(3) int a; float b; a=b=3.5;

a= 3

b=3.5

(4) int c, a=3, b=4; c= a>b;

c=0

d = a == b;

d=0

e = a != b;

e=1

Type Casting C provides a mechanism for allowing the programmer to change the default data type of a given expression. This is called Typecasting. Typecasting allows a variable to behave like a variable of another type. C provides two types of type conversions: Implicit and Explicit type conversions. In implicit type conversion, if the operands of an expression are of different types, the lower data type is automatically converted to the higher data type before the operation evaluation. The result of the expression will be of higher data type. The final result of an expression is converted to the type of the variable on the LHS of the assignment statement, before assigning the value to it. For example, o

float to int assignment causes truncation of the fractional part.

o

double to float causes round of digits.

o

long int to int causes dropping of the excess higher order bits. Page 33 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


In explicit type conversion, the user has to enforce the compiler to convert one data type to another data type by using typecasting operator. This method of typecasting is done by prefixing the variable name with the data type enclosed within parenthesis. The original value of the variable is not altered. General Form: (data type)variable/expression/value; Another two terms associated with type casting are: Narrowing: Converting the higher data type value to lower data type value. Widening: Converting the lower data type value to higher data type value.

Example 3.9 float sum; sum = (int) (1.5 * 3.8); The typecast (int) tells the C compiler to interpret the result of (1.5 * 3.8) as the integer 5, instead of 5.7. Then, 5.0 will be stored in sum, because the variable sum is of type float.

Example 3.10 float

to

(int or char)

- narrowing

(char or int)

to

float

- widening

The following examples show different kinds of expressions:

Example 3.11 int a, b, c, d, e, f; float x, y, z; a=14; b=4; c = a/b; d = a % b; x = a / 10.0; y = a / 10;

/*c=3 */ /*d=2

*/

/*x=1.4 (Mixed-mode expression)*/ /*y=1.0 */

e = -a % -b; /*-2 (Modulus operation retains the sign of the first operand)*/ f = a % -b;

/*f=2*/



Example 3.12 a

b

c

int a=0, b=0, c=0;

0

0

0

a=++b + ++c;

2

1

1

a=b++ + c++;

2

2

2

a=++b + c++;

5

3

3

a=b-- + --c;

5

2

2

c = a>b;

5

2

1 (Relational expression evaluated to true)

c = a && b

5

2

1 (Logical expression evaluated to true. Non zero value is true and Zero is false)

Input and Output Statements Reading, processing, and printing of data are the three essential functions of a computer program. There are two methods of providing data to the program variables. One method is to assign values to variables through the assignment statements. Another method is to use input functions, which can get data from the keyboard (standard input-stdin). There are two types of Input and Output (I/O) statements: Unformatted I/O statements and Formatted I/O statements. Unformatted Input statements Character Input There are several functions available to input a character from the console. getchar () This function accepts a single character from the stream stdin (keyboard buffer). This single character includes alphabets, digits, punctuations, return, and tab. General form: char-variable = getchar();

Example 3.13 char ch; ch = getchar();

getch ();

- character input from console & doesn’t echo the character.



getche();

- character input from console & echoes the character.

String Input gets () This function accepts a string terminated by a new line character. Blank space is also considered as a character. To get a line of text, this function serves the purpose. General Form: gets(stringvariable);

/* string is represented as character array */

Example 3.14 char ch[5]; gets(ch);

Unformatted Output statements Character Output putchar() This function displays a single character in the standard output (stdout), monitor. General Form: putchar(char variable);

Example 3.15 char ch; ch = getchar(); putchar(ch);

String Output puts() This function displays the string in the standard output.



General Form: puts(str); Example 3.16 char ch[5]; gets(ch); puts(ch);

Formatted I/O Statements Formatted input refers to an input data that has been arranged in a particular format. C has a special formatting character (%). A character following this defines the format for a value. Some of the format specifiers are given below: %c – character %d – integer %f, %e, %g – float %s – string %ld – long integer %o – octal %x – hexadecimal %hd – short integer %[..] – string of specified characters %u – unsigned General Form: “%-+s0w.pmc” Where:

-

Æ left justify

+

Æ print with sign

s

Æ print space with no sign

0

Æ pad with leading zero

w

Æ field width

p

Æ precision

m

Æ conversion character ( h, l, L)

c

Æ conversion character (d, f, u, o, x, g, e)

Formatted Input Statement scanf() scanf () function is used to read formatted data items. General Form: scanf (“format string”, list of variables); Format string specifies the field format in which the data is to be entered. Page 37 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


List of variables specify the address of memory locations where the data is to be stored. Address operator (&) is used before the variables. Format string and variables are separated by comma. Format string, also known as control string contains field specifications, which directs the interpretation of input data. By default, the delimiter while reading the values is space. Delimiter can be user-defined. To read a string using ‘%s’, ‘&’ need not be used. Example 3.17 scanf (“%c %d %f”, &ch, &i, &x); scanf (“%[^\n]s”, str); /*accepts all inputs including space. Stops when it encounters new line.*/ scanf (“%d=%d”, &a, &b); /*delimiter between two input is = (10=20)*/ scanf (“%2d%5d”,&a,&b); /*if the input is 12345 & 10, a=12 & b=345 if the input is 12 & 3456, a= 12 & b=3456*/ scanf (“%d%d”, &a,&b); /*if the input is 12345 & 10, a=12345 & b=10*/ sscanf() sscanf() function to read values from a string. This functions returns the number of inputs read successfully. General Form: sscanf (str, “format string”, list of variables); Formatted Output Statement printf() printf () function is used to output the values. This function returns the number of characters printed. General Form: printf (“format string”, list of variables); Example 3.18 printf (“char=%c, int=%3d, floating point=%6.2f”,ch, i, x); printf (“sum = %*.*f”, w, p, sum); /* width & precision can be user defined*/ printf (“name = %10.4s”, name); /* column width 10, first 4 characters printed.*/



sprintf() sprintf() function is used to output values to a string. General Form: sprintf (str, “format string”, list of variables);

Try It Out Problem Statement: Write a program to find out value for an expression

Code: #include main() { int z,x=5,y=-10,a=4,b=2; z = x++ - --y * b / a; printf("The Value of z : %d\n",z); getchar(); } Refer File Name: to obtain soft copy of the program code

How It Works: The program assigns the value and substitute in the expression, then based on the operator precedence, the value get computed and prints on the screen

Summary

C is a structured programming language.

C program is a collection of functions.

C supports four basic primitive data types: int, char, float, double.

C has a rich set of operators.

C has Unformatted and Formatted Input / Output statements.

Test your Understanding 1. Which of the following are valid identifiers? a. Emp_name b. “total” c. main d. total-marks



2. a = (b = 2) + (c=3); Is the statement valid? 3. What will be the value of the variables x and s after the following piece of code is executed? float x, s, y=7.5; x= (int) y; s= (int) y + 3.5; 4. What is ternary operator in C? 5. What is the difference between getche() and getch()? 6. If, the scanf() statement contains the following control : “%d \n %d” Which of the following set of inputs will successfully read ? a. 4 5 b. 4 5

7. What is the output of the following code? int a , b = printf (“welcome”); printf (“%d “,b); Answers: 1. a,c ( “ “ , - are not the valid characters to form an identifier) 2. valid 3. x = 7.0 , s = 10.5 4. ?: is called ternary operator (conditional operator) used to carry out simple decision making. 5. getche() echoes the input character on screen, but getch() will not echo the character. 6. All are valid. 7. welcome7



Session 5: Selection and Control Structures Learning Objectives After completing this session, you will be able to:

Write a Simple Program

Write program using Conditional statements

Write program using Looping and Iteration

Basic Programming Constructs The basic programming constructs are sequence, selection, and iteration (looping). In a sequence construct, the instructions are executed in the same order in which they appear in the program. In a selection structure, the control flow can be altered by evaluating conditions. In an iterative structure, a group of instructions is executed repeatedly, until some condition is satisfied. Statements in C Simple Statement (expression statement) An expression terminated by a semicolon (;) is termed to be a simple statement (or expression statement). Example 5. 1 a=8; c=a+b; ; Æ Null statement

Compound Statements / Blocks Compound statements are used to group the statements into a single executable unit. It consists of one or more individual statements enclosed within the braces { }. Example 5. 2 {

{

{

a=10;

a=1;

b=10;

x=a*b;

{

c=a + b;

y = x * b – k;

b=2; c=3;

}

}

} }



Sequence A program, which consists of declaration statements, input-output statements, and one or more simple expression statements, is executed in a sequential manner.
Selection Statements Selection statements are used to alter the normal sequential flow of control. It provides the ability to decide the order of execution. The following are the selection constructs available in C:

“ if ” statement

Conditional / Ternary operator statement (? :)

“switch” statement

‘if’ Statement The if statement, allows us to establish decision-making in the programs. Programs may require certain logical tests to be carried out at some particular points. The tests and subsequent decisions are made by evaluating a given expression as either True (non zero) or False (zero). An expression involves arithmetic, relational, and/or logical operators. Depending on the result of the expression the statements are executed. The if statement has three basic forms:

Simple if-else

Nested if

if-else if ladder

Simple “if-else” General Form: if (expression) { statements1; } [ else { statements2; } ] statements3; [ ] is used to represent the optional usage of ‘else’ block. Expression can be arithmetic, logical, and/or relational expression. If the expression is evaluated to true (nonzero), the statements1 are executed and the control is transferred to the statements (statements3) next to the if construct is executed. If the expression is evaluated to false (zero), the



statements1 will be skipped and the else part statements (statements2) are executed. If the else part is not specified, the statements (statements3) next to the if construct is executed.

Example 5.3: Program to find maximum of two numbers. if (a
printf(“ max = %d” ,max); Short-circuit Evaluation Whenever the expression with the operators && and || are evaluated, the evaluation process stops as soon as the outcome, true or false is known. For example: expr1 && expr2 If the value of expr1 is zero, the evaluation of expr2 will not occur [ 0 AND anything is 0] expr1 || expr2 If expr1 has non-zero value, the evaluation of expr2 will not occur [ 1 OR anything is 1] Nested ‘if’ Statement Body of an ‘if’ statement contains another ‘if’ statement. General Form: if (expression) { statements1; if (expression) statements-1; } else { statements2; if (expression) statements-2; }

Example 5.4 Program to find the maximum of 3 numbers. if (a>b) if (a>c) printf(“largest = %d”, a); else printf (“largest = %d”,c);



else if (c>b) printf (“largest = %d”,c); else printf (“largest = %d”,b);

‘if… else if’ Ladder Statement General Form: if (expression) statements1; else if (expression) statements2; else if(expression) statements3; else statements4; Each condition is evaluated in order and if any condition is true the corresponding statement is executed and the remainder of the chain is skipped. The final ‘else’ statement is executed only if none of the previous conditions are satisfied. Final ‘else’ serves as a default case and is useful in detecting an impossible or error condition. Example 5.5 if (mark >= 75) printf(“Honours\n”); else if (mark >=60) printf(“First Class\n”); else if (mark >=50) printf(“Second Class\n”); else if (mark >=45) printf(“Third Class\n”); else printf(“Fail\n”);

Conditional / Ternary / ?: Operator This operator takes 3 expressions / operands. It is a more efficient form for expressing simple if statements. General form: [variable = ]expr1? expr2:

expr3;

This simply states: Page 44 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


if (expr1 is true) then expr2 else expr3 Where: o

expr2 is evaluated, if the value of expr1 is non-zero (true part).

o

expr3 is evaluated, if the value of expr1 is zero (false part).

Example 5.6 max = (a>b) ? a : b; which is similar to the following if-else statement. if (a>b) max = a; else max = b;

Switch Statement This is a conditional control statement that allows some particular group of statements to be chosen from several available groups. It is a multi-way conditional statement generalizing the ‘ifelse’ statement. A switch statement allows a single variable to be compared with several possible case labels, which are represented by constant values. If the variable matches with one of the constants, then an execution jump is made to that point. A case label can not appear more than once and there can only be one default expression. General Form: switch (expression) { case item1: statement 1; break; case item2: statement 2; break; case itemn: statement n; break; default : statement; } Expression in the switch statement, must be an integer valued expression. Expression may be a constant value, variable, array variable, pointer variable, relational expression, logical expression, and/or arithmetic expression. Items which represent the case labels must be an integer constant or character constant. Default case is optional and if specified, default statements will be executed, if there is no match for the case labels. The break is needed to terminate the switch after the execution of particular choice. Otherwise the next cases get evaluated.



Example 5.7 switch (op) { case ‘+’: c=a+b; break; case ‘-’: c=a-b; break; case ‘*’: c=a*b; break; case ‘/’: c=a/b; break; default: printf (“Invalid operator”); }

Iteration Statements Most of the real world applications require some set of instructions to perform repetitive actions on a stream of data. There are several ways to execute loops in C. The statements used for looping are: ‘for’, ‘while’, ‘do- while’.

‘for’ statements This statement is used to repeat a statement or a set of statements for a specified number of times or until a condition satisfied. General Form: for (expression1; expression2; expression3) { statement / block of statements; } Where:

expression1 initializes the counter/index variable. The initialization is usually an assignment statement that is used to set the index variable or loop control variable.

expression2 is to set a terminating condition. It is evaluated at the beginning of every iteration. If the test condition is True, the statements inside the loop are executed. If the test condition is False, the control is transferred to the statement, which follows the loop.



expression3 is the loop variant/modifier (increment / decrement), which is evaluated at the end of every iteration. These three expressions are separated by semicolons. Example 5.8 (1) for (x=0;

((x>3) && (x<9));

(2) for (x=0, y=4;

x++)

((x>3) && (y<9));

(3) for (x=0, y=4, z=4000;

z ;

x++, y+=2)

z/=10)

(4) c=2; for (;c<=20;c=c+2) Æ infinite loop

(5) for (c=2;;++c) (6) c=2; for (;c<=20;) { printf (“%d”, c); c++; } (7) int c=0;

Æ infinite loop

for(;;) { c+=1;

printf (“c=%d”, c); } Nested ‘for’ statement There are many situations in which a loop statement contains another loop statement. Such loops are called nested loops. Example 5.9 for (i=1;i<=3;i++) { printf(“\n i = %d”,i); for (j=1;j<=3; j++) printf (“\n j = %d”,j); } In the above example, the loop controlled by the value of ‘i’ is called the outer loop. The second loop, controlled by the value of ‘j’, is called inner loop. All statements in the inner loop are within the boundaries of the outer loop. Different variables must be used to control each loop. For each & every iteration through the outer loop, the inner loop runs completely.



‘while’ statement The while is an entry controlled loop statement. The conditional expression is evaluated at the beginning and the result of the expression decides on the execution of the body of loop. If the result is True, the body of the loop is executed, General Form: while (expression) { Statements; } Expression can be a constant value, variable or any expression. If the expression evaluates to True, the body of the loop is executed, otherwise statements after the while block is executed. After executing the body of the loop, the expression is checked again. The body of the loop is executed repeatedly until the expression is False. If the expression is initially False, the body of loop is not executed at all. The body of the loop may have one or more statements. The braces are needed only if the body contains two or more statements. Example 5.10 Different ways to use while loops (1) while(x--){ }; (2) while(x = x+1){ }; (3) while(x) { }; (4) while(1); (5) while ( (ch = getche ( )) != ‘q’) putchar(ch); (6) c=1; while (c<=10) { printf (“%d”,c); ++c; }

‘do - while’ statement The do... while is an exit controlled loop statement. General Form: do statement (s); while (expression); On reaching the do statement, the program proceeds to evaluate the body of the loop first. At the end of the loop, the expression in the while statement is evaluated. If the expression is evaluated Page 48 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


to True, the program continues to evaluate the body of the loop once again. This process continues as long as the expression evaluates to True. When the condition becomes False, the loop will be terminated and control is transferred to the next statement following the do..while. Since the expression is tested at the end of the loop, the body of the loop is executed at least once. Example 5.11 int d=1; do { printf (“%d\n”,d); ++d; } while (d<=10);

Break, Continue Statements

Break Statement The break statement can appear in the switch statement and the loop statements. It causes the execution of the current enclosing switch case or the loop to terminate. General Form: break; Example 5.12 for(loop=0;loop<50;loop++) { If (loop==10) break;

/* control will come out of the loop. */

printf("%d\n",loop); } Only numbers 0 through 9 are printed. Continue Statement The continue statement can only appear in the loop statements. It is used to terminate the current iteration. It skips rest of the statements in the body of the loop and begins the next iteration. General Form: continue; Example 5.13 for(loop=0;loop<100;loop++) { if (loop==50)



continue; printf("%d\n",loop); } The numbers 0 through 99 are printed except 50.

Try It Out Problem Statement: Write a program to convert pounds in to equivalent international units starting from 10 pounds to 250 pounds incremental of 10 pounds

Code: #include #define KILOS_PER_POUND .45359 main() { int pounds; printf(" US lbs

UK st. lbs

INT Kg\n");

for(pounds=10; pounds < 250; pounds+=10) { int stones = pounds / 14; int uklbs = pounds % 14; float kilos = pounds * KILOS_PER_POUND; printf(" %d %d %d %f\n", pounds, stones, uklbs, kilos); } getchar(); } Refer File Name: to obtain soft copy of the program code

How It Works:

This program converts pounds in to stones , uklbs and kilos.

The conversion has to be done starting from 10 pounds till 250 pounds in the incremental of 10 pounds.

We know the starting point, termination condition and the increment, so we have used the for loop.

For each pounds, apply formula to get the stones,uklbs and kilos and print on the screen.

Continue this till the termination condition is met i.e, till the pound becomes greater than or equal to 250 pounds



Summary

if statement is a condition based decision making statement.

Ternary operator is more efficient form for expressing simple if statements.

Switch statement is a conditional control statement that allows some particular group of statements to be chosen from several available groups.

Looping allows a program to repeat a section of code any number of times or until some condition occurs.

for, while, and do-while statements are repetitive control structures available in C , that are used to carry out conditional looping.

break statement is used to terminate the loop but continue statement skips the current iteration and continues the loop with the next iteration.

Test your Understanding 1. Which of the following statements are true? a. An if statement must always include an else clause. b. An if statement may include only simple statements. c. if clause can contain another if statement. 2. When will the default case in switch statement be executed? 3. What is the output of the following piece of code? main( ) { int i=3; switch(i) { default : printf(“0”); case 1 : printf(“1”); break; case 2 : printf(“2”); break; case 3 : printf(“3”); break; } }



4. What is the difference between a while and do..while statements?What is the output of the following code? while(1) { if (printf (“%d”, printf (“%d”))) break; else continue; } Answers: 1. c 2. Default case is executed, whenever evaluated expression does not matches with any of the case labels. 3. 3 4. While is an entry controlled loop (condition is checked in the beginning) and do..while is exit controlled loop (condition is checked at the end). The loop statements of do..while will get executed at least once. 5.

01



Session 7: Arrays and Strings Learning Objectives After completing this session, you will be able to:

Explain the concept of Array and memory organization

Write program using Single-dimensional arrays

Write program using Multi-dimensional arrays

Understand Strings

Understand String and Character functions

Need for an Array Many applications require the processing of multiple data items that have common characteristics (e.g., set of numbers, set of names). Array is a derived data type which is used to store similar data items in contiguous memory locations under a single name. It holds a fixed number of equally sized data elements, of the same data type. The individual elements are accessed by specifying the subscript.

Memory Organization of an Array The elements in an array are always stored in consecutive memory locations. If an array of 5 integers elements is created, totally 10 contiguous bytes will be allocated in memory. Note: size of an integer is assumed to be 2 bytes

Starting address is assumed as 1000 and totally 10 bytes are created. 1000

1002

1004

1006

1008

Individual memory location is referred by index. [index 0 refers first location , index 1 refers second location, etc.]. Address of an array element is calculated as below: Address of ith location = base address + (size of the individual data element * index i ) Address of 0th element = 1000 + (2 * 0) = 1000 Address of 1st element = 1000 + (2 * 1) = 1002 … In C, the name of the array refers to the base address of the array.



Declaration and Initialization Array Declaration Arrays are declared with appropriate data type and size. Arrays can be of single dimension or of multi dimensions. Array declaration reserves space in memory. General Form: datatype arrayname[size] ; Arrays are defined by appending an integer encapsulated in square brackets at the end of a variable name. Each additional set of brackets defines an additional dimension to the array (multi dimensional arrays). When addressing an element in an array, indexing begins at 0 and ends at 1 less than the defined size of an array. Example 7.1 int x[5]; Defines an integer array x of at x[4].

5 integers, starting at x[0], and ending

char str[16]="qwerty"; Defines a character array, which is represents a string of maximum of 16 characters. float sales_amt[10]; Defines a floating point array sales_amt of 10 floating point numbers, starting at sales_amt[0] and ending at sales_amt[9]. int matrix[2][2]; Defines a 2*2 matrix (totally 4 elements) of integers. Accessing Array Elements The array elements are accessed by specifying the subscript / index. General Form: arrayname[index or subscript] Example 7.2 x[0]

Æ to access the 1st element in array

x[4]

Æ to access the 5th element in array

str[2]

Æ to access the 3rd character in the string (character array)

sales_amt [8] Æ to access the 9th sales amount in the array



Array Initialization Array elements can be initialized during declaration or can be initialized in the program. When arrays are initialized during declaration, partial initialization is allowed. In partial initialization, the uninitialized array elements are initialized to Zero or Null depending on the data type of the array. Zero is initialized for numeric array and Null for character array. If initialized, array can be declared without specifying the exact size. In such cases, size of the array equals the number of elements initialized. General Form: datatype arrayname[size] = {value(s)}; OR datatype arrayname[ ] = {value(s)}; Example 7.3 int a[5]={1,2,3,4,5}; /*a[0] = 1, a[1] = 2 , a[2] = 3 , a[3] = 4 and a[4] = 5*/ int a[5]={0}; /*all the array elements are initialized to zero*/ int a[5]={1,2,3,4}; /*a[4] = 0*/ int a[ ] = {1,2,3,4}; /*a[0]=1, a[1]=2, a[2]=3, a[3]=4 (if size not specified, size depends upon the number of values initialized. ) */ float b[2]={10.2,45.34}; /* b[0] = 10.20 ,

b[1] = 45.34 */

Basic Operation on Arrays Basic operations allowed on arrays are storing, retrieving, and processing of array elements. Insertion and deletion can be done by moving the array elements to the appropriate places. (ex. 3rd element can be deleted by moving 4th element to 3rd location, 5th element to 4th location and so on) Array name is a constant pointer (pointer is a variable which holds address of another variable) to the base address of the array. Thus, the base address can not be changed. The following expressions are illegal:

a++ (base address of array ‘a’ is modified by adding one)

a+=2 (base address of array ‘a’ is modified by adding two)



Getting the value for Arrays Input statement is used to get the values for an array. Example 7.5 int a[3]; (1)

(2)

scanf(“%d”, &a[0]);

/*gets value for 1st location*/

scanf(“%d”, &a[1]);

Æ gets value for 2nd location*/

scanf(“%d”, &a[2]);

Æ gets value for 3rd

location*/

scanf(“%d%d%d”, a, a+1, a+2); /* gets value for first 3 locations (array name has the base address - pointer)*/

(3)

for(i=0;i<3;i++) scanf(“%d”,&a[i]); /* usually loop statement is used to get the array elements*/

Printing out the array elements Example 7.6 int a[3]; (1)

printf(“%d”, a[0]); printf(“%d”,a[1]);

/*prints value of 1st location*/ /*prints value of 2nd location*/

printf(“%d”, a[2]); /*prints value of 3rd (2)

location*/

printf(“%d%d%d”,a[0],a[1],a[2]); /* prints value of first 3 locations*/

(3)

for(i=0;i<3;i++) printf(“%d”,a[i]); /*loop statement is used to print the array

elements */

Multi-dimensional Array The elements of an array can themselves be arrays. Multidimensional arrays will also occupy the contiguous memory locations. Two dimensional arrays can be viewed as set of one dimensional array (rows & columns) and 3 dimensional arrays can be viewed as set of two dimensional arrays. Two-dimensional array – Declaration Two-dimensional arrays are defined in the same way as one dimensional array, except that a separate pair of square brackets is required for second dimension. General Form: datatype arrayname [row ][column]



Example 7. 7 int a[2][2]; = 4 elements).

Æ creates

8 bytes of contiguous memory locations. (2*2

Elements are stored in row major order. Elements of 1st row are stored first and then the elements of next row. It is necessary to specify the size of the column in declaration. Assume that array starts at location 1000, a[0][0]

will be in location 1000

- row 0 & column 0

a[0][1]


- row 0 & column 1

a[1][0]


- row 1 & column 0

a[1][1]


- row 1 & column 1

Two-dimensional array Initialization Two-dimensional arrays can also be initialized in the declaration statement. In partial initialization, the uninitialized array elements are initialized to Zero. Example 7.8 int num[2][3] = {1,2,3,4,5,6}; int num[2][3] = {1,2,3,4,5};

/*num[1][2] = 0*/

int num[2][3] = {{1,2,3},{1,2,3}}; /*row elements are initialized separately*/ int num[2][3] = {{1,2},{4}}; /*num[0][2] = 0

num[1][1]=num[1][2]=0*/

Example 7.9: 4-dimensional array sales [year ] [month ] [area ] [salesperson] Advantages

Simple and easy to use

Stored in Contiguous locations

Fast retrieval because of its indexed nature

No need to worry about the allocation and de-allocation of arrays

Limitations

Conventional arrays are static in nature. Memory is allocated in the beginning of the execution. If m elements are needed, out of n locations defined, n-m locations are unnecessarily wasted

No automatic array bounds checking during compilation



Strings Strings are sequence of characters. In C, there is no built-in data type for strings. String can be represented as a one-dimensional array of characters. A character string is stored in an array of character type, one ASCII character per location. String should always have a NULL character (‘\0’) at the end, to represent the end of string. String constants can be assigned to character array variables. String constants are always enclosed within double quotes and character constants are enclosed within single quotes. Example 7.10 (1) char c[4]={‘s’,’u’,’m’,’\0’); (2) char str[16]="qwerty";

/*Creates a string. The value at str[5] is the character ‘y’. The value at str[6] is the null character. The values from str[7] to str[15] are undefined.*/

(3) char name[5]; int main( ) { name[0] = ‘G’; name[1] = ‘O’; name[2] = ‘O’; name[3] = ‘D’; name[4] = ‘\0’; return 0; } (4) char name[5] = “INDIA” /* Strings are terminated by the null character, it is preferred to allocate one extra space to store null terminator */ Array of Strings Two dimensional character arrays are used to represent array of strings. Declaration General Form: char arrayname [no. of strings] [max no. of chars in strings]; Example 7.11 char studname[50][15]; /* 50 student names each with 15 characters at the maximum */



Initialization General Form: char arrayname [ r ] [ c ]={“values”}; Example 7.12 char name[3][5] = {“bata” ,”cat” ,”at”} char name[3][5] {‘a’,’t’,’\0’}}

=

{{‘b’,’a’,’t’,’a’,’\0’},

{‘c’,’a’,’t’,’\0’},

String can be read either character-by-character or as an entire string (using %s format specifier). Array name itself specifies the base address and %s is a format specifier which will read a string until a white space character is encountered. [Note: no need to use & operator while reading string using %s] Example 7.13 (1) char name[20]; int i=0; while((name[i] = getchar ()) != ‘\n’ ) i++; (2)

scanf( “%s“ , name);

(3)

printf(“%s” , name);

Illegal operations on Strings C does not allow one array to be assigned to another, thus statements of the following form are illegal” Or

name1 = name;

Æ assignment not allowed

name = “GOOD”;

name1 = name + “to c “ Æ concatenation is not allowed

if (name1 == name) Æ two strings cannot be compared with the ‘equal to’ operator

String Functions

C does not provide any operator, which manipulates the entire string at once. Strings are manipulated either via pointers or via special routines available from the standard string library string.h.



The following is the list of string functions available in string.h: String Functions

Functionality

strcpy(string1, string2)

Copy string2 into string1

strcat(string1, string2)

Concatenate string2 onto the end of string1

strcmp(string1,string2)

Lexically compares the two input strings (ASCII comparison) returns 0 if string1 is equal to string2 < 0 if string1 is less than string2 > 0 if string1 is greater than string2

strlen (string)

Gives the length of a string

strrev (string)

Reverse the string and result is stored in same string.

strncat(string1, string2, n)

Append n characters from string2 to string1

strncmp(string1, string2, n)

Compare first n characters of two strings.

strncpy(string1,string2, n)

Copy first n characters of string2 to string1

strupr (string)

Converts string to uppercase

strlwr (string)

Converts a string to lowercase

atoi (string)

Converts the string to integer number

atof (string)

Converts the string to floating point number

atol (string)

Converts the string to long integer number

strchr (string, c)

Find first occurrence of character c in string.

strrchr (string, c)

Find last occurrence of character c in string.

strstr(s1,s2)

Locates the first occurrence of s2 in s1.

strpbrk(s1, s2)

Returns a pointer to the first occurrence in s1 of any character from s2

strspn(s1, s2)

Returns the number of characters at the beginning of s1 that match s2.

strcspn(s1, s2)

Returns the number of characters at the beginning of s1 that do not match s2.



Character Functions C provides the following collection of character functions, which can manipulate a single character. The header file, ctype.h, is used for the character functions. Functions

Functionality

int isalnum (c)

True if c is alphanumeric.

int isalpha (c)

True if c is a letter.

int isascii( c)

True if c is ASCII .

int iscntrl (c)

True if c is a control character (\n,\f,\r,\a)

int isdigit (c)

True if c is a decimal digit

int isgraph (c)

True if c is a graphical character (all characters, except space)

int islower (c)

True if c is a lowercase letter

int isprint (c)

True if c is a printable character (all characters including white space)

int ispunct (c)

True if c is a punctuation character (, . ,‘, ‘, “,:,)

int isspace( c)

True if c is a space character (\n,\f,\r,\t,\v,’ ‘)

int isupper (c)

True if c is an uppercase letter

int isxdigit (c)

True if c is a hexadecimal digit

toupper (x)

Converts lowercase letter to uppercase

tolower (x)

Converts uppercase to lowercase

toascii (x)

Converts the char to ASCII value

Try It Out 1. Problem Statement: Write a program to develop Fibonacci series using arrays

Code: #include main() { int fib[24]; int i; fib[0] = 0; fib[1] = 1; for(i = 2; i < 24; i++) fib[i] = fib[i-1] + fib[i-2]; for (i = 0; i < 24; i++) Page 61 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


printf("%3d %6d\n", i, fib[i]); getchar(); } Refer File Name: to obtain soft copy of the program code

How It Works:

The Fibonacci series is 1,2,3,5,8,13…..

This program implemented fibonacci series by using for loop and array.The program computes the series up to 24 numbers.

Initially array of size 24 is declared, as we know the first two numbers initialize the first two elements in the array.

In the for loop start adding the values in the previous two indices of array and store it in the third element

Then increment the indices and keep continuing the same process until 24 numbers are added.

Again use the for loop to print the series one by one from the array.

2. Problem Statement: Write a program to demonstrate two dimensional arrays

Code: #include main() { int twod[4][5]; int i,j; for(i=0; i<4; i++) for(j=0; j<5; j++) twod[i][j] = i*j; for (i=0; i<4; i++) { for (j=0; j<5; j++) printf("%d ", twod[i][j]); printf("\n"); } getchar(); } Refer File Name: to obtain soft copy of the program code

How It Works:

This program explains the how to use the two dimensional array.



In two dimensional array, two indices will be used, one represent the row and the other one column. Here “i” represents row and the “j’ represents the column

Two for loops are used.

The outer loop decides the row and the inner loop represents the column

Initialise both i and j to 0.

For each value of i, find out all the values of column by multiplying the i with j with incremental of j.

Store the values in the array

Use another for loop to print the values in the two dimensional array in the form of matrix.

The program output looks like this: o 00000 o 01234 o 02468 o 036912

Summary

An array can be defined as a collection of homogenous elements stored in consecutive memory locations.

Array name is a constant pointer to the base address of the array.

Conventional array always has a predefined size and the elements of an array are referenced by means of an index / subscript.

An array can be of more than one dimension. There is no restriction on the number of dimensions.

String is represented as an array of characters.

C supports a number of in-built string functions to manipulate strings.

Test your Understanding 1. Is it possible to declare an array x containing 50 integer elements followed immediately by 50 floating point numbers? 2. Why array index should always start with 0? 3. How entire array, x[100] with value 0, is initialized in declaration statement? 4. When a one dimensional array is being declared, under what condition may the size be omitted, with array name followed by an empty pair of square brackets?



5. What is the output of the following code? main() { int a[5]={2,3}; printf(""\n %d %d %d"",a[2],a[3],a[4]); }

6. List few library functions for string operations. Answers: 1. No, array can contain only similar data items. 2. Array elements are accessed by relative addressing method (base address + index), in order to access the first element, which is in base address, index must be 0. 3. int x[100] = {0} ( partial initialization) 4. If an entire array is being initialized within the declaration. 5. 0 0 0 6. strlen(), strcmp(), strcat(), strrev(), strcpy()



Session 9: Functions Learning Objectives After completing this session, you will be able to:

Define functions

Understand how to pass arguments to function

Understand and Implement Recursive functions

Understand how to pass arrays in a function

Need for Functions Functions are smaller self-contained components which carry out some specific, well defined task. As real world applications become more complex and large, several problems arise. Most common are:

Algorithms for solving more complex problems become more difficult and hence difficult to design.

Even after designing an algorithm, its implementation becomes more difficult because of the size of the program.

As programs become larger, testing, debugging, and maintenance will be a difficult task.

Thus, complex problems can be solved by breaking them into a set of sub-problems, called Modules. Each module can be implemented independently and later can be combined into a single unit. C supports modularity by means of functions. C functions are classified into two categories.

User defined functions

Library functions

C function offers the following advantages.

It facilitates top-down modular programming. Modularity brings logical clarity to the programs

It avoids the need for redundant code. The repeated instructions can be written as a function, which can then be called whenever it is needed

It facilitates reusability – functions created in one program can be accessed in other programs. C programmer can build on what others have already done, instead of starting from scratch

C functions can be used to build a customized library of frequently used routines



Function Prototype Like variables, functions are declared and declaration of a function is called Function Prototype. Prototype specifies the signature (name) of the function, the return type, and number and data types of the arguments. It helps the compiler to know about the function. Functions must be declared before it is called. Function prototyping is not mandatory in C. It is mandatory when the function is called prior to its definition. They are desirable, however, because they further facilitate error checking between function calls and the corresponding function definition. Example 9.1 int

find_big (int, int);

/* function find_big returns integer value, takes 2 integer arguments */ void

swap (int *, int *);

/* function ‘swap’ does not return any value, takes 2 pointer variables. */ float add(float, int); /* function ‘add’ returns float value, takes 1 float variable and 1 integer variable */

Example 9.2 (1) main() { int a,b; int sum(int, int) ;

/*

function prototyping. */

scanf("%d%d” , &a, &b); printf(“ %d “ ,

sum(a, b);

} int sum(int a , int b) { return a+b; }



(2) void fun() { printf(“"prototype not needed “);

Function is defined prior to its reference. So compiler will identify the function name.

} main() { fun(); }

Function Definition Function definition is used to define the function with appropriate name, parameters, and the operations to be carried out by the function. Functions can be defined at any location in the program. If the function is defined before the ‘main’ program, there is no need for the function prototype. A function definition has two principle components: Function header (first line), Function body. General form: return-type function-name(type arg1, type arg2, …..) { local variables Declaration; executable statement 1; executable statement 2; : return expression; } Function Header

function-name Æ specifies the name of the function and it must be a valid identifier

arg1,arg2 …

Æ specifies formal arguments (formal parameters)

return-type

Æ represents the data type of the data item returned by the function

Function Body Function can have declaration statements and any number of valid executable statements. Local Variables - The variables declared inside any function are local to that function. It can be accessed only within that function. Memory for the local variables is allocated only when the function is invoked and de-allocated when the control moves out of the function. Global Variables - The variables that are common to all the functions are declared outside the functions. If it is declared in the Global declaration section, it is used by all the functions in the program. Memory for the global variables is allocated, when the program gets executed and deallocated only at the end of program execution.



return statement is used to transfer the control back to the calling program. A function may or may not return a value to the calling function. A function may receive any number of values from the called function. If it returns a value, it is achieved by the return statement. There can be multiple return statements, each containing different expression. If there is no return statement, the closing braces (}) in the function body acts as a return statement. General Form: return; OR return(expression); expression can be a variable name, constant value or any single valued expression. Example 9.3 (1) return; Æ does not return any value; (control is transferred to calling program) Æ returns zero

(2)

return 0;

(3)

return(a*b);

Æ returns the product of a & b

(4)

return(a
Æ returns True (1) or False (0)

Example 9.4 Function for finding the biggest of two integers int find_big(int a, int b) { if ( a > b) return a; else return b;

Function Name

– find_big

Return Type

– integer

Formal arguments – 2 (a, b)

} If the function doesn’t receive any arguments and doesn’t return any data, then void keyword is used to represent that. Default return type is ‘int’. Example 9.5 (1)

void display(void) { printf(“this is a function”); }

(2)

main() { return 0; }



Function Call Functions are invoked by specifying its name, followed by a list of parameters enclosed within parentheses. General form: [variable name =] function name(actual arguments); Actual arguments are the parameters passed to the called function. The number, data type, and the order of the actual arguments and formal arguments should match. Variable names of the actual arguments and the formal arguments need not be same. When the function call is encountered, the control is transferred to the called function and the statements in the function are executed. When the return statement is executed or last statement is execution, the control is transferred back to the place of function call in the calling function. If a function is returning a value, that value is substituted in place of a function call in the calling function. The LHS variable name in the function call is optional. If the function returns value, the value returned is stored in the LHS variable name. Example 9.6 Program for finding biggest of two integers using the function find_big int find_big(int, int); /* function prototype, global declaration */ main( ) { int num1, num2, big; scanf(“%d%d”, &num1, &num2); big=find_big(num1,num2); /* function call statement, num1 & num2 are actual arguments */ printf(“ The biggest is : %d “, big); } int find_big(int a, int b)

/* a & b are formal arguments */

{ if ( a > b) return a; else return b; } Note: Function can also be called using printf (“The biggest is: %d”, find_big(num1,num2)) statement. Recursion If a function is having a self-reference, it is called Recursion. It is a process by which a function calls itself. A recursive function must have the following properties:

The problem must be written in a recursive form



There must be a base criteria (terminating condition) for which the function doesn’t call itself

Example 9.7 main() { int n, fact(int); printf(“Enter an integer\n”); scanf(“%d“,&n); printf(“Factorial = %d“,fact(n)); } fact(int k); { if (k<=1) return 1; else return(k*fact(k-1); } If n = 4, then call 1 = 4 * fact(3); call 3 = 2 * fact(1)

call 2 =

3 * fact(2) ;

In fourth call, the condition evaluates to 1 and returns 1 to the calling part (call 3), which in turn return the value to its calling function. Function will be evaluated in Last In First Out manner (Stack) Nesting of Functions Functions may be nested. The main function may call function1, which in turn call function2, which may call function3.

Passing Arguments A function is referenced by its name and providing appropriate values for the arguments. On seeing the name of the function in calling statement, the control is immediately transferred to the function. The parameter values are substituted and the function is executed. When the return statement is encountered, control is transferred back to the called function, along with the value returned. Depending on its definition, functions may be classified as:

Functions with no arguments & no return value

Functions with no arguments but return value

Functions with arguments but no return value

Functions with arguments and return value



Example 9.8 No Arguments and no return value

No arguments but return value

main()

main()

{

{

border();

int sum;

printf(“\t\t Hello World\n””)

sum=add();

border();

printf(“\nSum = %d”,sum);

}

}

border()

add()

{

{

int i;

int a,b;

for(i=1;i<=80;i++)

scanf(“%d%d”, &a,&b);

printf(“-“);

return(a+b);

printf(“\n”);

}

return; }

Example 9.9 With arguments and no return value return value

With

arguments

main()

main()

{

{

int n; char c;

int sum,a,b;

printf(“Enter the size of border & style\n”); integers\n”); scanf(“%d%c”, &n,&c);

printf(“Enter2

scanf(“%d%d”,&a,&b);

border(n,c); printf(“\t\t Hello World\n””)

and

sum=add(a,b); printf(“\nSum = %d”,sum);

border(n,c); }

}

border(int m, char s)

add(int x,int y)

{

{

int i; for(i=1;i<=m;i++)

return a+b ; }

printf(“%c“,s); printf(“\n”); return; }



Passing arguments to a Function: There are two approaches to pass the information to a function via arguments. They are:

Call by Value

Call by Reference

Call by Value Arguments are usually passed by value in C function calls. The values of the actual arguments are copied in to the respective formal arguments. Actual and formal arguments refer to the different memory locations and the value of actual argument is copied into the formal argument. So, any changes made to the formal argument are not reflected in their corresponding actual arguments. The value of the actual argument will remain same. aÆx

a is actual argument and x is formal argument.

Example 9.10: Program that illustrates call by value mechanism main() { int a, b; a=10; b=20; swap(a, b); /* passing the values of a and b to c and d of swap function */ printf(“%d %d”, a, b);

/* prints 10 20 */

} void swap(int c, int d) /*Function used to swap the values of variables c and d*/ { int temp; temp = c; c = d; d = temp; } Call by Reference In this approach, the addresses of actual arguments are passed to the function call and the formal arguments will receive the address. The actual and formal arguments refer to the same memory location. So, changes in the formal arguments are reflected in actual arguments. Note: Actual arguments are address of the ordinary variable, pointer variable or array name. Formal arguments should be a pointer variable or array. This approach is of practical importance while passing arrays to functions and returning back more than one value to the calling function. Passing arrays to functions is call by reference by default.



a

x a is actual argument and x is formal argument.

Example 9.11: Program that illustrates call by reference mechanism main() { int a, b; a=10; b=20; swap(&a, &b); /* passing the addresses of a and b to c and d of swap function */ printf(“%d %d”, a, b);

/* prints 20 10 */

} void swap(int *c, int *d)

/* reference is made */

{ int temp; temp = *c; *c = *d; *d = temp; }

Functions and Arrays It is possible to pass an entire array to a function. To pass an array to a function, it is enough to give the name of the array as argument. Array name is interpreted as base address of the array and the address is given to the formal argument. Formal argument can be an array or pointer variable, which points to an array. Example 9.12 int

maximum( int val[] )

/*size of the array need not be mentioned */ { int

max_value, i;

max_value = val[0]; for( i = 0; i < 5; ++i ) if ( val[i] > max_value ) max_value = val[i]; return max_value; } main() { int values[5], i, max; printf("Enter 5 numbers\n");



for( i = 0; i < 5; ++i ) scanf("%d", &values[i] ); max = maximum(values); /* array name is used to pass an entire array without any subscripts */ printf("\nMaximum value is %d\n", max ); } Passing Multidimensional Arrays Multi dimensional arrays can also be passed in the same manner as single dimensional array, but care must be taken in representing the formal arguments. Example 9.13 void print_table(int xsize,int ysize, float table[][5]) { int x,y; for (x=0;x


Try It Out 1. Problem Statement: Write a program to print out first 10 numbers in descending order using recursive function

Code: #include void recurse(int i); void main(void) { recurse(0); getchar(); } void recurse(int i) { if (i<10) { recurse(i+1); printf("%d ",i); } } Refer File Name: to obtain soft copy of the program code

How It Works:

This program explains about how to write recursive function

The main program calls the recurse function with value 0 as argument

In the recurse function, the value is increment and the recurse function is called again. This time it passes 1 as argument.

Again in the next step value will be incremented and the recurse function is called.

This continues till the value passed is less than 10.

Once it is equal to 10, it start printing the value of i. First it will print the value of 10, then it returns from the function and again prints the value as 9 and returns back.

This continues till all the function call is completed.

Hence the 10 numbers will be printed in descending order.



2. Problem Statement: Write a program to have functioning returning a value

Code: /* function that returns value*/ #include #include int getval(void); int main() { int weight; weight=getval(); printf("Entered value is %d\n",weight); getchar(); return(0); } int getval(void) { char input[20]; int x; printf("some integer:"); gets(input); x=atoi(input); return(x); } Refer File Name: to obtain soft copy of the program code

How It Works:

The main program calls the getval() function.

In getval() function, prompts the user to enter some number.

It reads the input value and converts to integer form .

Then returns the integer value.

The main program then prints the value on the screen.



Summary

Functions are smaller self-contained components which carry out some specific, well defined task.

Functions facilitates reusability and brings logical clarity to the programs.

C functions should be considered with three aspects: i) function definition, ii) function call, iii) function prototyping

Arguments can be passed to a function via call by reference method or by call by value method.

Arrays can be passed to a function by simply specifying its name.

A function calling itself is called recursion.

C supports four storage class specifiers (auto, static, extern and register) to define scope and life time for the variable.

The command line arguments, argc and argv are used to pass arguments to main() function.

Test your Understanding 1. What is function prototyping? 2. What is relationship between the actual parameters and its formal parameters? 3. What is the output of the following code? main() { int a =4; { int a = 3; printf(“ %d “ , a); } printf(“%d” , a); } 4. What is the difference between call by reference and call by value? 5. What is the output of the following code? main() { int i=10; fn(i); printf("%d",i); } fn(int i) { return ++i; }



6. What the following declaration statements imply? a. int p(char *a) b. int *p(char *a) c.

int (*p)(char a)

d. int *p(char *a[]) 7. How main() function is called with parameters?

Answers: 1. Function prototyping is like a function declaration statement which informs the compiler about the function (its name, type of its arguments, return data type). In C, it is needed only when the function is called prior to its definition. 2. a. There must be a one-to-one correspondence between the actual and formal parameters. b. Corresponding parameters must be of same type. 3. 3 4 4. In call by reference, address of the actual parameters are passed to corresponding formal parameters but in call by value, only the values of the actual parameters are copied in to corresponding formal parameters. 5.

10

6. a) p is a function which receives a character pointer and returns an integer value b) p is a function which receives a character pointer and returns an integer pointer c) p is a pointer (function pointer) which can point to any function with character argument and integer return value. d) p is a function whose argument is an array of pointers. 7. Using command line arguments.



Session 10: Functions/Structures and Unions Learning Objectives After completing this session, you will be able to:

Use different storage classes in a program

Use command line arguments

Explain the concept of structures and unions

Explain how to declare and initialise Structure

Perform operations on structures

Perform operation on structures and arrays

Perform operation on Structures and functions

Storage Classes Variables in C can be characterized by their data type and storage classes. Data type refers to the type of information represented by a variable and storage classes define its life time and scope. Scope The scope of the variable (where it can be used), is determined by where it is defined. If it is defined outside of all the blocks, it has file scope. This means, it may be accessed anywhere in the current source code file. This is normally called a global variable and is normally defined at the top of the source code. All other types of variables are local variables. If a variable is defined in a block (encapsulated with {and}), its scope begins when the variable is defined and ends when it hits the terminating. This is called block scope. Life Time Life time refers to the permanence of a variable – How long the variable will retain its value in memory. General Form: storage-class-specifier type-specifier variable-names,... The storage-class-specifier can be any one of the following:

auto

static

register

extern



Automatic variables (Auto storage class) Automatic variables are local (visible) to the block in which they are declared. If the variable is declared within a function, then its scope is confined to that function. Local variables of different functions/blocks may have the same name. It retains its value till the control remains in that block. When the execution of the block is completed, it is cleared and its memory destroyed. Whenever the control again comes to the same block new memory location will be allocated to those variables. They are local or private to the function in which they are declared. Because of this property, they are also called local or internal variables. If not initialized in the declaration statement, their initial value will be unpredictable (garbage value). If no storage class is specified, by default it is an auto variable. Example 10.1 main() { int a = 5 ; { int a =6 ; printf (“%d “ , a);

Æ

prints

6

} printf(“ %d “ , a);

Æ prints 5

} One important feature of automatic variables is that their value cannot be changed by whatever happens in some other function in the program. A variable local to the main function will be normally alive throughout the whole program, although it is active only in main(). In the case recursive functions, the nested variables are unique auto variables, a situation similar to function nested auto variables, with identical names. Static variables (static storage class) Static variables are also local (visible) to the block in which the variable is declared. They retain the values throughout the life of the program. Once allocated, memory will be de-allocated after the completion of the program execution. So, it will retain the value between function calls. If not initialized in the declaration, it is automatically initialized to zero. Static variables are stored in memory. A static variable may be either internal (local) or external (global). Internal variables are those declared inside a function (or block). The scope is only to the function in which it has been declared but the variable exists in the memory throughout the entire life of the program .Thus, internal static variables retain values between function calls.



Example 10.2 main() { int i; for (i=1;i<=5;i++) incre(); } incre() { static int x = 0; x = x +1; printf(“ x = %d\n”,x); } Output: x = 1 x = 2 x = 3 x = 4 Register variables (register storage class) It is possible to inform the compiler that a variable should be kept in one of the registers, instead of keeping it in the memory. Since registers are faster than memory, keeping the frequently accessed variables like a loop control variable in a register will increase the execution speed. Since the registers are less in numbers, careful selection must be made for their use. If the declaration of register variable exceeds the availability, they will be automatically converted into non register variables (automatic variable). Register variables are local (Visible) to the block in which they declared. It retains its value till the control remains in that block. If not initialized in the declaration, the variable is initialized to zero. External variables (extern storage class) External variables are not confined to a single function. Their scope extends from the point of definition through the remainder of the program. They are referred to as global variables. Access to variables outside of their file scope can also be made by using linkage. Linkage is done by placing the keyword extern prior to a variable declaration. This allows a variable that is defined in another source code file to be accessed. External variables can be accessed from any function and the changes done by one function will be reflected through out the entire scope. When using external variables, we must distinguish between:

External Variable Definition

External Variable Declaration



If not initialized in the declaration, it is initialized to zero. External variables are useful when working with multiple source files. Example 10.3 int a = 5 ; /* external variable definition (No need to use extern keyword) */ main() { extern int b; /* external variable declaration, just to say that the variable is declared somewhere else in the same program or other programs. */ void fun(); fun(); printf(“ %d “ , a);

/*

prints 10 */

printf(“ %d “ , b);

/*

prints 20

*/

} void fun() { a = 10 ; } int b = 20; External variable declaration can not have initialization. extern int a = 10; Æ invalid

Command Line Arguments Depending on the operating system and programming environment, a C program can be executed either by selecting an icon from a graphical user interface or by entering a command in a command window (DOS or UNIX command window). It is usually easier to write programs that are run by entering a command in a command window. When a command is entered in a command window, it is executed by a command-line interpreter. The operation of a command interpreter is quite complex, but as a first approximation, interpreter breaks up a command into words separated by spaces. The first word is treated as the name of a program. The interpreter searches for the program and starts it executing with the command words passed as arguments. A C program is executed by calling its main() function. The function is called with one integer argument that indicates how many words are in the command line and another argument that is a character array of pointers containing the command line words.



main ( int argc, char *argv[]) { : } Where:

argc provides a count of the number of command line argument

argv is an array of character pointer of undefined size that can be thought of as an array of pointer to strings, which are command line strings.

Example 10.4 main( int argc, char* argv[]) { int i; printf(“\n Total Number of Arguments = %d”,argc); for( i = 0; i < argc; i++) printf(“\nArgument number %d = %s”,i , argv[i]); } When the following command is given in the command prompt, C:\tc\bin> CMLPGM c cpp java arguments)

(CMLPGM

Æ

program

name,

c

cpp

java

Æ

The following result is displayed Number of Arguments = 4 Argument number 0 = CMLPGM Argument number 1 = c Argument number 2 = cpp Argument number 3 = java

Introduction to Structures and Unions Structures and Unions are the main constructs available in C by which programmers can define new data type. Structures and unions provide a way to group together logically related data items. Structure Structure is a derived data type used to represent heterogeneous data items. A structure is an aggregation of components that can be treated as a single variable. The components are called Members. For example, an employee is represented with the following attributes: employee code (string / integer), employee name (string), department code (string), salary (float).



Declaration and Initialization Declaration C provides facilities to define structures via a template and to declare a tag to be associated with such structures so that it is not necessary to repeat the definition. “struct” keyword is used to define structures. General form: struct tag_name { type variable-name, type variable-name, type variable-name, : : type variable-name, };

variable-name,........; variable-name,........; variable-name,........;

variable-name,........;

Structure-variables can be declared separately by specifying: struct tag_name new-structure-variable; When declaring structure variables, a separate instance of structure will be created with the name specified and memory will be allocated for that. Individual members will be given a separate memory location. Structure definition and declaration of structure variables can be combined together. Here, tag name is optional. Note: If tag name is not specified in the declaration, no extra structures can be created. Example 10.5 1)

struct employee { int code; char name[20]; int dept_code; float salary; } ; struct

employee

emp1, emp2;



2)

struct employee

(tag name is optional here)

{ int code; char name[20]; int dept_code; float salary; } emp1, emp2;

Initialization Structure variables can be initialized at the time of declaration. The format used is quite similar to initializing an array. If the structure variable is declared before the main function in the global declaration section, the member variables are automatically initialized to zero or Null depending on the data type of the member variable. If it is partially initialized, uninitialized members are assigned zero or Null. Example 10.6 struct

stud

{ int rollnum; char name[20]; int semester; float avg; }; struct stud stud1={101,”Dina”, 1, 90.78}, stud2={102, “Raja”,

1};

For the structure variable ‘stud2’, the ‘avg’ will be initialized to 0.0 Individual structure members can be initialized only via structure variable. No storage class can be specified for structure members. struct employee { int empno = 101 ;

Æ illegal;

static char[20] empname = “AAAA”;

Æ illegal;

} Accessing the members Members of the structure can be accessed by using the member access operator “.”(dot). If ‘s’ is a structure variable with a member named ‘m’, then the expression “s.m” refers to the value of the member ‘m’ within the structure ‘s’.



General Form: struct_vble . member-field-name Example 10.7 emp1.code emp1.name emp1.dept_code emp1.salary emp2.code emp2.name Operations on Structures Two structure variables cannot be compared for equality, even though the values stored in the member variables are same. This is because, slack bytes are added in-between two member variables and these slack bytes have garbage value. While comparing structure variables, the values in slack bytes are also compared, which is always not same for different structure variables. Assignment operation is allowed. For example, if ‘a’ and ‘b’ are two structure variables of the same structure type, the assignment expression a = b is valid. It causes each member of ‘a’ to be assigned the value of the corresponding member of ‘b’. sizeof() operator can be used to find the size of the structure. Example 10.8 struct emp { int empno; char name[20]; float basic; } emp1; printf (“Size = %d”,sizeof(emp1));

Size = 26

Nested Structure Just as arrays of arrays, structures can contain members that themselves are structures. This can be a powerful method to create complex data types. Note: Member structure must be defined prior to its use. Example 10.9 struct

date

{ int day; int month; int year; };



struct employee { int code; char name [20]; struct date doj; int dept_code; float salary; }emp1,emp2; In this example, if we want to access the year of joining of an employee of emp1, then we can do so by writing: emp1.doj.year

Structures and Arrays A structure can be a array of structure and the members of structures can be arrays. Example 10.10 Array of structures struct stud { int rollnum; char name[20]; int semester; int avg; }; struct stud

student[50];

Accessing values: student [1].rollnum student [1].name student [1].semester student [1].avg

Example 10.11: Arrays within structures struct student-mark { int rollnumber; char name[15]; int sub_marks[5]; }student; Accessing values: student.sub_marks[0]

student.sub_mark[1]

};



Structures and Functions Structures can be passed to a function via call by value and call by reference methods. When the structure variable (which not a pointer) is passed as an argument to a function, it is passed using call by value method. All the members are copied into corresponding formal arguments. But changes will not be reflected back. Example 10.12 struct emp { int empno; char empname[10]; }; main( ) { void display(struct emp); struct emp emp1 = { 101 , “AAAA”} ; display(emp1); } void display(struct emp emp2) { printf(“ %d “ , emp2.empno); printf(“ %s “ , emp2.empname); } Entire structure can be passed to a function using call by reference method. We can use pointer to structures, or we can pass address of the structure variable using & operator. Example 10.13 struct emp { int empno; char empname[10]; }; void main( ) { void change(struct emp *); struct emp emp1 = { 101 , “AAAA”} ; change(&emp1); printf(“%d” , emp1->empno);

/* prints

102 */



} void display(struct emp *emp2) { emp2->empno=102; } Function can return a structure type struct_name = fun_name (struct_vble_name); Function should be declared and defined as: struct tag_name fun_name( struct tag_name struct_vble_name, …) Example 10.14 emp1 = emp_pay (wage, x, y);

Æ wage is a structure variable of sal structure. Æ emp1 is a structure variable of employee structure.

struct employee emp_pay (struct sal pay, int a, float b) { } Æ function definition

Try It Out Problem Statement: Write a program to access the members of structure

Code: #include struct student { char name[20]; float marks; } student1, student2; int main ( ) { struct student student3; strcpy(student1.name,"Tom"); student2.marks = 99.9; printf (" Name is %s \n", student1.name); printf (" Marks are %.2f \n", student2.marks); getchar(); } Page 89 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


Refer File Name: to obtain soft copy of the program code

How It Works:

Declare student structure comprising of name and marks.

In the main program assign values to both member of structure.

Print the values of the structure.

Summary

Structure is a derived data type used to store heterogeneous data items under a single unit.

Structure members can be accessed by structure variables using dot ( . ) operator.

Structures can be nested and can also have self reference.

Structure can be passed to a function by both call by value approach and call by reference approach.

Unions are similar to structures but the main difference is that union members share the common memory location whereas memory is allocated to individual structure members.

In unions, only one member is accessible at a time.

enum keyword is used to define enumerations.

typedef statement is used to define new data types which are compatible with existing ones.

Test your Understanding 1. What distinguishes an array from a structure? 2. What is a self referential structure and where can it be used? 3. Consider the following structure, struct { int a; int *p; }*p1; How can the content pointed by member pointer p be accessed via structure variable p1?



4. What will be the result when the following code is executed? struct stud_type { int rollno; char name[15]; int age; }; union person { char surname[10]; struct stud_type s1; }ex; printf(“Size = %d”, sizeof (ex));

Answers: 1. The elements of an array are always of the same type, whereas the members of a structure can be of different types. 2. Self referential structures will contain a member that is a pointer to the parent structure type. It is very useful in applications that involve linked data structures. 3. *p1->p; 4. Size = 19



Session 14: Structures and Unions / Files and Preprocessor directives Learning Objectives After completing this session, you will be able to:

Explain how to declare and initialise Unions

Perform operations on unions

How to use typedef statement

How to declare and use enumeration data type

Explain the concept of file and its types

Perform basic file operations

Perform formatted, unformatted, and block file I/O operations

Unions Union, like a structure, is a derived data type. Unions follow the same syntax as structures. The programmer is responsible for interpreting the stored values correctly. Union differs from structure in storage and in initialization. Declaration The declaration can be thought of as a template - it creates the type, but no storage is allocated. In the declaration, keyword ‘union’, the tag name, and the members of the union are given. The tag name, along with the keyword ‘union’, can be used to declare variables of the union type. For each variable, the compiler allocates a piece of storage that can accommodate the largest of the specified members. General Form: union tag_name { type variable-name, variable-name,........; type variable-name, variable-name,........; type variable-name, variable-name,........; : : type variable-name, variable-name,........; }union-variable, union-variable...... ; Initialization Union can be initialized only with a value for the first union member. No other member can be initialized.



Example 14.1 union item { int m; float x; char c; }; static union item product = {100}; /* m will be initialized with 100 */ Accessing the member of union The notation used to access a member of a union is identical to that used to access member of a structure. The dot operator (.) is used to access the members. Union permits a section of memory to be treated as a variable of one type on one occasion, and as a different variable of a different type on another occasion. Thus, only one member variable can be accessed at a time.

Union of Structures Structures and unions can be members of structures and unions. Example 14.2

Union of Structures

struct employee_type { int code; char name[20]; int dept_code; float salary; }; struct stud_type { int rollno; char name[15]; int age; float avg; }; union

person

{ char surname[10]; struct employee_type e1; struct stud_type

s1;

}ex;



In the above example, the union allows the structure variables, e1 and s1, to share common memory. That is, the user can use either e1 or s1, but not both, at the same time. The elements of this union of structures are accessed using dot operator as follows: ex.e1.salary

Enumeration Enumeration is a derived data type, similar to structures or a union. Its members are constants that are written as identifiers, though they have signed integer values. These constants represent values that can be assigned to corresponding enumeration variables. “enum” keyword is used to declare enumerated variables. General Form: enum tag { member1 , member2 ,

…… member n } ;

tag is a name that identifies enumerations having this composition and members represent the identifiers that may be assigned to variables of this type. The member names must differ from one another. Enumerated variables can be declared as follows: storage-class enum tag var1 , var2 , …………… var n; As structures, definition and variable declaration can be combined. Example 14.3 enum escapes { bell = `\a', backspace = `\b', tab = `\t’, newline = `\n', vtab = `\v', return = `\r'} main() { enum escapes e1; e1 = getch(); if (e1 == newline) printf("newline"); } Enumeration variables can be processed in the same manner as other integer variables. As with arrays, first enumerated name has index value 0, next value is calculated as previous plus one. We can also override the 0 start value by assigning some other value. enum colors { red = 1 , blue = 5 ,

green }

Here, green takes the value 6.



Typedef Statement The ‘typedef’ allows users to define new data types that are equivalent to existing data types. It is used to give new names to existing data types. General Form typedef

datatype new-type;

Example 14.4 typedef numbers int; numbers is the new name given to integer data type and it can be used to declare integer variables. numbers n1, n2 ;

n1 , n2 are the

integer variables. typedef is mostly useful with structures and unions. Example 14.5 typedef

struct

{ int empno; char empname[10]; }employee;

employee is the name given to the structure of the above type. Then structure variables can be declared as follows, employee emp1, emp2;

Æ no need to use struct keyword.

Introduction to Files When a large volume of data is involved, supplying data through the keyboard during the execution or displaying the output on the screen is not convenient. The input data can be stored on disks and the program may access the data from disks for processing. Similarly, the results may be stored on disks. For such applications, files are needed. A file is a place on the disk where a group of related data is stored. In C, file manipulations may be done in two ways:

Low-level I/O using system calls

High-level I/O using functions from standard I/O library

The files accessed through the library functions are called Stream Oriented files and the files accessed with system calls are known as System Oriented files.

Streams and Files Page 95 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


Streams facilitate a way to create a level of abstraction between the program and an input/output device. This allows a common method of sending and receiving data amongst the various types of devices available. There are two types of streams: text and binary. Text streams are composed of a set of lines. Each line has zero or more characters and is terminated by a new line character. Text streams consist of printable characters, the tab character, and the new-line character. Conversions may occur on text streams during input and output. Spaces cannot appear before a newline character, a text stream removes these spaces even though implementation defines it. A text stream, on some systems, may be able to handle lines of up to 254 characters long (including the terminating new line character). Binary streams are composed of only 0’s and 1’s. It is simply a long series of 0’s and 1’s. More generally, there need not be a one-to-one mapping between characters in the original file and the characters read from or written to a text stream. But in the binary stream there will be one-to-one mapping because no conversion exists, and all characters will be transferred as such. When a program begins, there are three available streams:

Standard input (stdin) is the stream where a program gets its input data

Standard output (stdout) is the stream where a program writes its output data.

Standard error (stderr) is another output stream typically used by programs to output error messages.

File Operations Files are associated with streams and must be open in order to use it. The point of I/O within a file is determined by the file position. When a file is opened, the file position points to the beginning of the file unless the file is opened for an append operation - in which case the position points to the end of the file. The file position indicates where the next operation (read/write) will occur. When a file is closed, no more actions can be taken on it until it is opened again. Exiting from the main function causes all open files to be closed. In C, ‘FILE’ is a structure that holds the description of a file and is defined in stdio.h.

Basic File operations are:

Opening a File

Reading from and/or writing into a File

Closing the File Page 96 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


The logic is, the code must:

define a local ‘pointer’ of type FILE ( called file pointer )

‘open’ the file and associate it with the file pointer via fopen()

perform the I/O operations using file I/O functions ( ex. fscanf() and fprintf() )

disconnect the file from the task using fclose()

General form: FILE *fp; fp = fopen(“name”, “mode”); fscanf(fp, "format string", variable list); fprintf(fp, "format string", variable list); fclose(fp ); Where:

The ‘fp’ is a file pointer or file handler.

The ‘name’ is to represent filename and it is a string of characters. (Extensions can be specified like test.c, details.dat etc)

The ‘mode’ argument in the fopen() specifies, the purpose/positioning of opening the file. It is a string enclosed within double quotes.

The ‘mode’ can be any of the following: r

read text mode

w

write text mode (truncates file to zero length if it already exits or creates new file)

a

append text mode for writing (opens or creates file and sets file pointer to the end-of-file)

rb

read binary mode

wb

write binary mode (truncates file to zero length if it already exits or creates new file)

ab

append binary mode for writing (opens or creates file and sets file pointer to the end-of-file)

r+

read and write text mode

w+

read and write text mode (truncates file to zero length if it already exists or creates new file)

a+

read and write text mode (opens or creates file and sets file pointer to the end-of-file)



r+b or read and write binary mode rb+ w+b or read and write binary mode (truncates file to zero length if it already exists or creates new wb+ file) a+b or read and write binary mode (opens or creates file and sets file pointer to the end-of-file) ab+ If the file does not exist and it is opened with read mode (r), the file open fails and it will return NULL to file pointer. If the file is opened with append mode (a), all write operations occur at the end of the file regardless of the current file position. If the file is opened in the update mode (+), output cannot be directly followed by input and input cannot be directly followed by output without an intervening fseek(), fsetpos(), rewind(), or fflush().

fopen() returns the file pointer position for successful open and returns NULL, if the file does not open or the file does not exist.

fclose() returns zero for successful close and returns EOF (end of file) when error is encountered in closing a file. By default, all the files opened are closed when the program is terminated. It is good to close all the files opened with fopen(), because files can be reopened only if they are closed.

The Standard I/O provides variety of functions to handle files. It supports the following ways of reading from and writing into file:

Character I/O

String I/O

Formatted I/O

Block I/O

Integer I/O

Character I/O Using character I/O, one character (byte) can be written to or read from a file at a time.

Writing in to a file To write into a file, the file must be opened in ‘w’ mode The function putc() is used to write a byte to a file.



General Form: putc(ch,fptr); This function writes the character ch into a file pointed by the file pointer fptr. This fptr may be stdout, which represents standard output device, monitor as a file. On success, the character is returned. If an error occurs, the error indicator for the stream is set and EOF is returned. Example 14.6: Program to create a text file (character file) main() { FILE *fp; char c; if ((fp=fopen(“sample.dat”,”w”)) !=NULL) { while ((c=getchar()) != EOF) putc(c,fp); fclose(fp); } else printf(“Error in opening a file”); }

Reading from a file The function getc() is used to read a byte from a file. This may be a macro version of fgetc. General Form: ch =getc (fptr); This function reads a character from the file and it is returned to the program defined character variable. After the reading a character, the pointer is moved to the next position. The fptr may be stdin, which represents a standard input device, keyboard as a file. On success, the character is returned. If the end-of-file is encountered, EOF is returned and the end-of-file indicator is set. If an error occurs, the error indicator for the stream is set and EOF is returned. The EOF is end of file status flag, which is true if end of file is reached, otherwise false.

Example 14.7:

Program to read a character data from a text file

main() { FILE *fp; char c; if ((fp=fopen(“sample.dat”,”r”)) !=NULL) { while ((c=getc(fp)) != EOF) Page 99 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


putchar(c); fclose(fp); } else printf(“Error in opening a file”); }

String I/O Using string I/O, string can be written to, or read from, a file at a time.

Writing a string in to a file The function used is fputs(). Writes a string to the specified stream till the last character is read but does not include the null character. On success, a nonnegative value is returned. On error, EOF is returned.

General Form: fputs (str, fptr);

Reading a string from a file The function used is fgets(). Reads a line from the specified stream and stores it into the string pointed to by str. It stops when (n-1) characters are read, the newline character is read, or the endof-file is reached, whichever comes first. The newline character is copied to the string. A null character is appended to the end of the string. On success, a pointer to the string is returned. On error, a null pointer is returned. If the end-of-file occurs before any characters have been read, the string remains unchanged.

General Form: fgets(str,n,fptr);

Numeric I/O Using numeric I/O, integers can be written to, or read from, a file at a time. Writing integer in to a file The function used is putw(). This function writes an integer to a file. On success, a nonnegative value is returned. On error, EOF is returned. General Form: putw (i, fptr);



Reading integer from a file The function used is getw(). Reads an integer from the file and assigns it to the program defined numeric variable at the LHS. General Form: i = getw( fptr);

Formatted I/O The formatted I/O functions can handle a group of data in a single call.

Writing formatted data to a file The function fprintf() is used. This function will write the values stored in the variables into a file pointed by fptr, according to the format specifier specified in format string. On success, the number of characters printed is returned. If an error occurred, -1 is returned. General Form: fprintf ( fptr, format-string, variable-list); The fprintf() function takes the format string specified by the format argument and applies each following argument to the format specifiers in the string, in a left to right fashion. Each character in the format string is copied to the stream except for conversion characters which specify a format specifier.

Reading formatted data from the file The function used is fscanf().This function will read the formatted data from the file pointed by fptr, as specified by the format specifiers in format-string and stores in the variables, whose addresses are given in addresses-list. Reading an input field (designated with a conversion specifier) ends when an incompatible character is met, or the width field is satisfied. On success, the number of input fields converted and stored is returned. If an input failure occurs, EOF is returned. General Form: fscanf( fptr, format-string, addresses-list);

The fscanf() function takes input in a manner that is specified by the format argument and stores each input field into the corresponding arguments, in a left to right fashion.

Each input field is specified in the format string with a conversion specifier which specifies how the input is to be stored in the appropriate variable. Other characters in the format string specify characters that must be matched from the input, but are not stored in any of the following arguments. If the input does not match, the function stops scanning and returns. A white space character may match with any white space character such as space, tab, carriage return, new line, vertical tab, or form feed, or the next incompatible character.



Example 14.8: Program using fscanf() and fprintf() main() { FILE *fpt; struct { int no; char name[10]; int age; }std[10], std1[10]; int i; clrscr(); fpt = fopen("details.dat" , "w"); printf("\n\n enter the details (no , name , age )\n\n"); for(i=0; i<5 ;i++) { scanf("%d %s %d " , &std[i].no , std[i].name , &std[i].age); fprintf(fpt , "%d %s %d " , std[i].no , std[i].name , std[i].age); } fclose(fpt); fpt = fopen("details.dat" , "r"); printf("\n\n reading from file \n\n"); while(!feof(fpt)) { fscanf(fpt , "%d ,&std1[i].age);

%s %d " , &std1[i].no , std1[i].name

printf("%d %s %d \n" , std1[i].no , std1[i].name , std1[i].age); i++; } }

Block I/O Block I/O is used to read or write a specified number of bytes. The data handled by block input/output function will be in ‘raw data format’ (i.e. bytes of data).

Writing in to a file The function used is fwrite().Transfers a specified number of bytes beginning at a specified location in memory to a file. Used to write a structure or an array of structures to an output file. The function writes data from the array pointed to by ptr to the given stream. It writes ‘n’ blocks of size Page 102 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


‘size’. The total number of bytes written is (size*n). On success the number of elements written is returned. On error the total number of elements successfully written (which may be zero) is returned. General Form fwrite (ptr, size, n, fp); Where:

ptr Æ pointer to the data block (source)

size Æ size of each block (number of bytes to be written)

n

fp

Æ number of blocks to be written Æ file pointer (destination)

Reading from a file The function used is fread(). Reads data from the given stream into the variable pointed to by ptr. It reads ‘n’ number of elements of size ‘size’. The total number of bytes read is (size*n). On success the number of elements read is returned. On error or end-of-file, the total number of elements successfully read (which may be zero) is returned. General Form fread (&str, size, n, fp); Where:

&str Æ destination memory address

size Æ size of each block (number of bytes to be read)

n

fp

Æ number of blocks to be read Æ file pointer (source)

Example 14.9: Program using Block I/O main() { FILE *fptr; struct tag { char name[10]; int age ; }stud[10] , stud1[10]; int i ; clrscr(); fptr=fopen("ex.dat" , "w" ); for(i=0 ; i<5 ; i++) scanf("%s %d ",stud[i].name , &stud[i].age); fwrite(&stud , sizeof(stud[0]) , 5 , fptr); fclose(fptr); fptr = fopen("ex.dat" , "r" ); fread(&stud1 , sizeof(stud1[0]) , 5 , fptr); printf(" \n\n printing the values ");



for(i=0 ; i<5 ; i++) printf("\n %s \t %d " , stud1[i].name , stud1[i].age); }

Try It Out 1. Problem Statement: Write a program to find a word in a file.Print the line number and the line.

Code: /* findword.c */ #include #include /* #include */ FILE * inFile; // this will be the file I want to read main(int argc,char *argv[]) { char myString[256]; // This is where I read the lines of the file int count; // I will use this to count the lines of the file count = 0; // start at 0 lines counted so far inFile = fopen(argv[1], "r"); // open the file for reading only while (fgets(myString, 255, inFile) != NULL) // keep reading lines { // until I've seen them all count++; // after this command, count will equal the current line number if (strstr(myString, "name") != NULL) // check to see if 'drawline' printf("Line %d] %s",count, myString); // is in the current line and // if so, print it } fclose(inFile); // close the file I opened earlier getchar(); } Refer File Name: to obtain soft copy of the program code

How It Works:

Run the program by passing file that needs to searched as command line arguments.

In the main program, read the input argument.

Open the input file.

Read the first line of the file and increment the line count



compare the search key word say ”name” , if found print the line number and the full string.

Again read the next line in the file and do the same process.

Continue till all the lines in the file are processed.

Close the file and exit the program

2. Problem Statement: Write a program to print both members of union.

Code: //Output both value in a union #include union number { int x; double y; }; int main() { union number value; value.x = 100; printf( "%s\n%s\n%s%d\n%s%f\n\n", "Put a value in the integer member", "and print both members.", "int: ", value.x, "double:\n", value.y ); value.y = 100.0; printf( "%s\n%s\n%s%d\n%s%f\n", "Put a value in the floating member", "and print both members.", "int: ", value.x, "double:\n", value.y ); getchar(); return 0; } Refer File Name: to obtain soft copy of the program code

How It Works:

Declare a union having two members, one integer and the other double.

In the main program declare a variable of union datatype. Page 105 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


First assign the value of x as 100 and print both the members, x will print as 100 and y as 0

Next assign the value of y as 100 and print both the members, x will print as 0 and y as 100

Summary

Files are used to store bulk of related information in secondary storage.

Files can be classified as system oriented and stream oriented files.

fopen(), fclose() functions are used for opening and closing of files.

Input, Output operations on files can be of character I/O, string I/O, formatted I/O and block I/O.

Direct access of a file is supported by fseek(), ftell(), and rewind() functions.

Preproccessing is done before compilation.

Preprocessor directives are identified by # symbol.

Preprocessor directives perform i) macro substitution, ii) file inclusion and iii) conditional compilation.

Test your Understanding 1. What are the three files automatically associated with every C program? 2. What is the output of the following code? int main() { while(i<10) { fprintf(stdout,"hello-out"); sleep(1); i++; } return 0; } 3. What is EOF, and what value does it usually have? 4. What does the following statement specifies? fseek( fptr , 2L , 2)



5. What is the output of the following code? #define a 10 foo( ) { #undef a # define a 50 } main( ) { printf(“%d..”, a); foo( ); printf(“%d”,a );

}

Answers: 1. stdin, stdout, stderr 2. It will print hello-out in the monitor 10 times. 3. EOF is a constant returned by many I/O functions to indicate that the end of an input file has been reached. Its value on most computers is -1. 4. No significance, trying to move file pointer in the forward direction from the end of file. 5. 50 50



Session 15: Files and Preprocessor directives / Pointers Learning Objectives After completing this session, you will be able to:

Access files in both sequential and random order

Define pre-processor directives

Perform pre-processor operations

Perform conditional compilation

How to declare and initialise Pointers

Understand Pointer Arithmetic

Perform operations on Pointers and Arrays

Random File Operations The functions discussed earlier are to be used for reading and writing data sequentially. In some applications, it may be necessary to access some part of the file directly. This can be achieved by using the functions fseek(), ftell() and rewind().

ftell() This function takes a file pointer and returns a long int, which corresponds to the current file pointer position. If it is a binary stream, then the value is the number of bytes from the beginning of the file. If it is a text stream, then the value is a value usable by the fseek() function to return the file position to the current position. On success, the current file position is returned. On error, the value -1L is returned and error number (errno) is set. General Form: n = ftell(fptr);

fseek() This function sets the file position to the given offset (specified in long integer format). General Form: fseek( fptr, offset,

from_where)

The argument offset signifies the number of bytes to seek from the given ‘from_where’ position. The argument from_where can be:

Seeks from the beginning of the file.

0

SEEK_CUR Seeks from the current position.

1

SEEK_SET



SEEK_END Seeks from the end of the file.

2

On a text stream, from_where should be SEEK_SET and offset should be either zero or a value returned from ftell(). The end-of-file indicator is reset. The error indicator is NOT reset. On success, zero is returned. On error, a nonzero value is returned. Example 15.1 fseek (fp, 0L, 0);

Move the file pointer to the beginning.

fseek (fp, 0L, 2);

Move the file pointer to the end of file.

fseek (fp, 10L, 0);

Move after 10 bytes from the beginning.

fseek (fp, 10L, 1);

Move after 10 bytes from the current

fseek (fp, -10L, 1);

Move backward 10 bytes from the current

fseek (fp, -10L, 2);

Move backward 10 bytes from the EOF.

rewind() This function sets the file position to the beginning of the file of the given stream. The error and end-of-file indicators are reset.

General Form: rewind(fptr);

Preprocessor Directives One of C's most useful features is its preprocessor. Preprocessor directives are lines included in the code that are not program statements but directives for the preprocessor. These lines are always preceded by a pound sign (#). The preprocessor is executed before the actual compilation of code begins, therefore the preprocessor digests all these directives before any executable code is generated for the statements. Preprocessing is a step that takes place before compilation that lets you to:

Replace preprocessor tokens in the current file with specified replacement tokens.

Embed files within the current file

Conditionally compile sections of the current file

Generate diagnostic messages

Remove the blank lines in the program, change the line number of the next line of source and change the file name of the current file.

Remove comments from the source file.

A token is a series of characters delimited by white space. The white space allowed on a preprocessor directive may be the space, horizontal tab, vertical tab, form feed, or carriage return. The preprocessed source program file must be a valid C program.



Preprocessor directives begin with the # token followed by a preprocessor keyword. The # token must appear as a first character. The # is not part of the directive name and can be separated from the name with white spaces. A preprocessor directive ends at the new-line character unless the last character of the line is the \ (backslash) character. If the \ character appears as the last character in the preprocessor line, the preprocessor interprets the \ and the new-line character as a continuation marker. The preprocessor deletes the \ (and the following new-line character) and splices the physical source lines into continuous logical lines. No semicolon (;) is expected at the end of a preprocessor directive. Except for some #pragma directives, preprocessor directives can appear anywhere in a program.

Preprocessor Directives Name

Action

#

Null directive specifying that no action be performed.

#define

Defines a preprocessor macro.

#elif

Conditionally includes source text if the previous #if, #ifdef, #ifndef, or #elif test fails.

#else

Conditionally includes source text if the previous #if, #ifdef, #ifndef, or #elif test fails.

#endif

Ends conditional text.

#error

Defines text for a compile-time error message.

#if

Conditionally includes or suppresses portions of source code, depending on the result of a constant expression.

#ifdef

Conditionally includes source text if a macro name is defined.

#ifndef

Conditionally includes source text if a macro name is not defined.

#include Inserts text from another source file. #line

Supplies a line number for compiler messages.

#pragma Specifies implementation-defined instructions to the compiler. #undef

Removes a preprocessor macro definition.



Preprocessing Operations: Pre processing operations are mainly classifieds into 1) File Inclusion, 2) Macro substitution and 3) Conditional Compilation. Preprocessing will be done before compilation, compilation process operates on the preprocessor output, which is then syntactically and semantically analyzed and translated, and then linked as necessary with other programs and libraries. File Inclusion The #include directive allows external files to be added in to our source file, and then processed by the compiler. General Form: #include

OR

#include “header file”

The only difference between both expressions is the places (directories) where the compiler is going to look for the included file. If the file name is enclosed between angle-brackets <>, the file is searched in the directories where the compiler is configured to look for the standard header files. Therefore, standard header files are usually included in angle-brackets, while other user specificed header files are included using quotes. In the second case where the file name is specified between double-quotes, the file is searched first in the current working directory. In case that it is not there, the compiler searches the file in the default directories where it is configured to look for the standard header files. Example 15.2 #include #include “stdio.h” Preprocessor Macros: #define preprocessor directive is used to define a macro that assigns a value to an identifier. The preprocessor replaces subsequent occurrences of that identifier with its assigned value until the identifier is undefined with the #undef preprocessor directive, or until the end of the program source is reached, whichever comes first. There are two basic types of macro definitions that you can use to assign a value to an identifer:

Object-like Macros (Symbolic constants)

Replaces a single identifier with a specified token or constant value.



Function-like Macros

Associates a user-defined function and argument list to an identifier. When the preprocessor encounters that identifier in the program source, the defined function is inserted in place of the identifier along with any corresponding arguments.

Symbolic Constants The preprocessing directives #define and #undef allow the definition of identifiers which hold a certain value. These identifiers can simply be constants or a macro function. #define

General Form: #define symbolicvaraiablename value

Example 15.3 #define SIZE 10 #define NAME letters */

“xyz”

/* good practice is to use upper case

#undef:

General Form: #undef variablename

Example 15.4 #undef SIZE

Macros:

General Form: #define macroname(argument list) macrodefn

Example: #define sqarea(a) ((a)*(a)) main() { areaofsquare=sqarea(a); ….. }



Arguments in the macro definition are enclosed with parenthesis to avoid miscalculation. Continuation character for macro definition is \. There is no need for semicolon after the macro definition. Example 15.5 #define sqarea(a)

((a)*(a))

#define sqa(b) b*b #define add(a,b) ((a)+(b)); main() { areaofsquare=sqarea(a); /*

areaofsquare = (a) * (a); */

areaofsquare=sqarea(3); /*

areaofsquare = (3) *(3);

*/

areaofsquare=sqarea(3+4); /*

areaofsquare=(3+4)*(3+4); */

areaofsquare=sqa(3+4);

/*

areaofsquare=3+4*3+4;

addition=add(2,3);

/*

Æ(1) */

addition=(2)+(3);; Æ(2) */

} (1)

Æ miscalculation because of no parentheses

(2)

Æ two semicolons in macro expansion.

Conditional Compilation Directives: A preprocessor conditional compilation directive causes the preprocessor to conditionally suppress the compilation of portions of source code. These directives test a constant expression or an identifier to determine which tokens the preprocessor should pass on to the compiler and which tokens should be bypassed during preprocessing. The directives are:

#if

#ifdef

#ifndef

#else

#elif

#endif

The directives #ifdef and #ifndef allow conditional compiling of certain lines of code based on whether or not an identifier has been defined. For each #if, #ifdef, and #ifndef directive, there are zero or more #elif directives, zero or one #else directive, and one matching #endif directive. All the matching directives are considered to be at the same nesting level. General Form: #if constant_expression #else #endif OR #if constant_expression #elif constant_expression #endif



The compiler only compiles the code after the #if expression if the constant_expression evaluates to a non-zero value (true). If the value is 0 (false), then the compiler skips the lines until the next #else, #elif, or #endif. If there is a matching #else, and the constant_expression evaluated to 0 (false), then the lines between the #else and the #endif are compiled. If there is a matching #elif, and the preceding #if evaluated to false, then the constant_expression after that is evaluated and the code between the #elif and the #endif is compiled only if this expression evaluates to a nonzero value (true). Example 15.6 Check whether a variable is defined. If so, change the value of that variable to 1 after undefining it. #if define(NUMBER) #undef NUMBER #define NUMBER 1 #endif

# and ## operators # Æ causes the argument to be converted as a string enclosed within quotes. Example 15.7 #define name(x) #x main() { ….. printf(name(xyz));

/*

printf(“xyz”);

*/

/*

printf(“ssnsomca”);

…. } ## Æ concatenation operator Example 15.8 #define name(x,y) x##y main() { ….. printf(name(ssn,somca));

*/

…. }



Introduction to Pointers Pointer is a variable that contain the memory address of another variable. Pointers are one of the powerful and frequently used features of C, as they have a number of useful applications. Variables contain the values and pointer variables contain the address of variables that has the value. Variable directly references the value and Pointer variable indirectly references the value. Referencing a value through a pointer is called Indirection. Whenever a variable is declared, memory is allocated for the variable according to the data type specified. int a = 5 ;

Æ 2 bytes of memory is allocated for variable ‘a’

a

5

a – variable, 5 – value, 1000 – assumed as the address of a

1000

printf(“ Value = %d”, a); Æ prints the value 5 printf(“ Address of a = %u”, &a); Æ prints the address 1000

Declaration and Initialization A pointer variable is declared with an asterisk before the variable name. The type-specifiers determine that what kind of variable the pointer variable points to. Declaration General Form: data-type *pointer-name; C provides two operators, & and *, for pointer implementation.

& Î address operator. It is a unary operator that returns the address of its operand.

* Î Indirection or de-referencing operator. It returns the value of the variable to which its operand points.

* and & are inverse of each other.

Example 15.9 int x, *px; px = &x; x = 5 ; x

px 5

1000

Æ variables

1000

Æ values

3000

Æ addresses



Example 15.10 Now execute the following printf statements and observe the results. printf(“ x = %d “ , x);

Æprints 5

printf(” address of x = %d “ , &x);

Æprints 1000

printf (“ address pointed by pointer = %u”, px);

Æprints 1000

printf (“address of the pointer = %u”, &px);

Æprints 3000

printf (“content pointed by pointer = %d”, *px);

Æprints 5

Initialization Pointer variables should be initialized to 0, Null or an address. No other constant can be initialized to a pointer variable. Pointer variable of a particular data type can, hold only the address of the variable of same data type. Example 15.11 Valid and Invalid pointer assignments int a , b , *p = &a , *q = NULL; Æ valid. q = p; Æ valid

- both p and q is pointing to the memory location of variable a

b = &a; Æ invalid – ordinary variables cannot hold address. q = a; Æ invalid - cannot assign value to the pointer variable

Pointer Arithmetic Pointer Addition or subtraction is done in accordance with the associated data type. Æ adds 2 for every increment

int

char Æ adds 1 for every increment

float Æ adds 4 for every increment

long int Æ adds 4 for every increment

All the operations can be done on the value pointed by the pointer. The following operations can be performed on pointer variables:

A pointer variable can be assigned the address of an ordinary variable or it can be a null pointer.

A pointer variable can be assigned the value of another pointer variable.

An integer quantity can be added to or subtracted from a pointer variable.

One pointer can be subtracted from another pointer variable provided both are pointing to same array.

Two pointer variables can be compared.

The following are the illegal operations on pointers variables:

Two pointer variables can not be added.

Pointer variable can not be multiplied or divided by a constant.



Example 15.12: Pointer arithmetic int * ptr , i=5; ptr= &i;

Æ let ptr = 1000 (location of i)

ptr ++;

Æ ptr = 1002 (+2 for integers)

++*ptr or (*ptr)++ Æ increments the value of i by 1

Example 15.13: Pointer operations Legal operations p1 > p2 p1==p2

p1+2 p1-p2 (if p1, p2 points to same array)

Illegal operations p1/p2

p1*p2

p1+p2

p1/5

Pointers and Arrays Arrays Array is used to store the similar data items in contiguous memory locations under single name. Array addressing is in the form of relative addressing. Compiler treats the subscript as a relative offset from the beginning of the array. Array subscripting notation is converted to pointer notation during compilation, so writing array subscripting expressions using pointer notation can save compile time. Pointers Pointer addressing is in the form of absolute addressing. Exact location of the elements can be accessed directly by assigning the starting location of the array to the pointer variable. The pointer variable is incremented to find the next element.

C treats the name of the array as if it is a pointer to the first element. Thus, if v is an array, *pv is the same as v[0], *(pv+1) is the same as v[1], and so on.

Pointer pointing to an array Initialization To initialize a pointer variable, conventional array is declared and pointer variable can be made to point to the starting location of the array. Array elements are accessed using pointer variable.



General Form: pointer_variable = &array_name [starting index]; OR pointer_variable = array_name; Example 15.14 int a[5] = {1,2,3, 4,5} ptr = a ;

, *ptr

, i ;

Æ similar to ptr = &a[0];

Assume that array starts at location 1000 &a[0] = 1000

a[0] = 1

ptr + 0 = 1000

*(ptr+0)

= 1

&a[1] = 1002

a[1] = 2

ptr + 1 = 1002

*(ptr+1)

= 2

&a[2] = 1004

a[2] = 3

ptr + 2 = 1004

*(ptr+2)

= 3

&a[3] = 1006

a[3] = 4

ptr + 3 = 1006

*(ptr+3)

= 4

&a[4] = 1008

a[4] = 5

ptr + 4 = 1008

*(ptr+4)

= 5

Accessing value Example 15.15 printf (“%d “,*(ptr+i)); printf (“%d “,*ptr); printf (“%d “,*(a+i));

Æ displays the a[i] value Æ displays the a[0] value Æ displays the a[i] value

Accessing address Example 15.16 printf (“%u “, (ptr+i));

Æ displays address of a(i)

Pointers and Multi Dimensional Arrays As the internal representation of a multi dimensional array is also linear, a pointer variable can point to an array of any dimension. The way in which the pointer variable used, varies according to the dimension. General Form: ptr_vble = &array_name [starting index1]…[starting indexn]; OR ptr_vble = array_name; Example 15.17 int a[2][2] = {1,2,3,4} ,

*ptr ;

ptr = &a[0][0] ; Assume that the array starts at location 1000 &a[0][0] = 1000

a[0][0] = 1

ptr+0 = 1000

*(ptr+0) = 1

&a[0][1] = 1002

a[0][1] = 2

ptr+1 = 1002

*(ptr+1) = 2

&a[1][0] = 1004

a[1][0] = 3

ptr+2 = 1004

*(ptr+2) = 3

&a[1][1] = 1006

a[1][1] = 4

ptr+3 = 1006

*(ptr+3) = 4



If the pointer to the array is accessed with 2 subscripts, it results in a problem. For example, (p+0) + 1 Æ if it is used to represent 0th row and 1st column (p+1) + 0 Æ if it is used to represent 1st row and 0th column

and results in p+1.

So, multi dimensional arrays can be represented by pointer in the following two ways:

Pointer to a group of arrays

Array of pointers

Pointer to a group of arrays A two dimensional array, for example, is a collection of one dimensional array. Therefore, a twodimensional array is defined as a pointer to a group of one dimensional array and in the same way three dimensional arrays can be represented by a pointer to a group of two dimensional arrays. int a[3][2] can be represented by a pointer as follows: int (*p)[2] p is a pointer points to a set of one dimensional array, each with 2 elements. Note: First dimension need not be specified but the second dimension has to be specified. Here, a single pointer is used and it needs to know how many columns are there in a row. The following representations are used when a pointer is pointing to a 2D array:

ptr+i

is a pointer to ith row.

*(ptr+i)

refers to the entire row - actually a pointer to the first element in i th row.

(*(ptr + i) +j) is a pointer to jth element in ith row

*(*(ptr+i) + j)) refers to the content available in ith row, jth column

Accessing value Example 15.18 printf (“%d “,*(*(ptr + i) +j);

Æ displays the x(i,j) value

printf (“%d “,*(a[ i ] + j);


printf (“%d “,*(a + i)[ j ];


Example 15.19 main() { int i, j; int a[2][3]={1,2,3,4,5,6}; int *pa=&a[0][0]; for (i=0;i<2;i++) { for (j=0;j<3;j++) printf(“\t%d”,*(*(pa+i)+j));



printf(“\n”); } } Output: 1

2

3

4

5

6

Array of Pointers Multi dimensional array can also be expressed in terms of an array of pointers. int a[2][2] can be represented as int *ptr[2] Here, we have 2 pointers ptr[0], ptr[1] and each pointer can point to a particular row . Thus, only one indirection is enough to represent a particular element. Example 15.20 int a[2][2] = {1,2,3,4} , *ptr[2] ; ptr[0] = a[0]; /* ptr[0] is now pointing to the 0th row ( & a[0][0]) */ ptr[1] = a[1]; /* ptr[1] is now pointing to the 1st row ptr[0] + 0

= 1000

*(ptr[0] + 0)

=

1

ptr[0] + 1

= 1002

*(ptr[0] + 1)

=

2

ptr[1] + 0

= 1004

*(ptr[1] + 0)

=

3

ptr[1] + 1

= 1006

*(ptr[1] + 1)

=

4

( & a[1][0]) */

Example 15.21 (1)

*p[3]

declares p as an array of 3 pointers

(2)

(*p)[3]

declares p as a pointer to a set of one dimensional array of 3 elements

Pointers and Strings Character pointer is a pointer, which can hold the address of a character variable. Suppose, if we have a character array declared as: char name[30] = {“Data Structures”}; We can declare a character pointer as follows: char *p = NULL; Once the pointer is declared, the address of the array is assigned to this pointer. When an array is referenced by its name, it refers to the address of the 0th element. p = name;



The statement assigns the address of the 0th element to p. Now issue the following printf statements and check the output: printf(“Character output = %c\n”, *p); printf(“String output = %s”, *p); When a pointer variable is referred with the indirection operator, it refers the content of the address pointed by the pointer variable. The above printf statements produce the outputs as follows: Character output = D String output = Data Structures The reason for the output produced by the second printf statement is because of the %s format specifier, which will print the string till it encounters a ‘\0’ character. Pointer automatically gets incremented to the next location. Character-type pointer variable can be assigned an entire string as a part of its variable declaration. char *p = “string” ; int *p = {0,1,2,3} ;

Æ valid Æ invalid

Thus, string can be represented by either as a one-dimensional character array or a character pointer. An array of character pointers offers a convenient method for storing strings. Each pointer is used to represent a particular string. Conventional array declaration: char name[10][10]; Array of character pointers : char *name[10]; Ragged Arrays Consider the following array declaration. char names[3][10] = { “abcde”, “rstu”, “xyz”}; This array occupies 30 bytes and the row length is fixed. Instead of making each row a fixed number of characters, make it a pointer to a string of varying length. If the elements of array are string pointers, a set of initial values can be specified as part of the array declaration. char *name[4]

= { “A” , “AB” , “ABC” , “ABCD”} ;

An advantage is that a fixed block of memory need not be reserved in advance. The above statement allocates variable length block of memory and occupies only 14 bytes. It declares 4



pointers each pointing to a string. Thus, substantial saving in memory. Arrays of this type are referred as Ragged arrays (used only in the initialization of string arrays). In the above example, *(name + 1) will access the string AB * (name + 2) will access the string ABC *(*(name + i) +j) refers the jth character in ith string *(*(name+3)+3) refers D in the string “ABCD” Memory organization – String Pointers Example 15.22 (1) char *ps = “xyz”; pointer ‘ps’ is stored in 2 bytes and ‘ps’ contains the address of the string that requires 4 bytes. (2) char s[ ] = “xyz”; string ‘s’ is stored in 4 bytes. Pointer to a constant The address of a constant variable can be assigned to a pointer variable. The following example explains the pointer variable to a constant variable: Example 15.23 const int a=10; int *pa = &a; /* suspicious pointer conversion. Wise to avoid such assignments */ Variable ‘a’ is a constant variable. The value cannot be modified. Pointer variable ‘pa’ can take any other address and value of ‘a’ can be changed using pointer even though it is constant variable. Constant Pointer The pointer variable can be a constant. A pointer variable can take the address of a non-constant data and constant data. Constant pointer to non-constant data always points to the same memory locations and the data at that location can be modified through the pointer. Pointers variables that are declared ‘const’ must be initialized when they are declared. Example 15.24 int a; int *const pa = &a; Constant pointer to constant data always points to the same memory location and the data at that memory location cannot be modified.



Example 15.25 int b; const int * const pb = &b; Generic Pointer (void Pointer / Pointer to void) The type void * is used to declare generic pointers. The generic pointer can be made to point any data type. Type casting is not needed during address assignment. But it is needed, when dereferencing the content using void pointer, in order to know the size and value of the data item. Example 15.26 int a;

float b;

void *pab; pab=&a; *(int *) pab =100; pab=&b; *(float *) pab = 105.55;

Try It Out 1. Problem Statement: Write a program to change the value of variable through pointer

Code: //Change value of variable through pointer #include int main(void) { long num1 = 0; long num2 = 0; long *pnum = NULL; pnum = &num1; *pnum = 2; ++num2; num2 += *pnum; pnum = &num2; ++*pnum; printf ("\nnum1 = %ld num2 = %ld *pnum = %ld *pnum + num2 = %ld\n", num1, num2, *pnum, *pnum + num2); getchar(); Page 123 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


return 0; } Refer File Name: to obtain soft copy of the program code

How It Works:

This program gives a hands-on on usage of pointer.

First two integer variable num1 and num2 and a pointer to an integer are declared.

Initialize num1 and num2 to 0

Assign the address of num1 to pointer pnum. Then assign the value of 2 to pnum.

Then the value of num1 is 2.

Increment the value of num2, now the value of num2 is 1.

Then num2 equals the num2 _ value at pnum i.e, 1+2 = 3(value of num2)

Assign the address of num2 to pnum and do increment of value at pnum.

Now the value at pnum is 4 and num2 is 4.

Print all the values num1,num2,value at pnum

2. Problem Statement: Write a program to use array of pointers

Code: //In the pointer array, the array elements is the pointer. #include main(){ int *a[5]; int *b; int i1=4,i2=3,i3=2,i4=1,i5=0; int j; a[0]=&i1; a[1]=&i2; a[2]=&i3; a[3]=&i4; a[4]=&i5; printf("Address

Address in array

for(j=0;j<5;j++) { printf("%16u a[j],a[j],a[j]); }

%16u

Value\n");

%d\n",

printf("using pointer\n");



b = a; for( j=0;j<5;j++) { printf("value of elements %d %16lu\n",*b,*b,b); b++; } getchar(); } Refer File Name: to obtain soft copy of the program code

How It Works:

This program explains the usage of array of pointers.

Declare an array of integer pointers.

Each element of array is an pointer which holds the address of an integer varaiable.

Declare five integer variable and and store their address in the array.

Then print the value in the array by using array indices and using pointers.

See the difference.

Summary

Pointer is a variable which can hold the address of another variable.

& operator is used to refer the address of a variable and * operator is used for dereferencing the pointer.

Pointer can point to an array of any dimensions.

There are two ways to represent multi dimensional arrays by means of pointers: o Single pointer points to set of arrays o Array of pointers

Strings can easily be represented using pointer – Ragged arrays.

malloc(), calloc() functions are used to allocate memory dynamically.

free() function is used to de-allocate the memory.

Test your Understanding 1. State whether the following are true or false a. Pointer variable can only contain an address b. Address of the memory location can be assigned to ordinary variables c. Pointer can refer to the content of the memory location by & operator d. Size of the pointer variable is equivalent to the size of the data item it points. 2. What is the use of generic pointers?



3. What is the output of the following code? main() { int n[25]; n[0]=100; n[24]=200; printf("\n%d,%d", *n, *(n+24)+*(n+0) ); } 4. Given the following declaration: int a, *b = &a , **c = &b; What is the output of the following statements? a=4; **c=5; b = (int *)**c; 5. What is the output of the following code? main( ) { char *str1=”abcd”; char str2[]=”abcd”; printf(“%d %d %d”, sizeof(str1),sizeof(str2), sizeof(“abcd”)); } 6. Differentiate malloc() , calloc(). Answers: 1. True, false, false, false 2. Generic pointers (void pointers) can point to data items of any type. 3. 100, 300 4. The first statement assigns 4 to a. The second statement assigns 5 to the location pointed to by the location pointed to by c. Since c points to b, this is same as assigning 5 to the location pointed to by b. Since b points to a, this statement is equivalent to assigning 5 to a. The third statement castes **c, which is value of a, into type int *, assign the value to a. The result is meaningless, because values cannot be assigned to pointers. 5. 2 5 5 6. malloc(), calloc() will both allocate the memory dynamically, but the difference is calloc() will return a contiguous memory location and initializes it to 0.



Session 17: Pointers Learning Objectives After completing this session, you will be able to:

How to use Pointers with functions

How to use Pointers with structures

How to implement Dynamic memory allocation in creating a linked lists.

Functions and Pointers Pointers can be passed to a function as arguments and a function can also return a pointer to the calling program. Example 17.1: Passing pointers as argument main() { int

a =5 , *p;

void change(int *);

/*

function prototype */

p =&a; change(p);

/* pointer p is passed to a function – call by reference */

printf(“ %d “ , a);

/*

prints 10

*/

} void change(int *q)

/* q is a pointer which will point to the memory location pointed by p */

{ *q = 10; }

Example 17.2: Function returning pointer main() { int *p ; int *assign() ;

/* function prototype - function returning an integer pointer */

p = assign() ; printf(‘’ %d ‘’ , *p) ;

/* will print 20 */

}

int *assign() Page 127 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


{ int a , *q = &a; *q = 20 ; return q ; }

Example 17.3: Function receiving pointers and returning pointer int *big (int * , int *); main() { int a=10, b=20, *p; p = big (&a, &b);

/* address of the variable a or b will be stored in p */

printf (“%d”,*p); } int *big (int *x , int *y) { if (*x > *y) return (x); else return (y);

/* addr. of a is returned */

/* addr. of b is returned */

} It is possible to pass a portion of an array, rather than an entire array, to a function using pointers. Function Pointer Function will also have a memory address like other variables. So, we can have a pointer variable to point to the starting location of a function and can execute the function by means of the pointer variable, which will speeds up the execution. General Form: return-type (* function_pointer_name)(argument list..) Suppose we have a function as, void add(int x, int y) { printf(“Value = %d”, x + y); } Pointer to this function is declared as, void (*p)(int x, int y); Æ ‘p’ is a pointer which can point to a function having two integer arguments and returning an integer value. p = add; Æ makes the pointer to point to the function add() Note: function name specifies the starting address.



Æ will call the function add() with parameters 10,20

(*p)(10,20); Example 17.4 int display();

int (*func_ptr) (); func_ptr = display; (*func_ptr) ();

/*invokes the function display */

Example 17.5 main() { void

abc();

abc(); (*abc)(); /* calling the function by function pointer */ } void abc() { printf(“function”); } Output: functionfunction

Structures and Pointers Structure variable can be declared as pointers. It will be useful when an entire structure is passed to a function via call by reference. Pointer declaration to a structure is as follows: struct student

*ptr;

In this declaration, ‘ptr’ is a pointer type variable, which can hold an address of a variable of the type ‘student’. Example 17.6 struct stud { int rollnum; char name[20]; int semester; float avg; }; struct stud

student={101,”raja”, 1, 95.67}, *ptr ;

To make ‘ptr’ to point to the structure ‘student’, we can write as ptr = &student;



Accessing a member through pointer variable The notation for referring a member field of a structure pointed by a pointer is as follows: (*pointer). memberfieldname (OR) pointer -> memberfieldname Example 17.7 printf(“ %d \t %s \t %d \t %f “, ptr->rollnum, ptr->name, ptr->semester, ptr->avg); Self-Referential structures A structure containing a member that is a pointer to the same structure type is called selfreferential structures. It is used to build various kinds of linked data structures. Example 17.8 struct employee { char name[20]; char gender; float salary; struct employee *empptr;

Dynamic Memory Allocation Conventional arrays are static in nature, because size has to be mentioned in the declaration statement itself and fixed block of memory is reserved during the compilation. C supports dynamic memory allocation through the following functions: malloc(), calloc () , free() These functions provides the ability to reserve as much memory as may required during program execution, and then release this memory when it is no longer required. Thus, arrays can be represented in terms of pointers and an initial memory location can be allocated to pointer variable by means of this memory allocation functions. int *p; p = (int *) malloc ( 10 * sizeof(int)) ;



The above program constructs will return memory block of 20 bytes, which can hold 10 integers. The starting address is pointed by the pointer ‘p’. A one dimensional dynamic array can be declared using pointers as follows: int *p; p = (int *) calloc (10, sizeof(int)); This will return 10 continuous memory blocks of 2 bytes each and initializes them to 0. This can be used to allocate space for arrays and structures. free(p) will release the memory pointed by a pointer variable ‘p’. free() will take a void pointer. Example 17.9: Program for adding two matrices using array of pointers void main() { int *a[3] , *b[3] , *c[3]; int i,j; for(i=0 ; i<3; i++) { a[i] = (int *)malloc( 3 * sizeof(int)); /* memory is allocated to individual pointers */ b[i] = (int *)malloc( 3 * sizeof(int)); c[i] = (int *)malloc( 3 * sizeof(int)); } printf(" \n enter the values of matrix 1 \n"); for(i=0; i<3; i++) for(j=0; j<3; j++) scanf("%d", a[i]+j); printf("\n enter the values of second matrix"); for(i=0; i<3; i++) for(j=0; j<3; j++) scanf("%d", b[i]+j); for(i=0; i<3; i++ for(j=0; j<3; j++) *(c[i]+j) = *(a[i]+j) + *(b[i]+j); for(i=0; i<3; i++) for(j=0; j<3; j++) printf("\t%d", *(c[i]+j)); }



Chain of Pointers Multi dimensional arrays can be declared using pointer to pointer representation and memory can be allocated dynamically. int **p; Æ represents 2 dimensional array In the above declaration p is a pointer variable, which holds the address of another integer pointer. As such, there is no restriction imposed by the compiler as to how many levels we can go about in using a pointer. The following declaration is perfectly valid: int *****p; However, beyond 3 levels, it will make the code highly complex and un-maintainable. Example 17.10 addr.ptr2 Æ addr.ptr1 Æ value int x,*p1,**p2; x=100; p1=&x; p2=&p1; To access the value we can use either **p2 or

*p1

Advantages

It gives direct control over memory and thus we can play around with memory by all possible means. For example, we can refer to any part of the hardware like keyboard, video memory, printer, etc directly

As working with pointers is like working with memory, it will provide enhanced performance

Pass by reference is possible only through the usage of pointers. Useful while returning multiple values from a function

Allocation and freeing of memory can be done wherever required and need not be done in advance(Dynamic Memory Allocation)

Limitations

If the allocated memory is not freed properly, it cause memory leakages

If not used properly, it makes the program difficult to understand and may cause the illegal memory references



Try It Out 1. Problem Statement: Write a program to access structure using pointers

Code: #include struct card { char *face; char *suit; }; int main() { struct card aCard; struct card *cardPtr; aCard.face = "Ace"; aCard.suit = "Spades"; cardPtr = &aCard; printf( "%s%s%s\n%s%s%s\n%s%s%s\n", aCard.face, " of ", aCard.suit, cardPtr->face, " of ", cardPtr->suit, ( *cardPtr ).face, " of ", ( *cardPtr ).suit ); getchar(); return 0; } Refer File Name: to obtain soft copy of the program code

How It Works:

Declare a structure card having face and suit as two pointers to char.

In the main program, declare a variable using card structure and pointer variable pointing to card structure.

Assign the values of face and suit of card structure.

Print the values of card structure in three different forms.

All will print the same.



2. Problem Statement: Write a program to insert values in a linked list

Code: # include # include struct node { int data; struct node *link; }; struct node *insert(struct node *p, int n){ struct node *temp; if(p==NULL){ p=(struct node *)malloc(sizeof(struct node)); if(p==NULL) { printf("Error\n"); exit(0); } p-> data = n; p-> link = p; } else { temp = p; while (temp-> link != p) temp = temp-> link; temp-> link = (struct node *)malloc(sizeof(struct node)); if(temp -> link == NULL){ printf("Error\n"); exit(0); } temp = temp-> link; temp-> data = n; temp-> link = p; } return (p); } void printlist ( struct node *p ) { struct node *temp; temp = p; printf("The data values in the list are\n"); if(p!= NULL) Page 134 ©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved C3: Protected


{ do { printf("%d\t",temp->data); temp=temp->link; } while (temp!= p); } else printf("The list is empty\n"); } void main() { int n; int x; struct node *start = NULL ; start = insert ( start, 1 ); start = insert ( start, 2); start = insert ( start, 3 ); start = insert ( start, 4 ); printf("The created list is\n"); printlist ( start ); getchar(); } Refer File Name: to obtain soft copy of the program code

How It Works:

Declare a structure node with data as the one of the member and the link as the other member which is a pointer to same structure which will hold the address of next node.

In the main program, declare a pointer variable start pointing to struct node and initialize to NULL.

Call a function insert() and pass the start pointer and the value 1 as argument to the function.

In the insert function,as it is first time, the start pointer will be NULL, so it will allocate memory and assign the value of data as 1 and the link pointing to the same pointer p.

Then returns the pointer back.

In the main program, again insert() function is called with the returned pointer from previous call and the value as 2.

Now the start pointer is not NULL, so it goes to the else part and traverse the linked list till the last node.

Then allocate memory and assign data as 2 and link pointing to the same pointer p.

Then returns back the pointer.



Same is continued for next two insert function call.

Now four data’s has been inserted in to the linked list.

In the main program call the printlist() function to print all the data in the linked list.

In the printlist() function, using do while loop traverse through the linked list and print all the values.

Summary

Pointer is a variable which can hold the address of another variable.

& operator is used to refer the address of a variable and * operator is used for dereferencing the pointer.

Pointer can point to an array of any dimensions.

There are two ways to represent multi dimensional arrays by means of pointers: o Single pointer points to set of arrays o Array of pointers

Strings can easily be represented using pointer – Ragged arrays.

malloc(), calloc() functions are used to allocate memory dynamically.

free() function is used to de-allocate the memory.

Test your Understanding 1. State whether the following are true or false a. Pointer variable can only contain an address b. Address of the memory location can be assigned to ordinary variables c. Pointer can refer to the content of the memory location by & operator d. Size of the pointer variable is equivalent to the size of the data item it points. 2. What is the use of generic pointers? 3. What is the output of the following code? main() { int n[25]; n[0]=100; n[24]=200; printf("\n%d,%d", *n, *(n+24)+*(n+0) ); } 4. Given the following declaration: int a, *b = &a , **c = &b; What is the output of the following statements? a=4; **c=5; b = (int *)**c;



5. What is the output of the following code? main( ) { char *str1=”abcd”; char str2[]=”abcd”; printf(“%d %d %d”, sizeof(str1),sizeof(str2), sizeof(“abcd”)); } 6. Differentiate malloc() , calloc(). Answers: 1. True, false, false, false 2. Generic pointers (void pointers) can point to data items of any type. 3. 100, 300 4. The first statement assigns 4 to a. The second statement assigns 5 to the location pointed to by the location pointed to by c. Since c points to b, this is same as assigning 5 to the location pointed to by b. Since b points to a, this statement is equivalent to assigning 5 to a. The third statement castes **c, which is value of a, into type int *, assign the value to a. The result is meaningless, because values cannot be assigned to pointers. 5. 2 5 5 6. malloc(), calloc() will both allocate the memory dynamically, but the difference is calloc() will return a contiguous memory location and initializes it to 0.



Syntax Summary Program Structure/Functions type fnc(type1,: : : ) type name main() { declarations statements }

function declarations external variable declarations main routine local variable declarations

type fnc(arg1,: : : ) { declarations statements return value; }

function definition local variable declarations

/* */

comments

main(int argc, char *argv[])

main with args

exit(arg)

terminate execution

C Preprocessor #include

include library file

#include "filename"

include user file

#define

name text replacement text

#define name(var)

text replacement macro Example. #define max(A,B) ((A)>(B) ? (A) : (B))

#undef name

undefine

#

quoted string in replace

##

concatenate args and rescan

#if, #else, #elif, #endif

conditional execution

#ifdef, #ifndef

is name defined, not defined?

name defined?

defined(name)

line continuation char

\



Data Types/Declarations character (1 byte)

char

integer

int

float (single precision)

float

float (double precision)

double

short (16 bit integer)

short

long (32 bit integer)

long

positive and negative

signed

only positive

unsigned

pointer to int, float

*int, *float

enumeration constant

enum

constant (unchanging) value

const

declare external variable

extern

register variable

register

local to source file

static

no value

void

structure

struct

create name by data type t

typedef typename

size of an object (type is size_t)

sizeof object

size of a data type (type is size_t)

sizeof(type name)

Initialization initialize variable

type name=value

initialize array

type name[]={value1,: : : }

initialize char string

char name[]="string"

Constants long (suffix)

L or l

float (suffix)

F or f

exponential form

e

octal (prefix zero)

0

hexadecimal (prefix zero-ex)

0x or 0X

character constant (char, octal, hex)

‘a’, ‘\ooo’, ‘\xhh’

newline, cr, tab, backspace

\n, \r, \t, \b

special characters

\\, \?, \, \"

string constant (ends with \0)

"abc: : : de"



Pointers, Arrays & Structures declare pointer to type

type *name

declare function returning pointer to type type

*f()

declare pointer to function returning type type

(*pf)()

generic pointer type

void *

null pointer

NULL

object pointed to by pointer

*pointer

address of object name

&name

array

name[dim]

multi-dim array

name[dim1][dim2]….

Structures struct tag { declarations };

structure template declaration of members

struct tag name

create structure

name.member

member of structure from template

pointer -> member Ex. (*p).x and p->x are the same

member of pointed to structure

union

single value, multiple type structure

member : b

bit field with b bits

Operators (grouped by precedence) structure member operator

name.member

structure pointer

pointer->member

increment, decrement

++, --

plus, minus, logical not, bitwise not

+, -, !, ~

indirection via pointer, address of object

*pointer, &name

cast expression to type

(type) expr

size of an object

sizeof

multiply, divide, modulus (remainder)

*, /, %

add, subtract

+, -

left, right shift [bit ops]

<<, >>

comparisons

>, >=, <, <=

comparisons

==, !=

bitwise and

&

bitwise exclusive or

^

bitwise or (incl)

|

logical and

&&



logical or

||

conditional expression

expr1 ? expr2 : expr3

assignment operators

+=, -=, *=, ……

expression evaluation separator

,

Unary operators, conditional expression and assignment operators group right to left; all others group left to right. Flow of Control Statement terminator Block delimiters Exit from switch, while, do, for Next iteration of while, do, for go to Label Return value from function Flow Constructions if statement

while statement for statement do statement switch statement

; {} break continue goto label label: return expr

if (expr) statement else if (expr) statement else statement while (expr) statement for (expr 1; expr2; expr3) statement do statement while(expr ); switch (expr) { case const1: statement1 break; case const2: statement2 break; default: statement }

ANSI Standard Libraries



Character Class Tests Functions

Functionalities

isalnum(c)

Checks whether c is alphanumeric

isalpha(c)

Checks whether c is alphabetic

iscntrl(c)

Checks whether c is a control character

isdigit(c)

Checks whether c is a decimal digit

isgraph(c)

Checks whether c is a printing character (not incl space)

islower(c)

Checks whether c is a lower case letter

isprint(c)

Checks whether c is a printing character (incl space)

ispunct(c)

Checks whether c is a printing char except space, letter, digit

isspace(c)

Checks whether c is a Space, form feed, newline, cr, tab, vtab

isupper(c)

Checks whether c is a upper case letter

isxdigit(c)

Checks whether c is a hexadecimal digit

tolower(c)

Convert c to lower case

toupper(c)

Convert c to upper case

String Operations

Consider s, t are strings and cs, ct are constant strings Functions

Functionalities

strlen(s)

Returns the length of s

strcpy(s,ct)

Copies ct to s

strncpy(s,ct,n)

Copies up to n chars to s

strcat(s,ct)

Concatenate ct after s

strncat(s,ct,n)

Concatenate up to n chars

strcmp(cs,ct)

Compares cs to ct

strncmp(cs,ct,n)

Compares only first n chars

strchr(cs,c)

Pointer to first c in cs

strrchr(cs,c)

Pointer to last c in cs

memcpy(s,ct,n)

Copy n chars from ct to s

memmove(s,ct,n)

Copy n chars from ct to s (may overlap)

memcmp(cs,ct,n)

Compare n chars of cs with ct

memchr(cs,c,n)

Pointer to first c in first n chars of cs

memset(s,c,n)

Put c into first n chars of cs



Input/Output Standard I/O Standard input stream

stdin

Standard output stream

stdout

Standard error stream

stderr

End of file

EOF

Get a character

getchar()

Print a character

putchar(chr )

Print formatted data

printf("format ",arg 1,..)

Print to string s

sprintf(s,"format ",arg 1,… )

Read formatted data

scanf("format ",&name1,… )

Read from string s

sscanf(s,"format ",&name1,…. )

Read line to string s (< max chars)

gets(s,max)

Print string s

puts(s)

File I/O Declare file pointer

FILE *fp

Pointer to named file

fopen("name","mode") Where modes: r (read), w (write), a (append)

Get a character

getc(fp)

Write a character

putc(chr ,fp)

Write to file

fprintf(fp,"format",arg 1,: : : )

Read from file

fscanf(fp,"format",arg 1,: : : )

Close file

fclose(fp)

Non-zero if error

ferror(fp)

Non-zero if EOF

feof(fp)

Read line to string s (< max chars)

fgets(s,max,fp)

Write string s

fputs(s,fp)



Codes for Formatted I/O:

"%-+ 0w:pmc"

-

left justify

+

print with sign

Space

print space if no sign

0

pad with leading zeros

w

min field width

p

precision

m

conversion character:

h

short, l long, L long double

c

conversion character: d,i integer u unsigned c single char s char string f double e,E exponential o octal x,X hexadecimal p pointer n number of chars written g,G same as f or e,E depending on exponent

Standard Utility Functions Function Type

Functions

Absolute value of int n

abs(n)

Absolute value of long n

labs(n)

Quotient and remainder of ints n,d

div(n,d) returns structure with div_t.quot and div_t.rem

Quotient and remainder of longs n,d

ldiv(n,d) returns structure with ldiv_t.quot and ldiv_t.rem

Pseudo-random integer [0,RAND_MAX]

rand()

Set random seed to n

srand(n)

Terminate program execution

exit(status)

Pass string s to system for execution

system(s)



Conversions Function Type

Functions

Convert string s to double

atof(s)

Convert string s to integer

atoi(s)

Convert string s to long

atol(s)

Convert prefix of s to double

strtod(s,endp)

Convert prefix of s (base b) to long

strtol(s,endp,b)

Convert prefix of s (base b) to unsigned long

strtoul(s,endp,b)

Storage Allocation Function Type

Functions

Allocate storage

malloc(size), calloc(nobj,size)

Change size of object

realloc(pts,size)

Deal locate space

free(ptr)

Mathematical Functions Arguments and returned values are double Function Type

Functions

Trig functions

sin(x), cos(x), tan(x)

Inverse trig functions a

sin(x), acos(x), atan(x)

Arctan (y/x)

atan2(y,x)

Hyperbolic trig functions

sinh(x), cosh(x), tanh(x)

Exponentials and logs

exp(x), log(x), log10(x)

Exponentials and logs (2 power)

ldexp(x,n), frexp(x,*e)

Division and remainder

modf(x,*ip), fmod(x,y)

Powers

pow(x,y), sqrt(x)

Rounding

ceil(x), floor(x), fabs(x)



Conversion Specifier for ‘printf’ statement A conversion specifier begins with the % character. After the % character come the following in this order:

[flags]

Control the conversion (optional).

[width]

Defines the number of characters to print (optional).

[.precision] Defines the amount of precision to print for a number type (optional). [modifier]

Overrides the size (type) of the argument (optional).

[type]

The type of conversion to be applied (required).

Flags:

-

Value is left justified (default is right justified). Overrides the 0 flag.

+

Forces the sign (+ or -) to always be shown. Default is to just show the - sign. Overrides the space flag.

space Causes a positive value to display a space for the sign. Negative values still show the sign. #

Alternate form: Conversion Character Result

0

o

Precision is increased to make the first digit a zero.

X or x

Nonzero value will have 0x or 0X prefixed to it.

E, e, f, g, or G

Result will always have a decimal point.

G or g

Trailing zeros will not be removed.

For d, i, o, u, x, X, e, E, f, g, and G leading zeros are used to pad the field width instead of spaces. This is useful only with a width specifier. Precision overrides this flag.

Width: The width of the field is specified here with a decimal value. If the value is not large enough to fill the width, then the rest of the field is padded with spaces (unless the 0 flag is specified). If the value overflows the width of the field, then the field is expanded to fit the value. If a * is used in place of the width specifer, then the next argument (which must be an int type) specifies the width of the field. Note: when using the * with the width and/or precision specifier, the width argument comes first, then the precision argument, then the value to be converted.



Precision: The precision begins with a dot (.) to distinguish itself from the width specifier. The precision can be given as a decimal value or as an asterisk (*). If a * is used, then the next argument (which is of an int type) specifies the precision. Note: when using the * with the width and/or precision specifier, the width argument comes first, then the precision argument, then the value to be converted. Precision does not affect the c type.

Result

[.precision] Default precision values:

(none)

1 for d, i, o, u, x, X types. The minimum number of digits to appear. 6 for f, e, E types. Specifies the number of digits after the decimal point. For g or G types all significant digits are shown. For s type all characters in string are print up to but not including the null character. . or .0

For d, i, o, u, x, X types the default precision value is used unless the value is zero in which case no characters are printed. For f, e, E types no decimal point character or digits are printed. For g or G types the precision is assumed to be 1.

.n

For d, i, o, u, x, X types then at least n digits are printed (padding with zeros if necessary). For f, e, E types specifies the number of digits after the decimal point. For g or G types specifies the number of significant digits to print. For s type specifies the maximum number of characters to print.

Modifier: A modifier changes the way a conversion specifier type is interpreted.

[modifier]

[type]

Effect

h

d, i, o, u, x, X Value is first converted to a short int or unsigned short i nt.

h

n

l

d, i, o, u, x, X Value is first converted to a long int or unsigned long int .

l

n

Specifies that the pointer points to a long int.

L

e, E, f, g, G

Value is first converted to a long double.

Specifies that the pointer points to a short int.



Conversion specifier type: The conversion specifier specifies what type the argument is to be treated as.

[type]

Output

d, i

Type signed int.

o

Type unsigned int printed in octal.

u

Type unsigned int printed in decimal.

x

Type unsigned int printed in hexadecimal as dddd using a, b, c, d, e, f.

X

Type unsigned int printed in hexadecimal as dddd using A, B, C, D, E, F.

f

Type double printed as [-]ddd.ddd.

e, E

Type double printed as [-]d.dddeñdd where there is one digit printed before the decimal (zero only if the value is zero). The exponent contains at least two digits. If type is E then the exponent is printed with a capital E.

g, G

Type double printed as type e or E if the exponent is less than -4 or greater than or equal to the precision. Otherwise printed as type f. Trailing zeros are removed. Decimal point character appears only if there is a nonzero decimal digit.

c

Type char. Single character is printed.

s

Type pointer to array. String is printed according to precision (no precision prints entire string).

p

Prints the value of a pointer (the memory location it holds).

n

The argument must be a pointer to an int. Stores the number of characters printed thus far in the int. No characters are printed.

%

A % sign is printed.

Conversion specifier for ‘fscanf()’ An input field is specified with a conversion specifier which begins with the % character. After the % character come the following in this order:

[*]

Assignment suppressor (optional).

[width]

Defines the maximum number of characters to read (optional).

[modifier] Overrides the size (type) of the argument (optional). [type]

The type of conversion to be applied (required).



Assignment suppressor: Causes the input field to be scanned but not stored in a variable. Width: The maximum width of the field is specified here with a decimal value. If the input is smaller than the width specifier (i.e. it reaches a nonconvertible character), then what was read thus far is converted and stored in the variable. Modifier: A modifier changes the way a conversion specifier type is interpreted.

[modifier]

[type]

Effect

h

d, i, o, u, x The argument is a short int or unsigned short int.< /td>

h

n

l

d, i, o, u, x The argument is a long int or unsigned long int .

l

n

Specifies that the pointer points to a long int.

l

e, f, g

The argument is a double.

L

e, f, g

The argument is a long double.

Specifies that the pointer points to a short int.

Conversion specifier type: The conversion specifier specifies what type the argument is. It also controls what a valid convertible character is (what kind of characters it can read so it can convert to something compatible).

[type]

Input

d

Type signed int represented in base 10. Digits 0 through 9 and the sign (+ or -).

i

Type signed int. The base (radix) is dependent on the first two characters. If the first character is a digit from 1 to 9, then it is base 10. If the first digit is a zero and the second digit is a digit from 1 to 7, then it is base 8 (octal). If the first digit is a zero and the second character is an x or X, then it is base 16 (hexadecimal).

o

Type unsigned int. The input must be in base 8 (octal). Digits 0 through 7 only.

u

Type unsigned int. The input must be in base 10 (decimal). Digits 0 through 9 only.

x, X

Type unsigned int. The input must be in base 16 (hexadecimal). Digits 0 through 9 or A through Z or a through z. The characters 0x or 0X may be optionally prefixed to the value.

e, E, f, Type float. Begins with an optional sign. Then one or more digits, followed by an optional decimal-point and decimal value. Finally ended with an optional signed exponent value g, G designated with an e or E. s

Type character array. Inputs a sequence of non-white space characters (space, tab, carriage return, new line, vertical tab, or form feed). The array must be large enough to hold the sequence plus a null character appended to the end.



[type]

Input

[...]

Type character array. Allows a search set of characters. Allows input of only those character encapsulated in the brackets (the scan set). If the first character is a carrot (^), then the scan set is inverted and allows any ASCII character except those specified between the brackets. On some systems a range can be specified with the dash character (-). By specifying the beginning character, a dash, and an ending character a range of characters can be included in the scan set. A null character is appended to the end of the array.

c

Type character array. Inputs the number of characters specified in the width field. If no width field is specified, then 1 is assumed. No null character is appended to the array.

p

Pointer to a pointer. Inputs a memory address in the same fashion of the %p type produced by the printf function.

n

The argument must be a pointer to an int. Stores the number of characters read thus far in the int. No characters are read from the input stream.

%

Requires a matching % sign from the input.



References Websites

http://refcards.com/refcards/c/c-refcard-letter.pdf

http://cm.bell-labs.com/cm/cs/who/dmr/chist.html

http://www.lysator.liu.se/c/bwk-tutor.html#introduction

http://www.acm.uiuc.edu/webmonkeys/book/c_guide/

Books

Deitel & Deitel, “C How to Program”, Third Edition, Prentice Hall

Byron Gottfried, “Programming in C”, Tata McGraw Hill

R.G.Dromey, “How to solve it by Computer”, Eastern Economy Edition

Al Kelley, Ira Pohl, “A Book on C”, Fourth Edition, Pearson Education Asia



STUDENT NOTES:


Handout_Problem_Solving_and_C_Programming_v1[1].0

Recommend Documents