Softpanorama
(slightly skeptical)
Open Source Software Educational Society
May the source be with you, but remember the KISS principle ;-)
Softpanorama Search
|
Softpanorama |
May the source be with you, but remember the KISS principle ;-)
Softpanorama Search
|
C is not very good as a first programming language. After all, you can think about C as a 'portable assembly language' but without assembler transparency and closeness to machine architecture. For more info see C Webliography.
In an ideal world there are two ways (and two major schools of teaching) to master programming which can be called "bottom-up" and "top-down" approaches:
The first school recommends that a student should first learn a simple assembly language such as (IBM 360 is simpler, but Intel assembly language is pretty arcane, but still can be used due to a large number of good books and general availability). After a student understands assembly language and do some programming in it, he/she can "go up" to a higher-level language like Pascal and only after that learn C.
The second school recommends an interpreted scripting language (Basic, Javascript, etc) as the first language. From this language student can "go down" to C or Pascal even eventually assembler.
Both schools are valid approaches but the university reality is different and actually if your first language is C you need to thank God that it's not C++ or Java ;-)
For an introductory book on C (especially high-school level book) I recommend a book that use flowcharts and figures extensively (C by Example) and has decent typographical quality (again C by Example is pretty decent, Wrox press books are also not bad). Please be aware of the recently ratified new C standard - C9X. Only books published after 2000 cover this standard.
Books with a compiler on CD are a nice way to get a decent compiler if you do not have any and use Windows. (on Linux C compiler -- gcc is free and it's more or less OK but without GUI and an integrated debugger it is less suitable for a beginner).
On Windows you either need to pay at least $49 for a Microsoft C++ standard edition (a very decent compiler suitable for beginner) or use free Borland C 2.0 or Borland C++ 1.0. Especially brave guys can try EiC -- free C interpreter that has win32 port -- interpreters are much better than compilers for beginners.
I do not recommend trying to install DJGPP for DOS on Win95 unless you really have only DOS. It makes no sense to use it in Windows environment and standard Linux contains gcc, which is probably better for beginner. Some books like Teach Yourself Data Structures and Algorithms in 24 hours come with DJGCC on the CD. Avoid it.
It's cheaper to buy a book with a Windows compiler, than two things separately. Visual C++ 6 teaching edition in included on CD of at least two books (see Sams and Wrox press books) and it's an excellent C compiler for beginners with a lot of nice features including good editor with syntax highlighting and a decent built-in debugger. If you need a compiler those books are probably preferable. Please remember that these days, most commercial C compilers are bundled into C++ compiler packages, such as Visual C++, and Borland C++ and don't be frustrated if you get C++ compiler instead of C compiler you actually wanted. It will work as C compiler for files with extension .c.
The simplest way to start learning programming in C is not to type examples from scratch, but cut and paste a suitable example from the book and then gradually modify it until it will perform what you want to accomplish. That means that book without a downloadable examples (or examples of CD) is a very bad choice. As diagnostic in C compilers is pretty bad and you should never try to type examples for which you can find a suitable prototype.
I would like to stress it again: never ever try to type your first C programs ;-). You will be very disappointed by the quality of C diagnostics. Beginner should start with working example that is similar to what he needs and gradually modify it. Again you need to understand that diagnostic is really horrible and I am not joking here. If an example you can and paste runs OK before your changes than each time you make changes you know where you can introduce an error and thus is in much better position to accomplish a task without unnecessary frustration. Please remember that programming is not about writing program, it's about modifying existing program ;-). Using prototype you will be able to compile and execute modified program probably in half of the time and with far less problems. If you use VC++ 5.0 or better than after opening existing C-file, the project will be created for you automatically.
Using examples from the book has another implicit advantage: implicitly you will copy the author style in your programs and thus be introduced to a more or less OK style of programming. In good books each example starts with a comment line that describes it. Also it uses some reasonable naming conversion and comments in the body.
In many respects C is is an assembly level language with similar traps and pitfalls. Please read C Traps and Pitfalls the only book the honestly discuss the problems with this language. It might be better to buy it as a second book than two very similar introductory level books on the subject.
Again CD or downloadable code for examples is a must (Wrox Press has freely downloadable code for all books), e-text of the book is desirable -- in this case you can include your notes into the text, search for words and phrases, etc. But you can survive without it and making notes is actually an important part of learning process and it should be made too easy :-).
Do not believe that flowcharts are obsolete -- for beginners they are tremendously important and teachers/books that ignore them put students in a very serious disadvantage. From my teaching experience I firmly believe that a beginner book based on flowcharts has huge advantage over any other approach.
Illustrations are extremely important too. Book without illustrations usually is definitely less clear and hostile to the student that book with decent illustration in almost any area of C (especially pointers). An example of decent illustrations see Chapter about pointers from Practical C Programming (Nutshell Handbook) that is available online. Again, C by Example is a nicely illustrated book.
As for intermediate-advanced books I strongly recommend K&R book. this is classic and you can always benefit from reading a book that is part of the history of programming even if some ideas are no longer relevant.
Beware of OO propaganda-based mixed C/C++ books. C is an interesting enough and complex enough language to study separately and only then move to C++, if at all . C++ is an extensible language and this extensibility present several unobvious for beginners dangers in complex programming tasks. Debugging is really difficult in C but it's even more difficult in C++.
IMHO the value of OO outside visual interfaces is questionable. And even in this narrow domain in many cases one will be much better served by combination of C and Tcl/Tk or other suitable scripting language.
Be skeptical. Suggestions below should be critically evaluated. Select carefully. Its amazing how much simpler is to learn C using really great books than to do the same average books... Do not consider yourself to be stupid if you do not understand something on the lecture or fromthe book. It might be that a completely opposite situation :-).
For obvious reasons I prefer books that have e-text available. There are several of them in www.informit.com For example Teach Yourself C in 24 Hours is pretty decent, written in a nice style.
Dr. Nikolai Bezroukov
|
You can use Honor System to make a contribution, supporting this site |
Using numerous examples, C and Unix Programming: A Comprehensive Guide explains the basic concepts of the C language by creating the C-Virtual Machine, a unique, effective approach to helping students grasp technical ideas.
Everyone from high school graduates who are interested in programming to IT professionals, scientists, researchers, and other sophisticated computer users will benefit from the techniques and examples provided.
Among its many key features, this book:
Based on 1 review. Looks like Intermediate to advanced university textbook.
I do not know much about David Brooks but David Gries was a talented
author when he was young. Later he went into verification fundamentalism
and published nothing on real value.
I hope that the book is in the style of
Primer on Structured Programming Using Pl/1, Pl/C and Pl/Ct by
Richard Conway, D. Gries, which was on of the best intro books on its time.
They start the book with explaining of basic I/O.
I see the main value of the book that it covers classic algorithms like Searching&Sorting (Ch.8), Basic statistics (Ch.9) and Binary Trees (Ch.10) and thus can be used as a intro "Algorithms and Data Structures" textbook.
Amazon.com Sales Rank: 79,328
Avg. Customer Review: *****
Number of Reviews: 1
| ***** | This is an excellent book about SPARC Assembly Language. |
June 26, 1999 |
| Reviewer: Joseph D. Bissell bissell@cis.udel.edu from University of Delaware, Newark, DE | ||
| For anyone interested in learning
about the SPARC Architecture/Instruction Set (and RISC machines
in general) this book is invaluable. It is especially useful
for optimizing iterative and decision making C/C++ constructs.
In fact, if one follows the tenets espoused in this book, one
can learn to hand optimize time-critical sections of C/C++ code
that is better than that produced by gcc or cc - the aversion
of the UNIX community to write any code in assembly language
notwithstanding.
The book really delivers what its rather verbose title implies. That is, a really outstanding feature of the text is the way in which the author translates the standard C/C++ constructs to their low-level counterparts. He does this in stages - creating a variety of examples that progress from functional but grossly inefficient code fragments up to superbly succinct variants. I have used this book in a one semester undergraduate course at the University of Delaware for three years and have also used excerpts from it when I have taught the MIPS Architecture. There is no other book that treats RISC (or CISC) architecture from Professor Paul's relational premise, with which I totally agree. Having taught INTEL stuff for 10+ years, I firmly believe that much of its content could be effectively utilized in CISC courses. The book is also used as the secondary text in the graduate compiler course at U.D. The book is not without flaws, most of which are because of an incredible number of typographical errors - I have counted over 60 just involving commas! Hopefully the new edition which I believe is due to be published soon will have been edited/typeset with more care. Also, there are some minor changes to the gnu software (gdb and gcc) that need to be upgraded. |
||
|
|
Very well written Data Structures text!Reviewer: A reader from USA |
May 28, 1999 |
| This is an incredibly rich Data Structure text presented in a easy to read and straightforward manner. The text layout is appealing to the eye with lots of supporting pictures, diagrams, tables, Pseudocode algorithms, and program code. The Pseudocode is general for any language yet closely relates to C. The program code is in C. The Pseudo code logic covers all data structures very well. ~J Franzmeier | ||
Based on 186 reviews.
Write a review. Classic book. For example, the very first exercise given is to print "hello, world" became a standard way of introducing new language in a programming books. Not for the beginner, you need to know well at least one other language before reading this book. Might serve as a quick reference too. Written when memory was expensive, hence it takes all the short cuts to save storage. Therefore some examples (hort implementation of famous UNIX commands) are no longer represent recommended way of coding them.
The classic text, but there are better books., August
28, 2003
If you want to know what went on in the designers mind in the creation of C, get this book. If you need a tutorial about C, there are better choices. |
not the best, June 26, 2002
for this K&R's book, one thing i don't understand is that they seem to be obssessed with using string processing functions as examples. the matter of fact is, the C standard library does a lousy job processing strings: most of the string processing functions are type unsafe and tedious to use. as for why C is so popular (hence this book), one is because
C is relatively easy to learn and use, compared with C++, ML
etc. the other reason is that unix and most unix libraries are
written in C. but with virtual machine around the corner, it's
time to move one level up. even though i use C all the time
for writing compilers and kernel drivers, other languages like
java/ ML/ python/ lisp are much more fun to use. |
Great Reference Book, Beginners Look Elsewhere, October
30, 2002
|
A great Bible. Not a great tutorial., June 28, 2003
If you have no programming experience than I do not reccommend
this as your first book. Get a more introductory book first
and then dive into the K&R book. |
[alt.comp.lang.learn.c-c++] - FAQ list
16: Why do many experts not think very highly of Herbert Schildt's books? A good answer to this question could fill a book by itself. While no book is perfect, Schildt's books, in the opinion of many gurus, seem to positively aim to mislead learners and encourage bad habits. Schildt's beautifully clear writing style only makes things worse by causing many "satisfied" learners to recommend his books to other learners. Do take a look at the following scathing articles before deciding to buy a Schildt text. http://www.lysator.liu.se/c/schildt.html http://herd.plethora.net/~seebs/c/c_tcr.html The above reviews are admittedly based on two of Schildt's older books. However, the language they describe has not changed in the intervening period, and several books written at around the same time remain highly regarded. The following humorous post also illustrates the general feeling towards Schildt and his books. http://www.qnx.com/~glen/deadbeef/2764.html There is exactly one and ONLY one C book bearing Schildt's name on its cover that is at all recommended by many C experts - see Q 25.
| Absolute Beginner's Guide to C | C Programming in 12 Easy Lessons |
I think programming is easier that it looks to folks who haven't tried it, and I enjoy trying to make programming more approachable for beginners. My primary interest and motivation in writing lies in finding better ways to communicate the ideas -- to simplify them as much as possible, and to put them in an understandable context. I get a real kick out of every reader that writes in to Wrox saying they thought one of my books was great.
tony@pittarese.com from Pensacola, FL , November 10, 1998
Generally a good beginning text
I've taught C classes using this as the textbook and find the students generally receptive to the book. As a previous reviewer mentioned some of the things the author does (such as define main with a void return type) are not correct, and he picks up the pace of coverage significantly in difficult areas such as pointers.If you do buy this book, buy a good reference book such as "The C Programming Language" by Kernighan and Ritchie to go with it. Many library functions are not well documented in the Horton book.
If you know nothing about C and want to pick it up on your own, this book is one of the best I've seen at making it approachable. Its few errors are just (relatively) minor annoyances.
This is an excellent book for a 15 years old. BTW pretty large subset of C is covered... More advanced and more suitable for high school is C by Example that was published 1993.
NO LONGER A BEGINNER
I read this book, and shortly after began my own little business of C/C++ programming! This book is excellent, and if you use it right, can help you in many ways!
| C: Step-by-step | Beginning C |
Paperback - 629 pages (April 1989)
Sams; ISBN: 0672226510 ; Dimensions (in inches): 1.10 x 9.17 x 7.39
Amazon.com Sales Rank: 106,932
Avg. Customer Review:
Number of Reviews: 2
Table
of Contents
| Preface | ||
| Acknowledgements | ||
| Trademarks | ||
| 1 | C and Programming | 1 |
| 2 | Introducing C | 21 |
| 3 | Data and C | 45 |
| 4 | Character Strings and Formatted Input/Output | 77 |
| 5 | Operators, Expressions, and Statements | 113 |
| 6 | C Control Statements: Looping | 151 |
| 7 | C Control Statements: Branching and Jumps | 197 |
| 8 | Character Input/Output and Redirection | 239 |
| 9 | Functions | 273 |
| 10 | Arrays and Pointers | 313 |
| 11 | Character Strings and String Functions | 353 |
| 12 | File Input/Output | 395 |
| 13 | Storage Classes and Program Development | 429 |
| 14 | Structures and Other Data Forms | 465 |
| 15 | Bit Fiddling | 507 |
| 16 | The C Preprocessor and the C Library | 529 |
| App. A - Additional Reading | 569 | |
| App. B - C Operators | 571 | |
| App. C - Basic Types and Storage Classes | 579 | |
| App. D - Expressions, Statements, and Program Flow | 583 | |
| App. E - ASCII Table | 591 | |
| App. F - Standard I/O Functions (ANSI C) | 595 | |
| Answers to Odd-Numbered Review Questions | 599 | |
| Index | 617 |
You can read an interview with Ira Pohl.
Good but expensive... It is a university type book and not very suitable for high school students. If you solve the exercises (and they are doable) you will be on a decent level of mastering the language (libraries are quite a different story). Only 593 pages devoted to C and that diminish the value of the book -- the second part of the book is essentially useless and diminish the value -- there are plenty of C++ and Java books on the market. On a positive side it provides the useful introduction to pointers and pointer arithmetic. The examples are well integrated into the flow of presentation, and it is well indexed (it is an excellent reference book).
As you can see from Amazon.com rank it's very popular...
| Preface | ||
| Ch. 0 | Starting from Zero |
1 |
| Ch. 1 | An Overview of C |
5 |
| Ch. 2 | Lexical Elements, Operators, and the C System |
69 |
| Ch. 3 | The Fundamental Data Types |
107 |
| Ch. 4 | Flow of Control |
147 |
| Ch. 5 | Functions |
197 |
| Ch. 6 | Arrays, Pointers, and Strings |
245 |
| Ch. 7 | Bitwise Operators and Enumeration Types |
331 |
| Ch. 8 | The Preprocessor |
365 |
| Ch. 9 | Structures and Unions |
407 |
| Ch. 10 | Structures and List Processing |
447 |
| Ch. 11 | Input/Output and the Operating System |
493 |
| Ch. 12 | Advanced Applications |
555 |
| Ch. 13 | Moving from C to C++ |
593 |
| Ch. 14 | Moving from C to Java |
625 |
| App. A | The Standard Library |
641 |
| App. B | Language Syntax | lore. There is a very minimal amount of code in the book. Learning the correct way to free a singly-linked list and how to declare arrays and function pointers is by no means in the "expert" category in my opinion. Much of the material in this book is presented in a first semester course on programming and all of the topics that are superficially covered in this tiny book are better explained in other books.
|
Why I wrote "The C/Unix Programmer's Guide", April 8,
1999
I've programmed on many different platforms over the past
18 years, and C and Unix provide the most enjoyable environment
I've found. I hope you'll find this book helpful in getting
you into Unix programming, so you can share in the experience!
|
|
| ***** | Right on Target |
March 10, 2000 |
| Reviewer: Geoff Thornton (see more about me) from Oakey, Australia | ||
| I have been learning C++ for a while on a linux platform, and started to look at some C stuff in the kernel and other programs to broaden my knowledge. I saw that that although C++ is derived from C it doesn't necessarily do stuff the same way, so I picked up this book. It was right on the mark! and explained some peculiar C stuff right away and in a good easy to read style. It consolidated my knowledge well an added to my understanding, particularly with pointers to pointers by including well thought out text and pictures well done. It also provides a good tutorial into basic GCC usage and the peculirities of programming for Linux, I recomend it. | ||
| ***** | EXCELLENT TUTORIAL |
February 25, 2000 |
| Reviewer: David van Popering (see more about me) from Long Island | ||
| Aside from teaching myself BASIC
on my Commodore 64 way-back-when...this is the first programming
language I have learned and I owe it all to this book. It is fantastic.
Step-by-step, they take you from defining/describing what C is,
to writing real-world programs.
You would do well to ignore the ignorant reviewers who complain about the title "21 days" (or 24 hours). These people are only looking for excuses. All the 'Teach yourself in 21 Days' books should be seen as 21 LESSONS (and the 24 hours as 24 LESSONS). Could I do it in 21 days? Yes, following the book's plan I could. Easily. But, I have a full time job, family, etc. and these factors can NOT be held accountable by the authors. 21 Excellent Lessons. Days, Hours, months...whatever YOUR pace is, this book does an EXCELLENT job of teaching you what you need to know to write real-world, practical C Programs. I first learned Unix with using of the 'Teach yourself' books and have been a devoted reader ever since. Some days I have time to go through 2 lessons while other times a single lesson may take me a day or 2 due to time constraints. Bottom line: I LEARNED C FROM THIS BOOK AND YOU CAN TOO. I am NOT a computer science major. I am a self-taught Linux hacker who never wrote a line of code (except for a little BASIC 15 years ago) and I am now writing C code and tinkering with Open Source programs. (I'm running Slackware and Debian, if you were wondering). Other tutorials are fine but many assume you are using Windows 95/98. "C is C is C", but this book is written in 'Linuxland' for Linux users; GCC is carefully explained and used here. I use and love the Nedit editor which was one of several recommended in the book. New to C? Or want a fresh start from the beginning while in a Linux environment? GET THIS BOOK and digest all 21 LESSONS at your own pace! |
||
I got an "A" in my C course. And I used 5 text books. The ONLY textbook that really helped was Alcock's "Illustrating C". It uses diagrams in a truly "revolutionary" way that really helps understanding. It's like moving from black and white to colour. The intention is to provide the student with a set of course notes, complete with instructor black-board diagrams -- only better. It really works. It's enjoyable. Did I mention I got an "A"? I hope that other textbook writers pick up on Mr. Alcock's unique style! Bravo
Table of Contents
Preface 1 Introduction 1 2 Concepts 11 3 Components 27 4 Control 51 5 Organization 65 6 Pointers, Arrays, Strings 79 7 Input, Output 107 8 Structures, Unions 125 9 Dynamic Storage 143 10 Library 163 11 Summaries 195 Bibliography 209 Index 210
(see also Tcl/tk books -- Tcl has excellent interface with C (that can be viewed as an advanced C library) and is the best tool to use in complex projects -- IMHO combination of C and TCL in many cases is much better and more powerful that C++)
Home page for C Interfaces and Implementations
This is the most impressive advanced C book. Devid Hanson is the
author of
lcc A retargetable C compiler (with
Chris Fraser, the author of
copt, a simple, retargetable peephole optimizer).
Please visit the author Home page
Reviewer: tqbf@pobox.com from San Francisco, CA August 4, 1999
Clearly written and well organized, this book presents more than 20 _highly_ useful library interfaces for containers, string management, mathematics, and memory management. There isn't a line of code in the whole book that you couldn't take and use, verbatim, in a project today --- after reading this book, you'll probably never have a compelling reason to write a string library or a hash table interface again.More importantly, though, each example library illustrates ways to effectively design consistant and useable library interfaces, from generic ADTs to system service wrappers. After reading this book, you'll not only have an arsenal of useful code to leverage, but also a good understanding of how to design clean, modular, reuseable components for your application.
Hanson's C code is extremely clear and concise. Even if you've been programming professionally for a long time, you are likely to pick up a useful technique or two just by reading the source code in the book. If you're not very experienced, you will learn about C programming idioms that will be valuable to you in future work.
I really like how this book, and Hanson's other book ("A Retargetable C Compiler: Design and Implementation") are put together. Hanson employs Literate Programming techniques to weave the code he's discussing together with his discussion. This makes it very simple to track what portions of the code are being talked about at any point
Reviewer: Defang Zhou (dzhou@zoo.uvm.edu) from Vermont, USA July 15, 1999
This book is a highway leading you form toy project to real-life project. The author told you exactly what you want when you programming. The book detailed a lot of tricky stuff which would haunted you for a long time before you read this book.
Unfortunately amazon.com does not provide the table
of contents for the book, which is pretty impressive. Here is a very compressed TOC:
Part I: The C Language
Revisited ..... 1 1: C Programmer Unleashed! ..... 3 2: Holy Wars: Programming
Standards-Causes and Cures ..... 21 3: Optimization ..... 75 4: Dealing
with Dates ..... 113 5: Playing with Bits and Bytes ..... 131 6: Offline
Data Storage and Retrieval ..... 161 7: When Things Go Wrong: Code-Mending
..... 203 8: Managing Memory ..... 259 9: Simulations and Controllers
..... 299 10: Recursion ..... 315
Part II: Data
Organization ..... 341 11: Simple Abstract Data Structures ..... 343 12: Binary Search
Trees ..... 455 13: Rapid Sorting Techniques ..... 507 14: Tries .....
571 15: Sparse Matrix ..... 591 16: Working with Graphs ..... 641
Part III: Advanced
Topics ..... 709
17: Matrix Arithmetic ..... 711 18: Digital Signal Processing .....
759 19: Expression Parsing and Evaluation ..... 839 20: Making Software
Tools ..... 911 21: Genetic Algorithms ..... 977 22: Cross-Platform
Development: Communications Programming ..... 1001 23: Writing Common
Gateway Interface (CGI) Applications in C ..... 1053 24: Arbitrary Precision
Arithmetic ..... 1087
As one can see the book covers a wide range of topics including such forgotten in programming things as optimization of code and expression parsing and evaluation. Some topics like sorting, searching, tries, graph algorithms actually belong to a typical algorithms and data structure course. But the book covers them much more realistically. Examples are written in a very decent style using the latest version of the language and are quite useful.
And for such amount of information the price is very good.
All-in all this is a rare solid C book in the current C++ oriented world and I highly recommend it for developers and university students.
Focuses on portable programming, providing code that is useful across all platforms, including mainframes
CD-ROM contains arbitrary precision math and matrix math libraries, tree and sorting libraries, debugging trace routines, Julian date conversion routines, memory allocation tracking source code, DJGPP compiler and a draft of the new C9X standards
Book Info
Presents focused explanations of the core features and complexities
of C, including optimization and performance, handling I/O streams,
managing memory, debugging and diagnostics, trees and advanced data
structures, matrix arithmetic, digital signal processing, encryption,
and more. Softcover.
Table of Contents
Very good, not perfect, July 23, 2000
The BEST C book this C programmer has ever read!, January 26,
1998One of the best C/C++ books I've encountered. For a more detailed review, please see my Devil's Advocate column in UNIX Reveiw/Performance Computing Feb'99
IMHO system programming now became to a large extent network programming
UNIX Network Programming: Interprocess Communications (Volume 2) -- W. Richard Stevens; Hardcover
Based on 60 reviews.
Write a review. 
Interesting but not oustanding., July 30, 2003 | Reviewer: secretbearer (see more about me) from San Diego, CA United States |
However, the author suffers from being a compiler-writer who doesn't really understand the design philosophy of the C language. This is the same afflication that Bjarne Stroustroup and other language designers suffer from. For example, he complains that only 3% of switch statements in his own compiler have case statement fall-throughs, therefore "We conclude that default fall-through on switches is a design defect in C." (p. 38). This is a rant of a dangerous person. Two underlying concepts of the C language are, "No hidden instructions generated where I cannot see them," and "When in doubt, provide open operators for maximum expressiveness - do not restrict expressiveness". Just because this particular compiler-writer lacks the inventiveness to do interesting things with a switch statement he proposes to force his biases upon the rest of the world. I have seen and written macro libraries that allow you to suspend & resume function calls, and these libraries perform fall-through 100% of the time. Therefore, this book is in error and the author is a victim of his own lack of creativity.
Another thing I disliked was a tendency to try to impress the reader with irrelevant facts that are not germane to the subject, such as typos in the ANSI C standard or tired-out stories on how to burn out IBM PC displays. These things are irrelevant and do not belong within the book.
I recommend you check out the book from a library (as I did) and please do not waste your money on this book.
Based on 26 reviews.
Write a review. It might be a bad time for good reference books. I have found its index to be inadequate. One interesting review from Amazon.com states that it's a very difficult task to write a decent reference book -- you need to compete with web sites that have much better searching and hyperlinking than the book.
Still Guy Steele is a unique author and the book worth reading.
A reference + more, September 14, 2003 | Reviewer: Gerry (see more about me) from Perth, Western Australia |
One thing that I did not expect before receiving this book was the amazing language overview that comes with the book, they could have sold the book with just that part and it would have still been great. The overview goes into great detail and is really good at pointing out things that other C books miss and the fact that the author is well versed on all the features of the latest C99 Standard adds even more to the wealth of information. My favorite part of the book is the part on the C Pre-processor, which had a great deal of information that I was not previously aware of.
Apart from that, there is the reference side which has all the detail you could ever want in a standard library reference book, all in a very simple to search format (Oh yeah and I should mention, the index kicks ....).
So long story short, if you want a single book that you can turn to for 99.9% of your standard C problems, divorce your wife and give that spot in your bed to "C: A Reference Manual (5th Edition)"... or 6th if it's out by the time you read this review.
ps. If your looking for this book in a bookstore make sure the lady types in "C: A Reference Manual (5th Edition)" and not "See: A Reference Manual (5th Edition)", long story, I'll tell you another time.
Here is counterview:
Despite the rave reviews, I found this book rather disappointing. It reads like the ISO/ANSI official language grammar, that is, JUST THE FACTS AND IN TECHNICAL TERMS ONLY, with very few examples of how to use the language constructs. If this is your only C reference, then your in for some long hours at the computer. I would only recommend this book if you have an additional C reference manual that shows examples of how to use a construct. This book only gives you the technical definition
for the construct i.e. parameters and return values along with unnecessary technical jargon in 90 percent of the book.
It is an ok REFERENCE book if you don't have the official ISO/ANSI C grammar lying around. But look elsewhere for how to use the grammar productions effectively!
- Here is another review that I got directly from a reader (it does not answers the question of closeness to ISO/ANSI official document raise in the prev review, though):
- I totally disagree on the reviews you quoted from Amazon.com. Don't forget this book is written as a reference manual. As such, it is assumed that the readers should have some fundamental knowledge of C. That is also why it is written the way it is.
I have been using the 3rd edition of the book for quite a while now. Since buying the book, I have never had the need to turn to any other books. I think this book thoroughly deserves the rave reviews that it received. It certainly deserves more than the 3 stars you gave it.
Like all C programmers, I keep a copy of K&R's C book on my bookshelf just in case. But I haven't turned to it since I bought "C : A Reference Manual". It has been widely discussed on the Net about the K&R C book, and it is universally accepted as a very terse book - not very readable, especially for beginners. Written by the inventors of the language, of course it is
natural to regard it as the definitive reference. But it doesn't necessarily make it a better book than the others. I think as a C book, it probably only deserves 3 stars!
Based on 12 reviews.
My 2nd C Book, November 13, 2002 | Reviewer: VANCE CHEN (see more about me) from Boston, MA |
Chapter 1~5:
Introduce the essential concepts you have to know about C (data type,
flow control, expression etc.) in great detail.
I like chapter 3 most. It explains the concepts about scope, linkage,
storage and the "static" keyword very clearly. (those are what confused
me when I read my 1st C book)
Chapter 6:
A must read chapter, "pointers".
Chapter 7~10:
Covers functions, arrays, strings, structures etc. with pointer related
issue.
Those chapter will let you be more familiar with how to apply pointers
on them.
Chapter 11:
Special topic on memory allocation. In normal C textbook you won't see
a specific chapter dealing with this.
Chapter 12, 13:
Advanced pointer concepts with structures, functions including
pointer to pointer, void pointer, pointer to function etc. Very important
and useful contents.
Chapter 14~18:
I don't like this part. Even if those chapters cover the preprocessor,
I/O, standard library, data structures, and runtime issue, the author
doesn't give enough examples to illustrate them very well. For example
in section 16.5, the author talks about the Signals (in standard library).
However, he just gives the concepts and tells us how to use them but
without A example!!!
If you have dealt with OS, you should know signals are very important
and never easy to handle. Without a example, how could readers understand
the usage and the ideas for them.
This is a very good book for sure.
It points out the common programming error, tips and the differences
between K&R C and ANSI C.
However, the only thing I am disappointed with this book is "a good
start, but not a very good end". Those latter chapters really show the
concepts we need to know but without sufficient examples to demonstrate
them out.
Even if the title of the book is "Pointers on C", it doesn't talk about the pointer all through this book. Instead, it just puts more emphasis on pointers and teaches you C.
The best book on C in print, April 11, 2002
The author also endeavors to organize the C code for those who are going on to study C++ and the accompanying object-oriented approach to programming. In addition, he emphasizes how to write C code so as to make it more portable. For those writing commercial applications in C that must be used on different platforms, this is a very important issue of course. Particularly well-written is the author's discussion on the storage class of a variable, noting, for those such as I who are pre-disposed to using recursion, that the formal parameters to a function cannot be static if recursion is to be supported. The book is full of examples such as this that give readers insight on the workings of C that fit their particular programming style. He does discuss 'goto' statements in relation to function scope and in C statement structures, but, thankfully, recommends such statements never be used. He gives an interesting counterexample to those who say that goto statements must be used to break out of nested loops. Also, the author discusses the difference between L- and R-values, and this is not usually included in beginning books on C. Dynamic memory allocation has been at times a somewhat painful aspect of programming in C, but the author shows how to do straightforwardly in the book. Having a book like this that is predominantly about pointers is quite a blessing for those who are inexperienced with them or for more experienced programmers who are still uncomfortable with their use. It is not uncommon these days to have to write programs in one's professional work that involve triple pointers or even quadruple pointers. In addition, for embedded systems programming, the use of pointer arithmetic is almost mandatory. This also is true for writing applications in cryptography using C. The author does pay careful attention to pointer arithmetic in the book. The performance pay-off for using pointers is undeniable, and so a thorough knowledge of their use and pit-falls is of upmost importance for those C programmers who are involved in writing performance-sensitive applications. The author discusses in detail what can happen when pointers are misused and gives many examples of what to avoid and good hints for the proper use of pointers. He recommends against the use of the 'null' pointer in array searching, and recommends a strategy for circumventing them. Some very helpful diagrams are given for explaining pointer expressions. In addition, the author gives helpful hints on when to use pointers and not subscripts when manipulating arrays in C. The performance issues involved in this are extremely important in scientific programming using C. The author gives a very interesting example of the differences in performance using pointers involving a program to copy the contents of one array into another. Arrays of pointers, useful in data mining applications, are also given ample treatment in this book, and the author addresses the issue of when to use a matrix instead of an array of pointers. The author also gives an effective presentation of functions in C, particularly the construction of recursive functions, and he employs some useful diagrams to illustrate how the variables in a recursive function call change on the stack. The performance hit experienced by using recursion versus iterative loops is discussed in a standard way via the Fibonacci series. Those readers raised in the functional programming paradigm will want to pay notice these performance issues when using C to do recursion. Along the same lines, the author shows how to implement functions with variable argument lists in C. This is another topic that is frequently passed over in beginning books on C. The author's treatment of data structures in C is also very nicely done, and he includes again a topic not usually treated in beginning books on C, namely the concept of a self-referential data structure. These are very important in applications in artificial intelligence, and the author shows how to implement them in C using a data structure that points to itself. This leads to a discussion of incomplete declarations. Very helpful diagrams are used again to discuss how to access members of data structures and how to point to data structures. Bit fields, so often used in embedded system applications, are also given a detailed treatment. |
| You must read this book. |
December 27,
1999 |
| Reviewer: A reader from Plano, Texas | |
| If you program in C or C++, you must read this book if you want to consider yourself a superior programmer. If you are a college student, definitely read this book. Koenig fills in a lot of gaps left by authors of introductory books on C or C++. Why do I mention C++? Because C++ is far more than just objects and classes. The lower level implementation of functions is still basically C programming. He includes chapters on linkage, the preprocessor, and portability. It is a short book that is definitely worth reading. | |
| A rare and unusual book for experienced programmers. |
July 23, 1999 |
| Reviewer: A reader from Cambridge, MA | |
| Along with Holub's 'The C Companion', this is one of the few programming books that I've read in 13 years of C programming that talks about real programming issues instead of simply rehashing what a for loop is. A must read for C programmers. | |
| Enormously entertaining and exceedingly helpful! |
May 13, 1997 |
| Reviewer: A reader | |
| This is among the five "must
have" books on the astute C programmer's bookshelf. Actually,
it spends little time on the shelf since one refers to it time
and time again. This slim volume packs a lot of information
about those "gotchas" that still "getcha" (when you least expect
it). The Introduction is "Chapter 0", your first hint that Koenig
knows and respects the subject. His treatment of unscrambling
complex declarations is especially good.
Why a 9 instead of a 10? Simple. Andy: please release a new version! The ANSI/ISO standard is almost ten years old. :) |
|
Paperback -
466 pages Bk&Cd Rom edition (January 26, 2000)
Microsoft Press; ISBN:
0735608865 ; Dimensions (in inches): 1.37 x 9.23 x 7.35
Amazon.com Sales Rank:
5,640
Avg. Customer Review:
Number of Reviews:
10
|
|
Do you aspire to be a serious developer? If so, read this bk |
March 11, 2000 |
| Reviewer: Osiris Pedroso (see more about me) from SF Bay Area | ||
| John Robbins did a great job
on this book. I was very impressed both on the depth and breadth
of the issues treated.
At first, I though on skipping the chapter on Visual Basic debugging, since I am strictly a VC++ developer, but I am glad I did not. Even that chapter gave me insights that I can use on my day to day, for example, when he runs the VB compiler while in the debugger and is able to see how VB uses the C compiler's code generation (second pass). Some great insights and lots of good example on how to resolve problems and how to use all the capabilities of the debugger to ones best advantage. It will teach you what to do when the debugger gets you to a source line that before that line, everything is working properly, after that line the world has turned upside down. It will teach you enough X86 assembly to make you dangerous and be able to read between the (source) lines in the process. Even if you thought you knew it already. Could it be improved ? Yes, can't it always ? Coverage on tracking memory leaks could be expanded, for example, to cover MFC's shortcomings when reporting them, but this book is a close to perfection as I have seen them. And it is a great read too. His style is easy to follow, even though some of the subjects are deep and complex, but John transfers the knowledge so easily, it is amazing. Once I completed my first read, I really felt like I had just finished listening to a very good rendition of a Beethoven or Mozart simphony. Every developer that aspire to be a serious developer should read it and reread it. And thank you, John Robbins. I will be buying every book you write. |
||
| 7 of 8 people found the following review helpful: | ||
|
|
Good, but could be even better |
March 5, 2000 |
| Reviewer: EJ Bartelds from Rotterdam, The Netherlands | ||
| When I first heard John Robbins
was writing a book on Win32 debugging, I was delighted. I've
been a fan of his MSJ Bugslayer articles since the beginning,
and John's debugging knowledge, displayed in those articles,
has helped me tremendously.
However, for someone who has read all his MSJ work, this book is a bit of a disappointment. The reason is that the second part of the book is a collection of his (slightly-rewritten) MSJ articles, with almost no new content added as far as I can see. The first part of the book, however, is worth every dollar, as other reviewers have already mentioned, even though I was missing coverage of the WinDbg debugger, and MS tools such as userdump. Maybe in a second edition? To summarize, I suspect this book to be a 5-star for anyone who is fairly new to debugging and has not read John's MSJ columns. For others, who have been exposed to his columns, and have some experience, I'd rate this book 3-stars. |
||
| ****Helps you find the code you need |
February 6, 1999 |
| Reviewer: clif@cflynt.com (see more about me) from Dexter, MI | |
| The C/C++ Users Group has been
collecting source code and making it available for the past
15 years. The trick has been finding the package that has what
you need. This book makes a big dent in solving that problem.
It contains brief descriptions of hundreds of C and C++ programs,
libraries, and documentation, indexed by keyword, type of functionality,
OS/CPU and title. Along with the book is a CD-ROM containing the complete C Users Group code distributions with HTML indexes to direct users to the package they need. These indexes and HTML pages make the difference between 400 packages of data, and 400 packages of information. The range of code available is astounding. It ranges from AI toolkits to compression utilities, from DOS TSR toolkits to Unix utilities from games to ray-tracing image generation, and almost anything else you can name. Most important, you can find the code you need. |
|
Copyright © 1996-2009 by Dr. Nikolai Bezroukov. www.softpanorama.org was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. Submit comments This document is an industrial compilation designed and created exclusively for educational use and is placed under the copyright of the Open Content License(OPL). Site uses AdSense so you need to be aware of Google privacy policy. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine.
Disclaimer:
Last modified: August 10, 2009
Based on 8 reviews.