WIXLIB

Our approach is possible only because C , and our understanding of it, has had time tomature. That maturity has let us ignore many of the low-level ideas that were the mainstayof earlier C programs and programmers.The ability to ignore details is characteristic of maturing technologies. For example, earlyautomobiles broke down so often that every driver had to be an amateur mechanic. It wouldhave been foolhardy to go for a drive without knowing how to get back home even ifsomething went wrong. Today's drivers don't need detailed engineering knowledge in orderto use a car for transportation. They may wish to learn the engineering details for otherreasons, but that's another story entirely.We define abstraction as selective ignorance—concentrating on the ideas that are relevant tothe task at hand, and ignoring everything else—and we think that it is the most importantidea in modern programming. The key to writing a successful program is knowing whichparts of the problem to take into account, and which parts to ignore. Every programminglanguage offers tools for creating useful abstractions, and every successful programmerknows how to use those tools.We think, abstractions are so useful that we've filled this book with them. Of course, wedon't usually call them abstractions directly, because they come in so many forms. Instead,we refer to functions, data structures, classes, and inheritance—all of which areabstractions. Not only do we refer to them, but we use them throughout the book.If abstractions are well designed and well chosen, we believe that we can use them even ifwe don't understand all the details of how they work. We do not need to be automotiveengineers to drive a car, nor do we need to understand everything about how C worksbefore we can use it.CoverageIf you are serious about C programming, you need to know everything in this book—even though this book doesn't tell you everything you need to know.This statement is not as paradoxical as it sounds. No book this size can contain everythingyou'll ever need to know about C , because different programmers and applicationsrequire different knowledge. Therefore, any book that covers all of C —such asStroustrup's The C Programming Language (Addison-Wesley, 2000)—will inevitably tellyou a lot that you don't need to know. Someone else will need it, even if you don't.On the other hand, many parts of C are so universally important that it is hard to beproductive without understanding them. We have concentrated on those parts. It is possibleto write a wide variety of useful programs using only the information in this book. Indeed,one of our reviewers, who is the lead programmer for a substantial commercial systemwritten in C , told us that this book covers essentially all of the facilities that he uses in hiswork.Using these facilities, you can write true C programs—not C programs in the style ofC, or any other language. Once you have mastered the material in this book, you will knowenough to figure out what else you want to learn, and how to go about it. Amateur telescope

makers have a saying that it is easier to make a 3-inch mirror and then to make a 6-inchmirror than to make a 6-inch mirror from scratch.We cover only standard C , and ignore proprietary extensions. This approach has theadvantage that the programs that we teach you to write will work just about anywhere.However, it also implies that we do not talk about how to write programs that run inwindowing environments, because such programs are invariably tied to a specificenvironment, and often to a specific vendor. If you want to write programs that will workonly in a particular environment, you will have to turn elsewhere to learn how to do so— butdon't put this book down quite yet! Because our approach is universal, you will be able touse everything that you learn here in whatever environments you use in the future. By allmeans, go ahead and read that book about GUI applications that you were considering—butplease read this one first.A note to experienced C and C programmersWhen you learn a new programming language, you may be tempted to write programs in astyle that is familiar from the languages that you already know. Our approach seeks to avoidthat temptation by using high-level abstractions from the C standard library right fromthe start. If you are already an experienced C or C programmer, this approach containssome good news and some bad news—and it's the same news.The news is that you are likely to be surprised at how little of your knowledge will help youunderstand C as we present it. You will have more to learn at first than you might expect(which is bad), but you will learn more quickly than you might expect (which is good). Inparticular, if you already know C , you probably learned first how to program in C, whichmeans that your C programming style is built on a C foundation. There is nothing wrongwith that approach, but our approach is so different that we think you'll see a side of C that you haven't seen before.Of course, many of the syntactic details will be familiar, but they're just details. We treat theimportant ideas in a completely different order from what you've probably encountered. Forexample, we don't mention pointers or arrays until Chapter 10, and we're not even going todiscuss your old favorites, printf and malloc, at all. On the other hand, we start talking aboutthe standard-library string class in Chapter 1. When we say we're adopting a new approach,we mean it!Structure of this bookYou may find it convenient to think of this book as being in two parts. The first part, throughChapter 7, concentrates on programs that use standard-library abstractions. The secondpart, starting with Chapter 8, talks about defining your own abstractions.Presenting the library first is an unusual idea, but we think it's right. Much of the C language—especially the harder parts—exists mostly for the benefit of library authors.Library users don't need to know those parts of the language at all. By ignoring those partsof the language until the second part of the book, we make it possible to write useful C programs much more quickly than if we had adopted a more conventional approach.

