C How to Program / Edition 7


For introductory courses in C Programming. Also for courses in Programming for Engineers, Programming for Business, and Programming for Technology.

The Deitels' How to Program series offers unparalleled breadth and depth of object-oriented programming concepts and intermediate-level topics for further study. Using the Deitels’ signature “Live-Code™ Approach,” this complete, authoritative introduction to C programming introduces fundamentals of structured programming, and covers relevant features of C language’s C-201X standard. It also includes an updated treatment of C++ for those who want to transition to object-oriented concepts. Finally, new material on security is added to this edition.

Read More Show Less

Product Details

  • ISBN-13: 9780132990516
  • Publisher: Pearson Education
  • Publication date: 4/2/2012
  • Sold by: Barnes & Noble
  • Format: eTextbook
  • Edition number: 7
  • Pages: 992
  • File size: 8 MB

Meet the Author

Paul J. Deitel, CEO and Chief Technical Officer of Deitel & Associates, Inc., is a graduate of the MIT Sloan School of Management, where he studied Information Technology. He holds the¿Java Certified Programmer and¿Java Certified Developer professional certifications, and has been designated by Sun Microsystems as a Java Champion—"a prominent member of the Java community whose input is solicited by the company in order to improve the Java platform." He has delivered programming language courses to clients including numerous Fortune 1000 companies, government organizations and the military. Paul is one of the world's most experienced corporate trainers. He has also lectured on C and Java for the Boston Chapter of the Association for Computing Machinery. The Deitels are the world's best-selling programming language textbook authors.

Dr. Harvey M. Deitel, Chairman and Chief Strategy Officer of Deitel & Associates, Inc., has 46 years of academic and industry experience in the¿computer field. Dr. Deitel earned B.S. and M.S. degrees from the Massachusetts Institute of¿Technology and a Ph.D. from Boston University. He has 20 years of college teaching experience, including earning tenure and serving as the Chairman of the¿Computer Science Department at Boston College before founding Deitel & Associates, Inc. He and Paul are the co-authors of several dozen books and multimedia packages. With translations published in many languages, the Deitels' texts have earned international recognition and are used in over 150 countries. Dr. Deitel has delivered hundreds of professional seminars to major corporations, academic institutions, government organizations and the military.

Read More Show Less

Table of Contents

