C by Dissection The Essentials of C Programming,9780201713749

C by Dissection The Essentials of C Programming

by ;
Edition: 4th
ISBN13: 9780201713749
ISBN10: 0201713748
Format: Paperback
Pub. Date: 2000-10-30
Publisher(s): Pearson
List Price: $185.44

Buy New

Usually Ships in 2-3 Business Days
$176.61
Add to Cart

Rent Textbook

Select for Price
Add to Cart
There was a problem. Please try again later.

Used Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

Buy from our Marketplace starting at $4.39

How Marketplace Works:

  • This item is offered by an independent seller and not shipped from our warehouse
  • Item details like edition and cover design may differ from our description; see seller's comments before ordering.
  • Sellers much confirm and ship within two business days; otherwise, the order will be cancelled and refunded.
  • Marketplace purchases cannot be returned to eCampus.com. Contact the seller directly for inquiries; if no response within two days, contact customer service.
  • Additional shipping costs apply to Marketplace purchases. Review shipping costs at checkout.

Summary

C by Dissection presents a thorough introduction to the programming process by carefully developing working programs to illuminate key features of the C programming language. This book presents the concepts of the programming process using the "dissection" method. Dissection is a unique tool first developed by the authors to point out key features of program code. It is similar to a structured walk-through of the code, with the intention of explaining newly encountered programming elements and idioms as found in working code.Each chapter presents a number of carefully explained programs, which lead the reader in a holistic manner to ever-improving programming skills. Right from the start, the reader is introduced to complete programs, and at an early point in the book is introduced to writing functions as a major feature of structured programming. This edition features expanded treatment of pointers, memory management, and recursion. It also takes into account the fact that many people are learning Java as a first language and then going to C, or vice-versa, and calls out those topics that present a challenge when making such transitions (e.g. i/o, data types).This book assumes no programming background and can be used by first-time computer users or by experienced programmers who are transitioning to C.

Author Biography

Al Kelley, Ph.D., is an emeritus faculty at the University of California at Santa Cruz, where he was a professor of mathematics.

Table of Contents