Once you have understood how to use the library, you will be ready to learn about the lowlevel facilities on which the library is built, and how to use those facilities to write your ownlibraries. Moreover, you will have a feeling for how to make a library useful, and when toavoid writing new library code altogether.Although this book is smaller than many C books, we have tried to use every importantidea at least twice, and key ideas more than that. As a result, many parts of the book referto other parts. These references look like §39.4.3/857, which refers to text on page 857 thatis part of section 39.4.3—or at least it would do so if this book had that many sections orpages. The first time we explain each idea, we mention it in bold italic type to make it easyto find and to call your attention to it as an important point.Every chapter (except the last) concludes with a section called Details. These sections servetwo purposes: They make it easy to remember the ideas that the chapter introduced, andthey cover additional, related material that we think you will need to know eventually. Wesuggest that you skim these sections on first reading, and refer back to them later asneeded.The two appendices summarize and elucidate the important parts of the language andlibrary at a level of detail that we hope will be useful when you are writing programs.Getting the most out of this bookEvery book about programming includes example programs, and this one is no different. Inorder to understand how these programs work, there is no substitute for running them on acomputer. Such computers abound, and new ones appear constantly—which means thatanything we might say about them would be inaccurate by the time you read these words.Therefore, if you do not yet know how to compile and execute a C program, please visithttp://www.acceleratedcpp.com and see what we have to say there. We will update thatwebsite from time to time with information and advice about the mechanics of running C programs. The site also offers machine-readable versions of some of the example programs,and other information that you might find interesting.AcknowledgmentsWe would like to thank the people without whom this book would have been impossible. Itowes much of its form to our reviewers: Robert Berger, Dag Brück, Adam Buchsbaum,Stephen Clamage, John Kalb, Jeffrey Oldham, David Slayton, Bjarne Stroustrup, AlbertTenbusch, Bruce Tetelman, and Clovis Tondo. Many people from Addison-Wesleyparticipated in its publication; the ones we know about are Tyrrell Albaugh, Bunny Ames,Mike Hendrickson, Deborah Lafferty, Cathy Ohala, and Simone Payment. Alexander Tsirischecked the Greek etymology in §13.2.2/236. Finally, the idea of starting with high-levelprograms grew over many years, stimulated by the hundreds of students who have satthrough our courses and the thousands of people who have attended our talks.Andrew KoenigBarbara E. MooGillette, New JerseyJune 2000

To our students,who taught ushow to teach.

0Getting startedLet us begin by looking at a small C program:// a small C program#include iostream int main(){std::cout "Hello, world!" std::endl;return 0;}Programmers often refer to such a program as a Hello, world! program. Despite itssmall size, you should take the time to compile and run this program on your computerbefore reading further. The program should writeHello, world!on the standard output, which will typically be a window on your display screen. If you havetrouble, find someone who already knows C and ask for help, or consult our Website,http://www.acceleratedcpp.com, for advice.This program is useful because it is so simple that if you have trouble, the most likelyreasons are obvious typographical errors or misconceptions about how to use theimplementation. Moreover, thoroughly understanding even such a small program can teacha surprising amount about the fundamentals of C . In order to gain this understanding,we'll look in detail at each line of the program.0.1 CommentsThe first line of our program is// a small C program