Appendices E through I are PDF documents posted online at the book’s Companion Website (located at www.pearsonhighered.com/deitel).
Preface xxi
1 Introduction to Computers, the Internet and the Web 1
1.1 Introduction 2
1.2 Computers: Hardware and Software 3
1.3 Computer Organization 4
1.4 Personal, Distributed and Client/Server Computing 5
1.5 The Internet and the World Wide Web 5
1.6 Machine Languages, Assembly Languages and High-Level Languages 6
1.7 History of C 7
1.8 C Standard Library 8
1.9 C++ 9
1.10 Java 9
1.11 Fortran, COBOL, Pascal and Ada 10
1.12 BASIC, Visual Basic, Visual C++, C# and .NET 10
1.13 Key Software Trend: Object Technology 11
1.14 Typical C Program Development Environment 12
1.15 Hardware Trends 14
1.16 Notes About C and This Book 15
1.17 Web Resources 16
2 Introduction to C Programming 23
2.1 Introduction 24
2.2 A Simple C Program: Printing a Line of Text 24
2.3 Another Simple C Program: Adding Two Integers 28
2.4 Memory Concepts 33
2.5 Arithmetic in C 34
2.6 Decision Making: Equality and Relational Operators 38
3 Structured Program Development in C 54
3.1 Introduction 55
3.2 Algorithms 55
3.3 Pseudocode 55
3.4 Control Structures 56
3.5 The if Selection Statement 58
3.6 The if…else Selection Statement 59
3.7 The while Repetition Statement 63
3.8 Formulating Algorithms Case Study 1: Counter-Controlled Repetition 64
3.9 Formulating Algorithms with Top-Down, Stepwise Refinement Case Study 2: Sentinel-Controlled Repetition 66
3.10 Formulating Algorithms with Top-Down, Stepwise Refinement Case Study 3: Nested Control Structures 73
3.11 Assignment Operators 77
3.12 Increment and Decrement Operators 78
4 C Program Control 97
4.1 Introduction 98
4.2 Repetition Essentials 98
4.3 Counter-Controlled Repetition 99
4.4 for Repetition Statement 100
4.5 for Statement: Notes and Observations 103
4.6 Examples Using the for Statement 103
4.7 switch Multiple-Selection Statement 107
4.8 do…while Repetition Statement 113
4.9 break and continue Statements 114
4.10 Logical Operators 116
4.11 Confusing Equality (==) and Assignment (=) Operators 119
4.12 Structured Programming Summary 121
5 C Functions 140
5.1 Introduction 141
5.2 Program Modules in C 141
5.3 Math Library Functions 142
5.4 Functions 144
5.5 Function Definitions 144
5.6 Function Prototypes 148
5.7 Function Call Stack and Activation Records 151
5.8 Headers 151
5.9 Calling Functions By Value and By Reference 152
5.10 Random Number Generation 153
5.11 Example: A Game of Chance 158
5.12 Storage Classes 161
5.13 Scope Rules 164
5.14 Recursion 167
5.15 Example Using Recursion: Fibonacci Series 170
5.16 Recursion vs. Iteration 174
6 C Arrays 195
6.1 Introduction 196
6.2 Arrays 196
6.3 Defining Arrays 198
6.4 Array Examples 198
6.5 Passing Arrays to Functions 212
6.6 Sorting Arrays 216
6.7 Case Study: Computing Mean, Median and Mode Using Arrays 218
6.8 Searching Arrays 223
6.9 Multiple-Subscripted Arrays 229
7 C Pointers 253
7.1 Introduction 254
7.2 Pointer Variable Definitions and Initialization 254
7.3 Pointer Operators 255
7.4 Passing Arguments to Functions by Reference 257
7.5 Using the const Qualifier with Pointers 261
7.6 Bubble Sort Using Call-by-Reference 267
7.7 sizeof Operator 270
7.8 Pointer Expressions and Pointer Arithmetic 273
7.9 Relationship between Pointers and Arrays 275
7.10 Arrays of Pointers 280
7.11 Case Study: Card Shuffling and Dealing Simulation 280
7.12 Pointers to Functions 285
8 C Characters and Strings 309
8.1 Introduction 310
8.2 Fundamentals of Strings and Characters 310
8.3 Character-Handling Library 312
8.4 String-Conversion Functions 317
8.5 Standard Input/Output Library Functions 322
8.6 String-Manipulation Functions of the String-Handling Library 326
8.7 Comparison Functions of the String-Handling Library 329
8.8 Search Functions of the String-Handling Library 331
8.9 Memory Functions of the String-Handling Library 337
8.10 Other Functions of the String-Handling Library 341
9 C Formatted Input/Output 356
9.1 Introduction 357
9.2 Streams 357
9.3 Formatting Output with printf 357
9.4 Printing Integers 358
9.5 Printing Floating-Point Numbers 359
9.6 Printing Strings and Characters 361
9.7 Other Conversion Specifiers 362
9.8 Printing with Field Widths and Precision 363
9.9 Using Flags in the printf Format Control String 366
9.10 Printing Literals and Escape Sequences 368
9.11 Reading Formatted Input with scanf 369
10 C Structures, Unions, Bit Manipulations and Enumerations 382
10.1 Introduction 383
10.2 Structure Definitions 383
10.3 Initializing Structures 386
10.4 Accessing Structure Members 386
10.5 Using Structures with Functions 388
10.6 typedef 388
10.7 Example: High-Performance Card Shuffling and Dealing Simulation 389
10.8 Unions 391
10.9 Bitwise Operators 394
10.10 Bit Fields 403
10.11 Enumeration Constants 406
11 C File Processing 417
11.1 Introduction 418
11.2 Data Hierarchy 418
11.3 Files and Streams 420
11.4 Creating a Sequential-Access File 421
11.5 Reading Data from a Sequential-Access File 426
11.6 Random-Access Files 430
11.7 Creating a Random-Access File 431
11.8 Writing Data Randomly to a Random-Access File 433
11.9 Reading Data from a Random-Access File 436
11.10 Case Study: Transaction-Processing Program 437
12 C Data Structures 454
12.1 Introduction 455
12.2 Self-Referential Structures 456
12.3 Dynamic Memory Allocation 456
12.4 Linked Lists 458
12.5 Stacks 466
12.6 Queues 472
12.7 Trees 478
13 C Preprocessor 495
13.1 Introduction 496
13.2 #include Preprocessor Directive 496
13.3 #define Preprocessor Directive: Symbolic Constants 496
13.4 #define Preprocessor Directive: Macros 497
13.5 Conditional Compilation 499
13.6 #error and #pragma Preprocessor Directives 500
13.7 # and ## Operators 500
13.8 Line Numbers 501
13.9 Predefined Symbolic Constants 501
13.10 Assertions 502
14 Other C Topics 507
14.1 Introduction 508
14.2 Redirecting I/O 508
14.3 Variable-Length Argument Lists 509
14.4 Using Command-Line Arguments 511
14.5 Notes on Compiling Multiple-Source-File Programs 512
14.6 Program Termination with exit and atexit 514
14.7 volatile Type Qualifier 515
14.8 Suffixes for Integer and Floating-Point Constants 516
14.9 More on Files 516
14.10 Signal Handling 518
14.11 Dynamic Memory Allocation: Functions calloc and realloc 520
14.12 Unconditional Branching with goto 521
15 C++ as a Better C; Introducing Object Technology 528
15.1 Introduction 529
15.2C++ 529
15.3 A Simple Program: Adding Two Integers 530
15.4 C++ Standard Library 532
15.5 Header Files 533
15.6 Inline Functions 535
15.7 References and Reference Parameters 537
15.8 Empty Parameter Lists 542
15.9 Default Arguments 542
15.10 Unary Scope Resolution Operator 544
15.11 Function Overloading 545
15.12 Function Templates 548
15.13 Introduction to Object Technology and the UML 551
15.14 Wrap-Up 554
16 Introduction to Classes and Objects 560
16.1 Introduction 561
16.2 Classes, Objects, Member Functions and Data Members 561
xiv Contents
16.3 Defining a Class with a Member Function 562
16.4 Defining a Member Function with a Parameter 566
16.5 Data Members, set Functions and get Functions 569
16.6 Initializing Objects with Constructors 576
16.7 Placing a Class in a Separate File for Reusability 579
16.8 Separating Interface from Implementation 583
16.9 Validating Data with set Functions 589
16.10 Wrap-Up 594
17 Classes: A Deeper Look, Part 1 601
17.1 Introduction 602
17.2 Time Class Case Study 603
17.3 Class Scope and Accessing Class Members 609
17.4 Separating Interface from Implementation 611
17.5 Access Functions and Utility Functions 612
17.6 Time Class Case Study: Constructors with Default Arguments 615
17.7 Destructors 620
17.8 When Constructors and Destructors are Called 621
17.9 Time Class Case Study: A Subtle Trap–Returning a Reference to a private Data Member 624
17.10 Default Memberwise Assignment 627
17.11 Wrap-Up 629
18 Classes: A Deeper Look, Part 2 635
18.1 Introduction 636
18.2 const (Constant) Objects and const Member Functions 636
18.3 Composition: Objects as Members of Classes 645
18.4 friend Functions and friend Classes 651
18.5 Using the this Pointer 654
18.6 static Class Members 659
18.7 Data Abstraction and Information Hiding 664
18.8 Wrap-Up 666
19 Operator Overloading 672
19.1 Introduction 673
19.2 Fundamentals of Operator Overloading 674
19.3 Restrictions on Operator Overloading 675
19.4 Operator Functions as Class Members vs. Global Function 676
19.5 Overloading Stream Insertion and Stream Extraction Operators 678
19.6 Overloading Unary Operators 681
19.7 Overloading Binary Operators 682
19.8 Dynamic Memory Management 682
19.9 Case Study: Array Class 684
19.10 Converting between Types 696
19.11 Building a String Class 697
19.12 Overloading ++ and -- 698
19.13 Case Study: A Date Class 700
19.14 Standard Library Class string 704
19.15 explicit Constructors 708
19.16 Proxy Classes 711
19.17 Wrap-Up 715
20 Object-Oriented Programming: Inheritance 727
20.1 Introduction 728
20.2 Base Classes and Derived Classes 729
20.3 protected Members 732
20.4 Relationship between Base Classes and Derived Classes 732
20.4.1 Creating and Using a CommissionEmployee Class 733
20.4.2 Creating a BasePlusCommissionEmployee Class Without Using Inheritance 738
20.4.3 Creating a CommissionEmployee—BasePlusCommissionEmployee Inheritance Hierarchy 743
20.4.4 CommissionEmployee—BasePlusCommissionEmployee Inheritance Hierarchy Using protected Data 748
20.4.5 CommissionEmployee—BasePlusCommissionEmployee Inheritance Hierarchy Using private Data 755
20.5 Constructors and Destructors in Derived Classes 762
20.6 public, protected and private Inheritance 770
20.7 Software Engineering with Inheritance 771
20.8 Wrap-Up 772
21 Object-Oriented Programming: Polymorphism 778
21.1 Introduction 779
21.2 Polymorphism Examples 780
21.3 Relationships Among Objects in an Inheritance Hierarchy 781
21.3.1 Invoking Base-Class Functions from Derived-Class Objects 782
21.3.2 Aiming Derived-Class Pointers at Base-Class Objects 789
21.3.3 Derived-Class Member-Function Calls via Base-Class Pointers 790
21.3.4 Virtual Functions 792
21.3.5 Summary of the Allowed Assignments Between Base-Class and Derived-Class Objects and Pointers 798
21.4 Type Fields and switch Statements 799
21.5 Abstract Classes and Pure virtual Functions 799
21.6 Case Study: Payroll System Using Polymorphism 801
21.6.1 Creating Abstract Base Class Employee 803
21.6.2 Creating Concrete Derived Class SalariedEmployee 806
21.6.3 Creating Concrete Derived Class HourlyEmployee 808
21.6.4 Creating Concrete Derived Class CommissionEmployee 811
21.6.5 Creating Indirect Concrete Derived Class BasePlusCommissionEmployee 813
21.6.6 Demonstrating Polymorphic Processing 814
21.7 (Optional) Polymorphism, Virtual Functions and Dynamic Binding “Under the Hood” 818
21.8 Case Study: Payroll System Using Polymorphism and Runtime Type Information with Downcasting, dynamic_cast, typeid and type_info 822
21.9 Virtual Destructors 826
21.10 Wrap-Up 826
22Templates 832
22.1 Introduction 833
22.2 Function Templates 833
22.3 Overloading Function Templates 837
22.4 Class Templates 837
22.5 Nontype Parameters and Default Types for Class Templates 844
22.6 Notes on Templates and Inheritance 845
22.7 Notes on Templates and Friends 845
22.8 Notes on Templates and static Members 846
22.9 Wrap-Up 846
23 Stream Input/Output 851
23.1 Introduction 852
23.2 Streams 853
23.2.1 Classic Streams vs. Standard Streams 853
23.2.2 iostream Library Header Files 854
23.2.3 Stream Input/Output Classes and Objects 854
23.3 Stream Output 857
23.3.1 Output of char
• Variables 857
23.3.2 Character Output Using Member Function put 857
23.4 Stream Input 858
23.4.1 get and getline Member Functions 858
23.4.2 istream Member Functions peek, putback and ignore 861
23.4.3 Type-Safe I/O 861
23.5 Unformatted I/O Using read, write and gcount 861
23.6 Introduction to Stream Manipulators 862
23.6.1 Integral Stream Base: dec, oct, hex and setbase 863
23.6.2 Floating-Point Precision (precision, setprecision) 864
23.6.3 Field Width (width, setw) 865
23.6.4 User-Defined Output Stream Manipulators 866
23.7 Stream Format States and Stream Manipulators 868
23.7.1 Trailing Zeros and Decimal Points (showpoint) 868
23.7.2 Justification (left, right and internal) 869
23.7.3 Padding (fill, setfill) 871
23.7.4 Integral Stream Base (dec, oct, hex, showbase) 872
23.7.5 Floating-Point Numbers; Scientific and Fixed Notation(scientific, fixed) 873
23.7.6 Uppercase/Lowercase Control (uppercase) 874
23.7.7 Specifying Boolean Format (boolalpha) 874
23.7.8 Setting and Resetting the Format State via Member Function flags 875
23.8 Stream Error States 877
23.9 Tying an Output Stream to an Input Stream 879
23.10 Wrap-Up 879
24 Exception Handling 889
24.1 Introduction 890
24.2 Exception-Handling Overview 891
24.3 Example: Handling an Attempt to Divide by Zero 891
24.4 When to Use Exception Handling 897
24.5 Rethrowing an Exception 898
24.6 Exception Specifications 900
24.7 Processing Unexpected Exceptions 901
24.8 Stack Unwinding 901
24.9 Constructors, Destructors and Exception Handling 903
24.10 Exceptions and Inheritance 904
24.11 Processing new Failures 904
24.12 Class auto_ptr and Dynamic Memory Allocation 907
24.13 Standard Library Exception Hierarchy 909
24.14 Other Error-Handling Techniques 911
24.15 Wrap-Up 912

