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 mainstay ofearlier 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 order touse a car for transportation. They may wish to learn the engineering details for other reasons,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 important ideain modern programming. The key to writing a successful program is knowing which parts ofthe problem to take into account, and which parts to ignore. Every programming languageoffers tools for creating useful abstractions, and every successful programmer knows how touse those tools.We think, abstractions are so useful that we've filled this book with them. Of course, we don'tusually call them abstractions directly, because they come in so many forms. Instead, we referto functions, data structures, classes, and inheritance—all of which are abstractions. Not onlydo 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 if wedon't understand all the details of how they work. We do not need to be automotive engineersto drive a car, nor do we need to understand everything about how C works before we canuse it.CoverageIf you are serious about C programming, you need to know everything in this book— eventhough 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 applications requiredifferent knowledge. Therefore, any book that covers all of C —such as Stroustrup's TheC Programming Language (Addison-Wesley, 2000)—will inevitably tell you a lot that youdon'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 possible towrite a wide variety of useful programs using only the information in this book. Indeed, one ofour reviewers, who is the lead programmer for a substantial commercial system written inC , told us that this book covers essentially all of the facilities that he uses in his work.

Using these facilities, you can write true C programs—not C programs in the style of C,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 telescopemakers 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 in windowingenvironments, because such programs are invariably tied to a specific environment, and oftento a specific vendor. If you want to write programs that will work only in a particularenvironment, you will have to turn elsewhere to learn how to do so— but don't put this bookdown quite yet! Because our approach is universal, you will be able to use everything that youlearn here in whatever environments you use in the future. By all means, go ahead and readthat book about GUI applications that you were considering—but please 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 from thestart. If you are already an experienced C or C programmer, this approach contains somegood 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 thatyou 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 second part,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. Libraryusers don't need to know those parts of the language at all. By ignoring those parts of thelanguage until the second part of the book, we make it possible to write useful C programsmuch 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 thelow-level 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 to avoidwriting new library code altogether.Although this book is smaller than many C books, we have tried to use every important ideaat least twice, and key ideas more than that. As a result, many parts of the book refer to otherparts. These references look like §39.4.3/857, which refers to text on page 857 that is part ofsection 39.4.3—or at least it would do so if this book had that many sections or pages. Thefirst time we explain each idea, we mention it in bold italic type to make it easy to find and tocall 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, and theycover additional, related material that we think you will need to know eventually. We suggestthat you skim these sections on first reading, and refer back to them later as needed.The two appendices summarize and elucidate the important parts of the language and libraryat 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-Wesley

participated in its publication; the ones we know about are Tyrrell Albaugh, Bunny Ames, MikeHendrickson, Deborah Lafferty, Cathy Ohala, and Simone Payment. Alexander Tsiris checkedthe Greek etymology in §13.2.2/236. Finally, the idea of starting with high-level programs grewover many years, stimulated by the hundreds of students who have sat through our coursesand 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 its small size,you should take the time to compile and run this program on your computer before readingfurther. 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 teach asurprising amount about the fundamentals of C . In order to gain this understanding, we'lllook in detail at each line of the program.0.1 CommentsThe first line of our program is// a small C programThe // 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 standard library,rather than being part of the core language. This distinction is important because the corelanguage is always available to all C programs, but you must explicitly ask for the parts ofthe 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 that ourprogram 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 the C 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 its concern,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 we askthe 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 tell theimplementation whether the program ran successfully. A zero value indicates success; anyother 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 isthe name that the core language uses to describe integers. The parentheses after mainenclose the parameters that our function receives from the implementation. In this particularexample, there are no parameters, so there is nothing between the parentheses. We'll seehow 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 a sequenceof 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. Inthis example, the left brace marks the beginning of the statements in our main function, andthe right brace marks their end. In other words, the braces indicate that all the statementsbetween 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 thestandard 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 names coutand 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 the C implementation uses for ordinary output from programs. In a typical C implementationunder a windowing operating system, std::cout will denote the window that theimplementation associates with the program while it is running. Under such a system, theoutput 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 were toproduce 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 called thefunction that is returning. The value that is returned must have a type that is appropriate forthe type that the function says it will return. In the case of main, the return type is int and theprogram to which main returns is the C implementation itself. Therefore, a return frommain must include an integer-valued expression, which is passed back 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 is worthwhileto 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 or theimplementation 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 output streamand ends the current line.An expression contains operators and operands, both of which can take on many forms. In ourHello, 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 right operandand std::cout as its left operand, and the second operator has std::endl as its rightoperand and std::cout "Hello, world! " as its left operand. If we use parentheses to clarifythe relationship between operands and operators, we see that our output expression isequivalent to(std::cout "Hello, world!") std::endlEach behaves in a way that depends on the types of its operands. The first has

std::cout, which has type std::ostream, as its left operand. Its right operand is a string literal,which has a mysterious type that we shall not even discuss until §10.2/176. With thoseoperand types, writes its right operand's characters onto the stream that its left operanddenotes, and its result is its left operand.The left operand of the second is therefore an expression that yields std::cout, which hastype std::ostream; the right operand is std::endl, which is a manipulator. The key property ofmanipulators is that writing a manipulator on a stream manipulates the stream, by doingsomething other than just writing characters to it. When the left operand of has typestd::ostream and the right operand is a manipulator, does whatever the manipulator saysto do to the given stream, and returns the stream as its result. In the case of std::endl, thataction is to end the current line of output.The entire expression therefore yields std::cout as its value, and, as a side effect, it writesHello, world! on the standard output stream and ends the output line. When we follow theexpression by a semicolon, we are asking the implementation to discard the value-whichaction 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 are notso foolish as to try to define std. When we use a name from the standard library, we mustspecify that the name we want is the one from the library; for example, std::cout means coutas defined in the namespace named std.The name std::cout is a qualified name, which uses the :: operator. This operator is alsoknown as the scope operator. To the left of the :: is the (possibly qualified) name of a scope,which in the case of std::cout is the namespace named std. To the right of the :: is a namethat is defined in the scope named on the left. Thus, std::cout means "the name cout that is inthe (namespace) scope std."Curly braces form another kind of scope. The body of main-and the body of every function-isitself a scope. This fact is not too interesting in such a small program, but it will be relevant toalmost 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 that

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 For more information, check out the series Web site at