The // characters begin a comment, which extends to the end of the line. The compilerignores comments; their purpose is to explain the program to a human reader. In this book,we shall put the text of each comment in italic type, to make it easier for you to distinguishcomments from other parts of the program.

0.2 #includeIn C , many fundamental facilities, such as input-output, are part of the standardlibrary, rather than being part of the core language. This distinction is important becausethe core language is always available to all C programs, but you must explicitly ask forthe parts of the standard library that you wish to use.Programs ask for standard-library facilities by using #include directives. Such directivesnormally appear at the beginning of a program. The only part of the standard library thatour program uses is input-output, which we request by writing#include iostream The name iostream suggests support for sequential, or stream, input-output, rather thanrandom-access or graphical input-output. Because the name iostream appears in an#include directive and it is enclosed in angle brackets ( and ), it refers to a part of theC library called a standard header.The C standard does not tell us exactly what a standard header is, but it does define eachheader's name and behavior. Including a standard header makes the associated libraryfacilities available to the program, but exactly how the implementation does so is itsconcern, not ours.0.3 The main functionA function is a piece of program that has a name, and that another part of the program cancall, or cause to run. Every C program must contain a function named main. When weask the C implementation to run a program, it does so by calling this function.The main function is required to yield an integer as its result, the purpose of which is to tellthe implementation whether the program ran successfully. A zero value indicates success;any other value means there was a problem. Accordingly, we begin by writingint main()to say that we are defining a function named main that returns a value of type int. Here,int is the name that the core language uses to describe integers. The parentheses aftermain enclose the parameters that our function receives from the implementation. In thisparticular example, there are no parameters, so there is nothing between the parentheses.We'll see how to use main's parameters in §10.4/179.

0.4 Curly bracesWe continue our definition of the main function by following the parentheses with asequence of statements enclosed in curly braces (often simply called braces):int main(){}// left brace// the statements go here// right braceIn C , braces tell the implementation to treat whatever appears between them as a unit.In this example, the left brace marks the beginning of the statements in our main function,and the right brace marks their end. In other words, the braces indicate that all thestatements between them are part of the same function.When there are two or more statements within braces, as there are in this function, theimplementation executes them in the order in which they appear.

0.5 Using the standard library for outputThe first statement inside the braces does our program's real work:std::cout "Hello, world!" std::endl;This statement uses the standard library's output operator, , to write Hello, world!on the standard output, and then to write the value of std::endl.Preceding a name by std:: indicates that the name is part of a namespace named std. Anamespace is a collection of related names; the standard library uses std to contain all thenames that it defines. So, for example, the iostream standard header defines the namescout and endl, and we refer to these names as std::cout and std::endl.The name std::cout refers to the standard output stream, which is whatever facility theC implementation uses for ordinary output from programs. In a typical C implementation under a windowing operating system, std::cout will denote the windowthat the implementation associates with the program while it is running. Under such asystem, the output written to std::cout will appear in the associated window.Writing the value of std::endl ends the current line of output, so that if this program wereto produce any more output, that output would appear on a new line.0.6 The return statementA return statement, such asreturn 0;ends execution of the function in which it appears, and passes the value that appearsbetween the return and the semicolon (0 in this example) back to the program that calledthe function that is returning. The value that is returned must have a type that isappropriate for the type that the function says it will return. In the case of main, the returntype is int and the program to which main returns is the C implementation itself.Therefore, a return from main must include an integer-valued expression, which is passedback to the implementation.Of course, there may be more than one point at which it might make sense to terminate aprogram; such a program may have more than one return statement. If the definition of afunction promises that the function returns a value of a particular type, then every returnstatement in the function must return a value of an appropriate type.