A Operator Precedence Charts 919
B ASCII Character Set 923
C Number Systems 924

C.1 Introduction 925
C.2 Abbreviating Binary Numbers as Octal and Hexadecimal Numbers 928
C.3 Converting Octal and Hexadecimal Numbers to Binary Numbers 929
C.4 Converting from Binary, Octal or Hexadecimal to Decimal 929
C.5 Converting from Decimal to Binary, Octal or Hexadecimal 930
C.6 Negative Binary Numbers: Two’s Complement Notation 932
D Game Programming: Solving Sudoku 937
D.1 Introduction 937
D.2 Deitel Sudoku Resource Center 938
D.3 Solution Strategies 938
D.4 Programming Sudoku Puzzle Solvers 942
D.5 Generating New Sudoku Puzzles 943
D.6 Conclusion 945

Appendices on the Web 946
Appendices E through I are PDF documents posted online at the book’s Companion Website (located at www.pearsonhighered.com/deitel).
E Game Programming with the Allegro C Library I
E.1 Introduction II
E.2 Installing Allegro II
E.3 A Simple Allegro Program III
E.4 Simple Graphics: Importing Bitmaps and Blitting IV
E.5 Animation with Double Buffering IX
E.6 Importing and Playing Sounds XVI
E.7 Keyboard Input XX
E.8 Fonts and Displaying Text XXV
E.9 Implementing the Game of Pong XXXI
E.10 Timers in Allegro XXXVII
E.11 The Grabber and Allegro Datafiles XLII
E.12 Other Allegro Capabilities LI
E.13 Allegro Resource Center LII
F Sorting: A Deeper Look LVIII
F.1 Introduction LIX
F.2 Big O Notation LIX
F.3 Selection Sort LX
F.4 Insertion Sort LXIV
F.5 Merge Sort LXVII
G Introduction to C99 LXXVIII
G.1 Introduction LXXIX
G.2 Support for C99 LXXIX
G.3 New C99 Headers LXXX
G.4 // Comments LXXX
G.5 Mixing Declarations and Executable Code LXXXI
G.6 Declaring a Variable in a for Statement Header LXXXII
G.7 Designated Initializers and Compound Literals LXXXIV
G.8 Type bool LXXXVII
G.9 Implicit int in Function Declarations LXXXVIII
G.10 Complex Numbers LXXXIX
G.11 Variable-Length Arrays XC
G.12 The snprintf Function: Helping Avoid Hacker Attacks XCIII
G.13 Additions to the Preprocessor XCV
G.14 Other C99 Features XCVI
G.15 Web Resources XCIX
H Using the Visual Studio Debugger CIV
H.1 Introduction CV
H.2 Breakpoints and the Continue Command CV
H.3 Locals and Watch Windows CIX
H.4 Controlling Execution Using the Step Into, Step Over, Step Out and Continue Commands CXII
H.5 Autos Window CXIV
H.6 Wrap-Up CXVI
I Using the GNU Debugger CXVIII
I.1 Introduction CXIX
I.2 Breakpoints and the run, stop, continue and print Commands CXIX
I.3 print and set Commands CXXIV
I.4 Controlling Execution Using the step, finish and next Commands CXXVI
I.5 watch Command CXXVIII
I.6 Wrap-Up CXXX
Index 947