Writing an ANSI C Program
Getting Ready to Program
A First Program
Variables, Expressions, and Assignments
Initialization
The Use of #define and #include
The Use of printf() and scanf()
The Use of printf()
The Use of scanf()
The while Statement
Problem Solving: Computing Sums
Style
Common Programming Errors
System Considerations
Writing and Running a C Program
Interrupting a Program
Typing an End-of-File Signal
Redirection of the Input and the Output
Moving to C++
Summary
Exercises
Lexical Elements, Operators, and the C System
Characters and Lexical Elements
Comments
Keywords
Identifiers
Constants
String Constants
Operators and Punctuators
Precedence and Associativity of Operators
Increment and Decrement Operators
Assignment Operators
An Example: Computing Powers of 2
The C System
The Preprocessor
The Standard Library
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Flow of Control
Relational, Equality, and Logical Operators
Relational Operators and Expressions
Equality Operators and Expressions
Logical Operators and Expressions
Short-Circuit Evaluation
The Compound Statement
The Empty Statement
The if and if-else Statements
The while Statement
Problem Solving: Finding Maximum Values
The for Statement
Problem Solving: Combinatorics
Problem Solving: Boolean Variables
The Comma Operator
The do Statement
The goto Statement
The break and continue Statements
The switch Statement
Nested Flow of Control
The Conditional Operator
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Functions and Structured Programming
Function Invocation
Function Definition
The return Statement
Function Prototypes
Top-Down Design
Program Correctness: The assert() Macro
Function Declarations from the Compiler's Viewpoint
Limitations
Problem Solving: Random Numbers
An Alternate Style for Function Definition Order
Developing a Large Program
What Constitutes a Large Program?
A Simulation: The Game of Heads or Tails
Invocation and Call-by-Value
Recursion
Style
Common Programming Errors
System Considerations
Moving to C++
Function Prototypes in C++
Summary
Exercises
Character Processing
The Data Type char
The Use of getchar() and putchar()
An Example: Capitalize
The Macros in ctype.h
Problem Solving: Repeating Characters
Problem Solving: Counting Words
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
The Fundamental Data Types
Declarations and Expressions
The Fundamental Data Types
Characters and the Data Type char
The Data Type int
The Integral Types short, long, and unsigned
The Floating Types
The sizeof Operator
Mathematical Functions
Conversions and Casts
The Integral Promotions
The Usual Arithmetic Conversions
Casts
Problem Solving: Computing Interest
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Enumeration Types and typedef
Enumeration Types
The Use of typedef
An Example: The Game of Paper, Rock, Scissors
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Functions, Pointers, and Storage Classes
Pointer Declaration and Assignment
Addressing and Dereferencing
Pointers to void
Call-by-Reference
Scope Rules
Storage Classes
The Storage Class auto
The Storage Class extern
The Storage Class register
The Storage Class static
Static External Variables
Default Initialization
An Example: Processing Characters
Function Declarations and Definitions
The Type Qualifiers const and volatile
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Arrays and Pointers
One-Dimensional Arrays
Initialization
Subscripting
An Example: Counting Each Letter Separately
The Relationship Between Arrays and Pointers
Pointer Arithmetic and Element Size
Passing Arrays to Functions
A Sorting Algorithm: Bubble Sort
Two-Dimensional Arrays
Multidimensional Arrays
Dynamic Memory Allocation
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Strings and Pointers
The End-of-String Sentinel \0
Initialization of Strings
An Example: Have a Nice Day
Using Pointers to Process a String
Problem Solving: Counting Words
Passing Arguments to main()
String Handling Functions in the Standard Library
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Recursion
Recursive Problem Solving
An Example: Drawing Patterns on the Screen
String Handling Using Recursion
The Divide-and-Conquer Methodology
Style
Common Programming Errors
System Considerations
Moving to C++
Summary
Exercises
Structures and ADTs
Declaring Structures
Accessing a Member
Operator Precedence and Associativity: A Final Look
Structures, Functions, and Assignment
Problem Solving: Student Records
Initialization of Structures
The Use of typedef
Self-Referential Structures
Linear Linked Lists
Dynamic Storage Allocation
List Operations
Counting and Lookup
Insertion and Deletion
Style
Common Programming Errors
System Considerations
Moving to C++
Classes
Summary
Exercises
Input/Output and Files
The Output Function printf()
The Input Function scanf()
Directives in the Control String
Ordinary Characters
White Space Characters
Conversion Specifications
Floating Numbers in the Input Stream
Using the Scan Set
The Return Value
A scanf() Example
The functions sprintf() and sscanf()
The functions fprintf() and fscanf()
Accessing Files
An Example: Double-Spacing a File
Using Temporary Files and Graceful Functions
Accessing a File Randomly
Style
Common Programming Errors
The Function sscanf() Is Different
System Considerations
Moving to C++
Summary
Exercises
Software Tools
Executing Commands From Within a C Program
Environment Variables
The C Compiler
Creating a Library
Using the Profiler
How to Time C Code
The Use of dbx
The Use of make
The Use of touch
Other Useful Tools
Style
Common Programming Errors
System Considerations
Summary
Exercises
From C to C++
Object-Oriented Programming
Why Switch to C++?
Classes and Abstract Data Types
Overloading
Constructors and Destructors
Inheritance
Polymorphism
Templates
C++ Exceptions
Benefits Of Object-Oriented Programming
Style
Common Programming Errors
System Considerations
Summary
Exercises
From C To C++
Output
Input
Classes and Abstract Data Types
Overloading
Constructors and Destructors
Object-oriented Programming and Inheritance
Style
Common Programming Errors
System Considerations
Summary
Exercises
The Standard Library
Diagnostics: assert.h
Character Handling: ype.h
Testing a Character
Mapping a Character
Errors: errno.h
Floating Limits: float.h
Integral Limits: limits.h
Localization: local.h
Mathematics: math.h
Nonlocal Jumps: setjmp.h
Signal Handling: signal.h
Variable Arguments: stdard.h
Common Definition: stddef.h
Input/Output: stdio.h
Opening, Closing, and Conditioning a File
Accessing the File Position Indicator
Error Handling
Character Input/Output
Formatted Input/Output
Direct Input/Output
Removing or Renaming a File
General Utilities: stdlib.h
Dynamic Allocation of Memory
Searching and Sorting
Pseudo Random Number Generator
Communicating With the Environment
Integer Arithmetic
String Conversion
Multibyte Character Functions
Multibyte String Functions
Leaving the Program
Memory and String Handling: string.h
Memory Handling Functions
String Handling Functions
Date and Time: time.h
Accessing the Clock
Accessing the Time
Miscellaneous
Using File Descriptors
Creating a Concurrent Process
Overlaying a Process
Interprocess Communication
Suspending Program Execution
The Preprocessor
The Use of #include
The Use of #define
Syntactic Sugar
Macros With Arguments
The Use of #undef
Conditional Compilation
Predefined Macros
The Operators # and ##
The assert() Macro
The Use of #error and #pragma
Line Numbers
Corresponding Functions
Bitwise Operators
Bitwise Operators and Expressions
Bitwise Complement
Two's Complement
Bitwise Binary Logical Operators
Left- and Right-Shift Operators
Masks
Printing an int Bitwise
Packing and Unpacking
Common Programming Errors
System Considerations
Summary
Exercises
ANSI C Compared To Traditional C
Types
Constants
Declarations
Initializations
Expressions
Functions
Conversions
Array Pointers
Structures and Unions
Preprocessor
Header Files
Miscellaneous
ASCII Character Codes
Operator Precedence and Associativity
Table of Contents provided by Publisher. All Rights Reserved.

An electronic version of this book is available through VitalSource.

This book is viewable on PC, Mac, iPhone, iPad, iPod Touch, and most smartphones.

By purchasing, you will be able to view this book online, as well as download it, for the chosen number of days.

Digital License

You are licensing a digital product for a set duration. Durations are set forth in the product description, with "Lifetime" typically meaning five (5) years of online access and permanent download to a supported device. All licenses are non-transferable.

More details can be found here.

A downloadable version of this book is available through the eCampus Reader or compatible Adobe readers.

Applications are available on iOS, Android, PC, Mac, and Windows Mobile platforms.

Please view the compatibility matrix prior to purchase.