×
When you want to succeed as bad as you want to breathe, then you’ll be successful.
--Your friends at LectureNotes
Close

Note for Programming in C - C By Sumit Kumar

  • Programming in C - C
  • Note
  • 426 Views
  • 20 Offline Downloads
  • Uploaded 8 months ago
Sumit Kumar
Sumit Kumar
0 User(s)
Download PDFOrder Printed Copy

Share it with your friends

Leave your Comments

Text from page-1

An Introduction to the C Programming Language and Software Design Tim Bailey

Text from page-2

Preface This textbook began as a set of lecture notes for a first-year undergraduate software engineering course in 2003. The course was run over a 13-week semester with two lectures a week. The intention of this text is to cover topics on the C programming language and introductory software design in sequence as a 20 lecture course, with the material in Chapters 2, 7, 8, 11, and 13 well served by two lectures apiece. Ample cross-referencing and indexing is provided to make the text a servicable reference, but more complete works are recommended. In particular, for the practicing programmer, the best available tutorial and reference is Kernighan and Ritchie [KR88] and the best in-depth reference is Harbison and Steele [HS95, HS02]. The influence of these two works on this text is readily apparent throughout. What sets this book apart from most introductory C-programming texts is its strong emphasis on software design. Like other texts, it presents the core language syntax and semantics, but it also addresses aspects of program composition, such as function interfaces (Section 4.5), file modularity (Section 5.7), and object-modular coding style (Section 11.6). It also shows how to design for errors using assert() and exit() (Section 4.4). Chapter 6 introduces the basics of the software design process—from the requirements and specification, to top-down and bottom-up design, to writing actual code. Chapter 14 shows how to write generic software (i.e., code designed to work with a variety of different data types). Another aspect that is not common in introductory C texts is an emphasis on bitwise operations. The course for which this textbook was originally written was prerequisite to an embedded systems course, and hence required an introduction to bitwise manipulations suitable for embedded systems programming. Chapter 12 provides a thorough discussion of bitwise programming techniques. The full source code for all significant programs in this text can be found on the web at the address www.acfr.usyd.edu.au/homepages/academic/tbailey/index.html. Given the volatile nature of the web, this link may change in subsequent years. If the link is broken, please email me at tbailey@acfr.usyd.edu.au and I will attempt to rectify the problem. This textbook is a work in progress and will be refined and possibly expanded in the future. No doubt there are errors and inconsistencies—both technical and grammatical—although hopefully nothing too seriously misleading. If you find a mistake or have any constructive comments please feel free to send me an email. Also, any interesting or clever code snippets that might be incorporated in future editions are most welcome. Tim Bailey 2005. Draft 0.6 (July 12, 2005) TODO: - complete Chapter 16 - complete appendices - complete the index i

Text from page-3

Contents Preface i Contents ii 1 Introduction 1.1 Programming and Programming Languages . . . . 1.2 The C Programming Language . . . . . . . . . . . 1.3 A First Program . . . . . . . . . . . . . . . . . . . 1.4 Variants of Hello World . . . . . . . . . . . . . . . 1.5 A Numerical Example . . . . . . . . . . . . . . . . 1.6 Another Version of the Conversion Table Example 1.7 Organisation of the Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 2 3 4 5 6 6 2 Types, Operators, and Expressions 2.1 Identifiers . . . . . . . . . . . . . . 2.2 Types . . . . . . . . . . . . . . . . 2.3 Constants . . . . . . . . . . . . . . 2.4 Symbolic Constants . . . . . . . . 2.5 printf Conversion Specifiers . . . 2.6 Declarations . . . . . . . . . . . . . 2.7 Arithmetic Operations . . . . . . . 2.8 Relational and Logical Operations 2.9 Bitwise Operators . . . . . . . . . 2.10 Assignment Operators . . . . . . . 2.11 Type Conversions and Casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 8 8 10 11 12 13 13 14 15 15 16 3 Branching and Iteration 3.1 If-Else . . . . . . . . . . . 3.2 ?: Conditional Expression 3.3 Switch . . . . . . . . . . . 3.4 While Loops . . . . . . . . 3.5 Do-While Loops . . . . . 3.6 For Loops . . . . . . . . . 3.7 Break and Continue . . . 3.8 Goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 17 19 19 20 21 21 22 23 4 Functions 4.1 Function Prototypes 4.2 Function Definition . 4.3 Benefits of Functions 4.4 Designing For Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 25 25 28 29 . . . . . . . . . . . . ii

Text from page-4

4.5 4.6 Interface Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 32 5 Scope and Extent 5.1 Local Scope and Automatic Extent . . . . . . . 5.2 External Scope and Static Extent . . . . . . . . 5.3 The static Storage Class Specifier . . . . . . . 5.4 Scope Resolution and Name Hiding . . . . . . . 5.5 Summary of Scope and Extent Rules . . . . . . 5.6 Header Files . . . . . . . . . . . . . . . . . . . . 5.7 Modular Programming: Multiple File Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 33 34 35 36 38 38 39 6 Software Design 6.1 Requirements and Specification . . . . . . . 6.2 Program Flow and Data Structures . . . . . 6.3 Top-down and Bottom-up Design . . . . . . 6.4 Pseudocode Design . . . . . . . . . . . . . . 6.5 Case Study: A Tic-Tac-Toe Game . . . . . 6.5.1 Requirements . . . . . . . . . . . . . 6.5.2 Specification . . . . . . . . . . . . . 6.5.3 Program Flow and Data Structures . 6.5.4 Bottom-Up Design . . . . . . . . . . 6.5.5 Top-Down Design . . . . . . . . . . 6.5.6 Benefits of Modular Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 41 42 42 43 44 44 44 45 45 47 48 7 Pointers 7.1 What is a Pointer? . . . . . 7.2 Pointer Syntax . . . . . . . 7.3 Pass By Reference . . . . . 7.4 Pointers and Arrays . . . . 7.5 Pointer Arithmetic . . . . . 7.6 Return Values and Pointers 7.7 Pointers to Pointers . . . . 7.8 Function Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 49 50 52 53 54 56 57 57 8 Arrays and Strings 8.1 Array Initialisation . . . . . . . . 8.2 Character Arrays and Strings . . 8.3 Strings and the Standard Library 8.4 Arrays of Pointers . . . . . . . . 8.5 Multi-dimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 59 60 62 63 65 9 Dynamic Memory 9.1 Different Memory Areas in C . . . . . . 9.2 Standard Memory Allocation Functions 9.3 Dynamic Memory Management . . . . . 9.4 Example: Matrices . . . . . . . . . . . . 9.5 Example: An Expandable Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 68 69 70 72 75 . . . . . . . . . . . . . . . . iii

Lecture Notes