Read More Show Less

Customer Reviews

Average Rating 4
( 13 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 11 Customer Reviews
  • Anonymous

    Posted January 12, 2000

    C How to Learn Bad Habits

    The book does not start off well at all. The author provides examples in the beginning of chapter 2 that do not even compile, because the #include <stdio.h> line is missing from all the examples. Of course, the void material is put into play in an example of integer addition & subtraction later in chapter 2. In short, the book fails in many areas of learning C in the manner it was intended by Kernighan & Ritchie. Take some good advice, purchase the 'Joy of C' if you want a book that is better suited for the beginning programmer (opinion-is-allowable).

    1 out of 2 people found this review helpful.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted January 21, 2002

    Straight Forward and to the Point

    The book is really easy to understand. It is straight forward and to the point. Most of all technical terminology is defined for the beginner. I especially appreciate the fact that the authors have mentioned that they have tried to present C in such a way to be the first computer language for beginners, despite in traditional terms, Pascal being taught as the first programming language because of it's known structured programming discipline. In my lower years of education, I have had experiences with QBasic and a little of Visual Basic. However, as a student, I would think that skipping Pascal is a plus since I tend to ask myself, 'When am I ever going to use it in life...' Students tend to question the applicable use of something that is learned. These days, Pascal is seldom used as C++ predominantly takes the stage. In sum, learning C as a foundation and first language seems to be something that will pay off. This book also includes tips and points out common pitfalls such as common programming errors, good programming practices, performance tips, and software engineering observations, which are all really helpful. If you are new to programming, this book is a must.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted October 9, 2001

    C How To Program

    I read this book 'C How To Program 3rd Ed'. Programmers say its easy to learn Visual Basic, but its easy to learn any rogramming language as long as it is 'Deiteled'. One, this book is three in one, that is it covers three programming languages in one book and in a fashion that a beginner/professional will find it very easy to read and understand. The book introduces you to C language it then detail the language with full examples and it will finish by showing you how C++ join in to this journey, it will detail again using examples that make you quickly grasp the language, finally Java will join and again the book shows you how you use what you have or dont have to Java your world. Two, in any of the covered languages it takes you to a point where you can link/connect those languages, so if you want just know about C++ and never touched C the book has a bridge already you will end up knowing both, the same for any combination of the three languages. If you just glance on chapters 3, 15 and 25 you will get an ideal of what are those bridges am I talking about. I personally liked the book because it explained clearly the foundation one needs to know to use any of the three languages, when you finish C or C++ or Java in this book and make your own program using say Java, its no gonna be a surprised to you to be able to make the same program using any of the three languages but a BIG surprise for someone who never used this book but just one day saw you reading a chapter about Java on this book. The book has made learning programming much easier and faster. I found examples are carefully designed to also be used as a good studying tool, you can also start from these examples (together with the explanations in the book) to build big professional programs. Finally I dont see the reason why the book should not be used as a reference since it has all the syntax explanations, keywords in all those three languages, quick examples showing how to use programming statements, advantages and disadvante of some operators etc.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted July 16, 2001

    Here is what I think:

    I think your book on programming is great! I have used it over and over again to answer questions as I move into learning Visual C++ and Java. The thinking skills I developed to successfully complete a class using this text are helpful all over in programming. But, I have a small problem. As I have used the book so much as a reference, it is starting to fall apart. Is there a way to get a hard-bound edition?

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted August 6, 2001

    Exceptionally good.

    I have set about learning to program in C to create course ware in my field, which is language and literature. The Deitels' book is without doubt the best book for learning C that I have found. This is saying a lot because I have bought five or six and reviewed those currently available. It is well-organized, absolutely clear, thorough and takes the reader in orderly progression from basic to difficult concepts. Unlike so many books, it explains every line of code which it uses as illustrations. This is an extremely important feature which makes the difference between comprehension and confusion. How many books have we all seen in the computing field which first give an abstract explanation and then use an example that makes use of even more advanced and as yet unexplained concepts! I will even go one step further in praise of this book: it could serve as model in pedagogy for books in other fields. In addition to a concept by concept approach in numbered paragraphs in the main body of the text, at the end of each chapter it summarizes the principal points, important terms, common programming errors, and good programming practices. Self-review exercises, answers and programming exercises follow. The appendices contain up-to-date web references, operator precedence charts, the ascii character set and number systems. The appendix on numbers goes beyond the usual inadequate coverage and explains, for example, how a binary negative number is formed and why it works. The authors are fully aware aware of the advances represented by object-oriented programming based on C and hence dedicate the second half of the book to C++ and Java and do the same masterful job they did with C. Though often overlooked in reviews, it is important to note that it is printed on excellent, semi-glossy paper that does not allow ink and highlighting to come through to the next page. Prentice-Hall has gone to the extra expense of using a combination of red and black ink with different sizes and styles of type and occasional pale red background. Though it may impress the reader as cosmetic, it certainly is not: it plays the very important role of improving learning and retention by making important points and sections stand out. I hesitate to make suggestions for future editions when the authors have done such an excelltent job, but I'm going to throw in a couple: include a chart of the new ISO character set and issue the book in hardcopy as well as soft, because this book should be considered not only a text but a reference volume which the reader will want to have on his shelf for a long time to come. As it is, the paper covers tend to curl up which shortens its life and makes shelving difficult. In conclusion, this text is not only excellent in itself but because it fills the void between 'academic' texts, which are often written to show colleages how clever we are, and commercial 'how-tos', often dumbed down, incomplete and short on conceptualization. I can confidently recommend this book to the general public and as a text book. If it is not adopted as the text for introductory courses in C, it will be for reasons other than its excellence as a teaching instrument and as a treatise on C.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted February 24, 2001

    The most complete programming guide!

    I've bought many different C programming books, but this is the most complete book I've found. Each chapter contains many tips for better programming techniques, avoiding common errors, improving programming speed and helping ensure your programs are portable. Many complete examples demonstate each subject, rather than small snipets of code commonly found in other programming books. At the end of each chapter there are lots of questions to get you to try out what you have just learned. Only half of these give answers, encouraging you to work it out for yourself. This helps improve self-study techniques and keeps the reader interested. The most important aspect of this book, though, is how it explains 'Top-down, step-wise' program design. This is one of the most important aspects of structured programming, however, many other books don't even mention this. It is obvious this book was written by programming teachers, not just programmers, because so much emphisis is placed on learning proper programming techniques.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted January 15, 2001

    Programmers beware

    I'm not sure who this book is written for, but, in my opinion, certainly not for C programmers. Not only do I view usage of language elements often wrong, advice that I interpret to the effect of 'avoid standard C usage' is liberally sprinkled throughout the text. e.g. don't embed function calls inside of other program elements 'it's only confusing' ! I think that this might possibly as a text for a course taught by a non-C programmer to students who are never going to use C (or C++ or java). But I would never choose it for a course that I taught

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted December 23, 2000

    It's darn spiffy

    This was my class textbook this semester. Thanks to it, I will get an A for the course. It brought me from C zero to C hero in three months.<BR><BR> This book is great. It will hit you with many different levels of detail. The chapters are written with such clarity, you only need to read each chapter once to understand its key concepts. Key concepts, warnings, and tips are listed twice for each chapter -- once in the back, and once in the text. I wish the ...For Dummies books did that -- listing the tips at the end of each chapter makes referencing a breeze.<BR><BR> Each sample program is explained line by line, so that you can understand how programs execute, the order of operations, precedence... etc. After about four chapters you shouldn't have trouble tracing through your programs! Their sample code is easy to read and examples build on each other. It gave me more and more confidence as I progressed through each example.<BR><BR> The sample code is written exceptionally well! The authors' style is extremely easy to read, and is extremely consistent throughout the book. It shows these guys really understand the algorithms they are coding and are REALLY comfortable with C syntax. <BR><BR> The practice problems for each chapter range from Mickey-Mouse to Really Tough! You'll get the appropriate theory, feature detail, and numerous sample programs to help work your way throught each problem -- no matter the difficulty. (except the Tower of Hanoi -- HOLY COW IT'S HARD)<BR><BR> This book deserves *****. This book will make you feel smart. Also, this book will never get in your way as these programming books often do.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted October 30, 2000

    Great Book

    The book makes C programming simple. You will be able to write a program and understand pointers much quicker than in any other book due to its great examples and illustrations.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted March 30, 2000

    Programming: How to write a text

    There are many things I like about this book. It stands as an example of how to write a programming text. It adheres to the principle, 'Tell 'em what you're going to tell 'em, then tell 'em, then tell 'em what you've told 'em.' Each chapter begins with a list of objectives and an outline, and ends with a summary and compilations of principles outlined in the chapter ( 'Common Programming Errors', 'Good Programming Practices', 'Portability Tips', 'Performance Tips' 'Software Engineering Observations'). At the end of each chapter is a set of self-review short exercises with answers, and a set of longer exercises that range in complexity from writing short blocks of code to writing complete programs (e.g. Knight's tour). Fine points of C syntax are each illustrated with short programs. (One of the other reviewers mentioned that some of the programs in chapter 2 omit some header includes, causing compilation failure. This seems to only happen for the very first couple of examples, and is discussed in section 2.3. I guess the other reviewer was using a very strict compiler. ) The writing style is clear and easy to follow (but not simplisitic or chatty). The material is laid out in a logical way. Where appropriate, diagrams and tables are included. It's a comprehensive book. It seems that every time I had a question about some potentially tricky area, I could find a discussion somewhere in the book. The last third of the book is on C++. Where C and C++ have language elements in common, these are described in the C part of the book. The C++ section describes the additional features of C++ over C, and contrasts differences in functionality between superficially similar (but different) language elements. The approach here is to regard C++ as a superset of a large part of C, as opposed to describing C++ as a language in its own right without reference to C as an ancestor. This approach works well if you are coming to C++ from C as I did. There are 5 appendices, which serve as useful reference material on C, including language syntax and standard library functions. One omission is that there isn't a corresponding guide to the C++ libraries. So you need another C++ book when you start programming in C++ in earnest. The book is well made. The pages sit reasonably flat, except near the start and the end of the book (although the spine crack has helped with that ;-)) The paper has some sheen, but not too much glare comes back. The sheen prevents highlighter ink from seeping through to the other side of the page. The paper is sturdy too, and resists dog-earing. There are 1 inch margins around the text which I like for making pencil annotations. The book stands well on a bookshelf, without flopping over if unsupported. It's a very well made book, but not quite as well made as O'Reilly's, which I regard as the current benchmark in paperback construction. I have found very few typos. It seems that many books these days come out full of bad hyphenations, mis-spellings, poor placements and so on. Deitel^2's book has been well edited and proofread. Occasionally, some figures are printed a couple of pages on from the referring text. This is a little awkward, but I can see why they did it. There are many figures illustrating well-structured code, so these are necessarily large, and need to be placed in sequence. In summary: a great book for learning C from scratch, or for going from novice to professional, or for going from C to intermediate C++. For full competency in C++, you'll need to get another book later.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted April 11, 2012

    No text was provided for this review.

Sort by: Showing all of 11 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)