0.7 A slightly deeper lookThis program uses two additional concepts that permeate C : expressions and scope. Wewill have much more to say about these concepts as this book progresses, but it isworthwhile to begin with some of the basics here.An expression asks the implementation to compute something. The computation yields aresult, and may also have side effects-that is, it may affect the state of the program orthe implementation in ways that are not directly part of the result. For example, 3 4 is anexpression that yields 7 as its result, and has no side effects, andstd::cout "Hello, world!" std::endlis an expression that, as its side effect, writes Hello, world! on the standard outputstream and ends the current line.An expression contains operators and operands, both of which can take on many forms. Inour Hello, world! expression, the two symbols are operators, and std::cout,"Hello, world! " and std::endl are operands.Every operand has a type. We shall have much more to say about types, but essentially, atype denotes a data structure and the meanings of operations that make sense for that datastructure. The effect of an operator depends on the types of its operands.Types often have names. For example, the core language defines int as the name of a typethat represents integers, and the library defines std::ostream as the type that providesstream-based output. In our program, std::cout has type std::ostream.The operator takes two operands, and yet we have written two operators and threeoperands. How can this be? The answer is that is left-associative, which, looselyspeaking, means that when appears twice or more in the same expression, each willuse as much of the expression as it can for its left operand, and as little of it as it can for itsright operand. In our example, the first operator has "Hello, world! " as its rightoperand and std::cout as its left operand, and the second operator has std::endl asits right operand and std::cout "Hello, world! " as its left operand. If we useparentheses to clarify the relationship between operands and operators, we see that ouroutput expression is equivalent to(std::cout "Hello, world!") std::endlEach behaves in a way that depends on the types of its operands. The first hasstd::cout, which has type std::ostream, as its left operand. Its right operand is astring literal, which has a mysterious type that we shall not even discuss until §10.2/176.With those operand types, writes its right operand's characters onto the stream that its

left operand denotes, and its result is its left operand.The left operand of the second is therefore an expression that yields std::cout, whichhas type std::ostream; the right operand is std::endl, which is a manipulator. Thekey property of manipulators is that writing a manipulator on a stream manipulates thestream, by doing something other than just writing characters to it. When the left operandof has type std::ostream and the right operand is a manipulator, does whateverthe manipulator says to do to the given stream, and returns the stream as its result. In thecase of std::endl, that action is to end the current line of output.The entire expression therefore yields std::cout as its value, and, as a side effect, itwrites Hello, world! on the standard output stream and ends the output line. When wefollow the expression by a semicolon, we are asking the implementation to discard thevalue-which action is appropriate, because we are interested only in the side effects.The scope of a name is the part of a program in which that name has its meaning. C hasseveral different kinds of scopes, two of which we have seen in this program.The first scope that we used is a namespace, which, as we've just seen, is a collection ofrelated names. The standard library defines all of its names in a namespace named std, sothat it can avoid conflicts with names that we might define for ourselves-as long as we arenot so foolish as to try to define std. When we use a name from the standard library, wemust specify that the name we want is the one from the library; for example, std::coutmeans cout as defined in the namespace named std.The name std::cout is a qualified name, which uses the :: operator. This operator isalso known as the scope operator. To the left of the :: is the (possibly qualified) name ofa scope, which in the case of std::cout is the namespace named std. To the right of the:: is a name that is defined in the scope named on the left. Thus, std::cout means "thename cout that is in the (namespace) scope std."Curly braces form another kind of scope. The body of main-and the body of every functionis itself a scope. This fact is not too interesting in such a small program, but it will berelevant to almost every other function we write.

0.8 DetailsAlthough the program we've written is simple, we've covered a lot of ground in this chapter.We intend to build on what we've introduced here, so it is important for you to be sure thatyou understand this chapter fully before you continue.To help you do so, this chap

Accelerated C : Practical Programming by Example, Andrew Koenig and Barbara E. Moo Essential C , Stanley B. Lippman Exceptional C ; 47 Engineering Puzzles, Programming Problems, and Solutions, Herb Sutter Modern C Design: Applied Generic Programming and Design Patterns, Andrei Alexandrescu