Professional C++

( 2 )

Overview

Master complex C++ programming with this helpful, in-depth resource

From game programming to major commercial software applications, C++ is the language of choice. It is also one of the most difficult programming languages to master. While most competing books are geared toward beginners, Professional C++, Third Edition, shows experienced developers how to master the latest release of C++, explaining little known features with detailed code examples users can plug into their own...

See more details below
Paperback
$31.21
BN.com price
(Save 30%)$44.99 List Price

Pick Up In Store

Reserve and pick up in 60 minutes at your local store

Other sellers (Paperback)
  • All (16) from $16.17   
  • New (9) from $24.05   
  • Used (7) from $16.17   
Professional C++

Available on NOOK devices and apps  
  • NOOK Devices
  • Samsung Galaxy Tab 4 NOOK 7.0
  • Samsung Galaxy Tab 4 NOOK 10.1
  • NOOK HD Tablet
  • NOOK HD+ Tablet
  • NOOK eReaders
  • NOOK Color
  • NOOK Tablet
  • Tablet/Phone
  • NOOK for Windows 8 Tablet
  • NOOK for iOS
  • NOOK for Android
  • NOOK Kids for iPad
  • PC/Mac
  • NOOK for Windows 8
  • NOOK for PC
  • NOOK for Mac
  • NOOK for Web

Want a NOOK? Explore Now

NOOK Book (eBook)
$25.99
BN.com price
(Save 42%)$44.99 List Price

Overview

Master complex C++ programming with this helpful, in-depth resource

From game programming to major commercial software applications, C++ is the language of choice. It is also one of the most difficult programming languages to master. While most competing books are geared toward beginners, Professional C++, Third Edition, shows experienced developers how to master the latest release of C++, explaining little known features with detailed code examples users can plug into their own codes. More advanced language features and programming techniques are presented in this newest edition of the book, whose earlier editions have helped thousands of coders get up to speed with C++. Become familiar with the full capabilities offered by C++, and learn the best ways to design and build applications to solve real-world problems.

Professional C++, Third Edition has been substantially revised and revamped from previous editions, and fully covers the latest (2014) C++ standard. Discover how to navigate the significant changes to the core language features and syntax, and extensions to the C++ Standard Library and its templates. This practical guide details many poorly understood elements of C++ and highlights pitfalls to avoid.

  • Best practices for programming style, testing, and debugging
  • Working code that readers can plug into their own apps
  • In-depth case studies with working code
  • Tips, tricks, and workarounds with an emphasis on good programming style

Move forward with this comprehensive, revamped guide to professional coding with C++.

Read More Show Less

Product Details

  • ISBN-13: 9780470932445
  • Publisher: Wiley
  • Publication date: 10/4/2011
  • Edition number: 2
  • Pages: 1104
  • Sales rank: 765,211
  • Product dimensions: 7.40 (w) x 9.20 (h) x 2.20 (d)

Meet the Author

Marc Gregoire is a software engineer and developer of C/C++ applications for both Windows and Linux. He is a Microsoft Visual C++ MVP, the founder of the Belgian C++ users group, and is currently working on 3D laser scanning software for Nikon Metrology. He previously worked on critical 2G and 3G telecom software for Siemens and Nokia Siemens Networks. Marc maintains a blog at nuonsoft.com/blog.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

Read More Show Less

Read an Excerpt

Professional C++


By Marc Gregoire Nicholas A. Solter Scott J. Kleper

John Wiley & Sons

Copyright © 2011 John Wiley & Sons, Ltd
All right reserved.

ISBN: 978-0-470-93244-5


Chapter One

A Crash Course in C++

WHAT'S IN THIS CHAPTER?

* A brief overview of the most important parts and syntax of the C++ language

The goal of this chapter is to cover briefly the most important parts of C++ so that you have a base of knowledge before embarking on the rest of the book. This chapter is not a comprehensive lesson in the C++ programming language. The basic points (such as what a program is and the difference between = and ==) are not covered. The esoteric points (Remember what a union is? How about the volatile keyword?) are also omitted. Certain parts of the C language that are less relevant in C++ are also left out, as are parts of C++ that get in-depth coverage in later chapters.

This chapter aims to cover the parts of C++ that programmers encounter every day. For example, if you've been away from C++ for a while and you've forgotten the syntax of a for loop, you'll find that syntax in this chapter. Also, if you're fairly new to C++ and don't understand what a reference variable is, you'll learn about that kind of variable here as well.

If you already have significant experience with C++, skim this chapter to make sure that there aren't any fundamental parts of the language on which you need to brush up. If you're new to C++, read this chapter carefully and make sure you understand the examples. If you need additional introductory information, consult the titles listed in Appendix B.

THE BASICS OF C++

The C++ language is often viewed as a "better C" or a "superset of C." Many of the annoyances or rough edges of the C language were addressed when C++ was designed. Because C++ is based on C, much of the syntax you'll see in this section will look familiar to you if you are an experienced C programmer. The two languages certainly have their differences, though. As evidence, The C++ Programming Language by C++ creator Bjarne Stroustrup (Third Edition; Addison-Wesley Professional, 2000), weighs in at 1030 pages, while Kernighan and Ritchie's The C Programming Language (Second Edition; Prentice Hall, 1988) is a scant 274 pages. So if you're a C programmer, be on the lookout for new or unfamiliar syntax!

The Obligatory Hello, World

In all its glory, the following code is the simplest C++ program you're likely to encounter.

// helloworld.cpp #include <iostream> int main() { std::cout << "Hello, World!" << std::endl; return 0; }

Code snippet from helloworld\helloworld.cpp

This code, as you might expect, prints the message "Hello, World!" on the screen. It is a simple program and unlikely to win any awards, but it does exhibit the following important concepts about the format of a C++ program.

* Comments

* Preprocessor Directives

* The main() Function

* I/O Streams

These concepts are briefly explained in the next sections.

Comments

The first line of the program is a comment, a message that exists for the programmer only and is ignored by the compiler. In C++, there are two ways to delineate a comment. In the preceding and following examples, two slashes indicate that whatever follows on that line is a comment.

// helloworld.cpp

The same behavior (this is to say, none) would be achieved by using a C-style comment, which is also valid in C++. C-style comments start with /* and end with */. In this fashion, C-style comments are capable of spanning multiple lines. The following code shows a C-style comment in action (or, more appropriately, inaction).

/* this is a multiline * C-style comment. The * compiler will ignore * it. */

Comments are covered in detail in Chapter 5.

Preprocessor Directives

Building a C++ program is a three-step process. First, the code is run through a preprocessor, which recognizes meta-information about the code. Next, the code is compiled, or translated into machine-readable object files. Finally, the individual object files are linked together into a single application. Directives aimed at the preprocessor start with the # character, as in the line #include <iostream> in the previous example. In this case, an include directive tells the preprocessor to take everything from the <iostream> header file and make it available to the current file. The most common use of header files is to declare functions that will be defined elsewhere. Remember, a declaration tells the compiler how a function is called. A definition contains the actual code for the function. The <iostream> header declares the input and output mechanisms provided by C++. If the program did not include it, it would be unable to perform its only task of outputting text.

In C, included files usually end in .h, such as <stdio.h>. In C++, the suffix is omitted for standard library headers, such as <iostream>. Your favorite standard headers from C still exist in C++, but with new names. For example, you can access the functionality from <stdio.h> by including <cstdio>.

The following table shows some of the most common preprocessor directives.

One example of using preprocessor directives is to avoid multiple includes. For example:

#ifndef MYHEADER_H #define MYHEADER_H // ... the contents of this header file #endif

If your compiler supports the #pragma once directive, this can be rewritten as follows:

#pragma once // ... the contents of this header file

Chapter 9 discusses this in more details.

The main() Function

main() is, of course, where the program starts. An int is returned from main(), indicating the result status of the program. The main() function either takes no parameters, or takes two parameters as follows:

int main(int argc, char* argv)

argc gives the number of arguments passed to the program, and argv contains those arguments. Note that the first argument is always the name of the program itself.

I/O Streams

If you're new to C++ and coming from a C background, you're probably wondering what std::cout is and what has been done with trusty old printf(). While printf() can still be used in C++, a much better input/output facility is provided by the streams library.

I/O streams are covered in depth in Chapter 15, but the basics of output are very simple. Think of an output stream as a laundry chute for data. Anything you toss into it will be output appropriately. std::cout is the chute corresponding to the user console, or standard out. There are other chutes, including std::cerr, which outputs to the error console. The << operator tosses data down the chute. In the preceding example, a quoted string of text is sent to standard out. Output streams allow multiple data of varying types to be sent down the stream sequentially on a single line of code. The following code outputs text, followed by a number, followed by more text.

std::cout << "There are " << 219 << " ways I love you." << std::endl;

std::endl represents an end-of-line sequence. When the output stream encounters std::endl, it will output everything that has been sent down the chute so far and move to the next line. An alternate way of representing the end of a line is by using the \n character. The \n character is an escape character, which refers to a new-line character. Escape characters can be used within any quoted string of text. The following table shows the most common escape characters.

Streams can also be used to accept input from the user. The simplest way to do this is to use the >> operator with an input stream. The std::cin input stream accepts keyboard input from the user. User input can be tricky because you can never know what kind of data the user will enter. See Chapter 15 for a full explanation of how to use input streams.

Namespaces

Namespaces address the problem of naming conflicts between different pieces of code. For example, you might be writing some code that has a function called foo(). One day, you decide to start using a third-party library, which also has a foo() function. The compiler has no way of knowing which version of foo() you are referring to within your code. You can't change the library's function name, and it would be a big pain to change your own.

Namespaces come to the rescue in such scenarios because you can define the context in which names are defined. To place code in a namespace, enclose it within a namespace block:

namespace mycode { void foo(); }

Code snippet from namespaces\namespaces.h

The implementation of a method or function can also be handled in a namespace:

#include <iostream> #include "namespaces.h" namespace mycode { void foo() { std::cout << "foo() called in the mycode namespace" << std::endl; } }

Code snippet from namespaces\namespaces.cpp

By placing your version of foo() in the namespace "mycode," it is isolated from the foo() function provided by the third-party library. To call the namespace-enabled version of foo(), prepend the namespace onto the function name by using :: also called the scope resolution operator as follows.

mycode::foo(); // Calls the "foo" function in the "mycode" namespace

Any code that falls within a "mycode" namespace block can call other code within the same namespace without explicitly prepending the namespace. This implicit namespace is useful in making the code more precise and readable. You can also avoid prepending of namespaces with the using directive. This directive tells the compiler that the subsequent code is making use of names in the specified namespace. The namespace is thus implied for the code that follows:

#include "namespaces.h" using namespace mycode; int main() { foo(); // Implies mycode::foo(); return 0; }

Code snippet from namespaces\usingnamespaces.cpp

A single source file can contain multiple using directives, but beware of overusing this shortcut. In the extreme case, if you declare that you're using every namespace known to humanity, you're effectively eliminating namespaces entirely! Name conflicts will again result if you are using two namespaces that contain the same names. It is also important to know in which namespace your code is operating so that you don't end up accidentally calling the wrong version of a function.

You've seen the namespace syntax before — you used it in the Hello, World program, where cout and endl are actually names defined in the std namespace. You could have written Hello, World with the using directive as shown here:

#include <iostream> using namespace std; int main() { cout << "Hello, World!" << endl; return 0; }

The using directive can also be used to refer to a particular item within a namespace. For example, if the only part of the std namespace that you intend to use is cout, you can refer to it as follows:

using std::cout;

Subsequent code can refer to cout without prepending the namespace, but other items in the std namespace will still need to be explicit:

using std::cout; cout << "Hello, World!" << std::endl;

Variables

In C++, variables can be declared just about anywhere in your code and can be used anywhere in the current block below the line where they are declared. Variables can be declared without being given a value. These uninitialized variables generally end up with a semi random value based on whatever is in memory at the time and are the source of countless bugs. Variables in C++ can alternatively be assigned an initial value when they are declared. The code that follows shows both flavors of variable declaration, both using ints, which represent integer values.

int uninitializedInt; int initializedInt = 7; cout << uninitializedInt << " is a random value" << endl; cout << initializedInt << " was assigned an initial value" << endl;

Code snippet from hellovariables\hellovariables.cpp

When run, this code will output a random value from memory for the first line and the number 7 for the second. This code also shows how variables can be used with output streams.

Most compilers will issue a warning when code is using uninitialized variables, and some C++ environments may report a run time error when uninitialized variables are being accessed.

The table that follows shows the most common variable types used in C++.

C++ does not provide a basic string type. However, a standard implementation of a string is provided as part of the standard library as described later in this chapter and in Chapter 14.

Variables can be converted to other types by casting them. For example, an int can be cast to a bool. C++ provides three ways of explicitly changing the type of a variable. The first method is a holdover from C, but is still the most commonly used. The second method seems more natural at first but is rarely seen. The third method is the most verbose, but often considered the cleanest.

bool someBool = (bool)someInt; // method 1 bool someBool = bool(someInt); // method 2 bool someBool = static_cast<bool>(someInt); // method 3

The result will be false if the integer was 0 and true otherwise. Chapter 9 describes the different casting methods in more detail. In some contexts, variables can be automatically cast, or coerced. For example, a short can be automatically converted into a long because a long represents the same type of data with additional precision.

long someLong = someShort; // no explicit cast needed

When automatically casting variables, you need to be aware of the potential loss of data. For example, casting a float to an int throws away information (the fractional part of the number). Many compilers will issue a warning if you assign a float to an int without an explicit cast. If you are certain that the left-hand side type is fully compatible with the right-hand side type, it's okay to cast implicitly.

Operators

What good is a variable if you don't have a way to change it? The following table shows the most common operators used in C++ and sample code that makes use of them. Note that operators in C++ can be binary (operate on two variables), unary (operate on a single variable), or even ternary (operate on three variables). There is only one ternary operator in C++ and it is covered in the section "Conditionals."

The following program shows the most common variable types and operators in action. If you're unsure about how variables and operators work, try to figure out what the output of this program will be, and then run it to confirm your answer.

#include <iostream> using namespace std; int main() { int someInteger = 256; short someShort; long someLong; float someFloat; double someDouble;

someInteger++; someInteger *= 2; someShort = (short)someInteger; someLong = someShort * 10000; someFloat = someLong + 0.785; someDouble = (double)someFloat / 100000; cout << someDouble << endl; return 0; }

Code snippet from typetest\typetest.cpp

The C++ compiler has a recipe for the order in which expressions are evaluated. If you have a complicated line of code with many operators, the order of execution may not be obvious. For that reason, it's probably better to break up a complicated statement into several smaller statements or explicitly group expressions by using parentheses. For example, the following line of code is confusing unless you happen to know the C++ operator precedence table by heart:

int i = 34 + 8 * 2 + 21 / 7 % 2;

Adding parentheses makes it clear which operations are happening first:

int i = 34 + (8 * 2) + ( (21 / 7) % 2 );

Breaking up the statement into separate lines makes it even clearer:

int i = 8 * 2; int j = 21 / 7; j %= 2; i = 34 + i + j;

For those of you playing along at home, all three approaches are equivalent and end up with i equal to 51. If you assumed that C++ evaluated expressions from left to right, your answer would have been 1. In fact, C++ evaluates /, *, and % first (in left-to-right order), followed by addition and subtraction, then bitwise operators. Parentheses let you explicitly tell the compiler that a certain operation should be evaluated separately.

Types

In C++, you can use the basic types (int, bool, etc.) to build more complex types of your own design. Once you are an experienced C++ programmer, you will rarely use the following techniques, which are features brought in from C, because classes are far more powerful. Still, it is important to know about the two most common ways of building types so that you will recognize the syntax.

(Continues...)



Excerpted from Professional C++ by Marc Gregoire Nicholas A. Solter Scott J. Kleper Copyright © 2011 by John Wiley & Sons, Ltd. Excerpted by permission of John Wiley & Sons. All rights reserved. No part of this excerpt may be reproduced or reprinted without permission in writing from the publisher.
Excerpts are provided by Dial-A-Book Inc. solely for the personal use of visitors to this web site.

Read More Show Less

Table of Contents

INTRODUCTION xli

Part I: INTRODUCTION TO PROFESSIONAL C++

CHAPTER 1: A CRA SH COURSE IN C++ AND THE STL 3

The Basics of C++ 4

Diving Deeper into C++ 25

C++ as an Object-Oriented Language 34

Summary 46

CHAPTER 2: WORKING WITH STRINGS 47

Dynamic Strings 47

Summary 55

CHAPTER 3: CODING WITH STYLE 57

Naming 68

Formatting 72

Summary 75

Part II: PROFESSIONAL C++ SOFTWAR E DESIGN

CHAPTER 4: DESIGNING PROFESSIONAL C++ PROGRA MS 79

What Is Programming Design? 80

The Importance of Programming Design 80

Designing for C++ 82

Two Rules for C++ Design 83

Reusing Code 87

Deciding Whether or Not to Use the STL 98

Designing with Patterns and Techniques 98

Designing a Chess Program 99

Summary 105

CHAPTER 5: DESIGNING WITH OBJECTS 107

Am I Thinking Procedurally? 108

The Object-Oriented Philosophy 108

Living in a World of Objects 111

Abstraction 122

Summary 126

CHAPTER 6: DESIGNING FOR REUSE 127

The Reuse Philosophy 127

How to Design Reusable Code 128

Summary 140

Part III: CODING THE PROFESSIONAL WAY

CHAPTER 7: GAINING PROFICIENCY WITH CLASSES AND OBJECTS 143

Introducing the Spreadsheet Example 144

Writing Classes 144

Summary 175

CHAPTER 8: MASTERING CLASSES AND OBJECTS 177

Dynamic Memory Allocation in Objects 178

Different Kinds of Data Members 188

More about Methods 193

Nested Classes 199

Enumerated Types Inside Classes 201

Friends 202

Operator Overloading 203

Summary 215

CHAPTER 9: DISCOVERING INHERITANCE TECHNIQUES 217

Building Classes with Inheritance 218

Multiple Inheritance 244

Interesting and Obscure Inheritance Issues 249

Summary 271

CHAPTER 10: C++ QUIRKS, ODDITIES, AND INCIDENTALS 273

References 274

Types and Casts 295

Summary of Casts 301

Scope Resolution 302

C++11 / C++14 303

Header Files 309

C Utilities 310

Summary 313

CHAPTER 11: WRITING GENERIC CODE WITH TEMPLATES 315

Overview of Templates 316

Class Templates 317

Function Templates 339

Variable Templates 343

Summary 343

CHAPTER 12: DEMYSTIFYING C++ I/O 345

Using Streams 346

String Streams 360

File Streams 362

Bidirectional I/O 366

Summary 367

CHAPTER 13: HANDLING ERR ORS 369

Errors and Exceptions 370

Exception Mechanics 372

Exceptions and Polymorphism 387

Stack Unwinding and Cleanup 394

Common Error-Handling Issues 397

Putting It All Together 405

Summary 409

CHAPTER 14: OVERLOADING C++ OPERA TORS 411

Overview of Operator Overloading 412

Overloading the Arithmetic Operators 420

Overloading the Bitwise and Binary Logical Operators 421

Overloading the Insertion and Extraction Operators 422

Overloading the Subscripting Operator 423

Overloading the Function Call Operator 428

Overloading the Dereferencing Operators 429

Writing Conversion Operators 432

Overloading the Memory Allocation and Deallocation Operators 436

Summary 442

CHAPTER 15: OVERVIEW OF THE C++ STANDARD LIBRARY 443

Coding Principles 444

Overview of the C++ Standard Library 445

Summary 465

CHAPTER 16: UNDERSTANDING CONTAINERS AND ITERATORS 467

Containers Overview 468

Sequential Containers 473

Container Adapters 498

Associative Containers 504

Unordered Associative Containers/Hash Tables 516

Other Containers 523

Summary 529

CHAPTER 17: MASTERING STL ALGORITHMS 531

Overview of Algorithms 532

Lambda Expressions 536

Function Objects 542

Algorithm Details 550

Algorithms Example: Auditing Voter Registrations 570

Summary 573

CHAPTER 18: STRING LOCALIZATION AND REGULAR EXPRESSIONS 575

Localization 575

Regular Expressions 581

ECMAScript Syntax 582

Summary 599

CHAPTER 19: ADDITIONAL LIBRARY UTILITIES 601

std::function 601

Ratios 603

The Chrono Library 606

Random Number Generation 612

Tuples 621

Summary 624

Part IV: MASTERING ADVANCED FEATURES OF C++

CHAPTER 20: CUSTOMIZING AND EXTENDING THE STL 627

Allocators 628

Iterator Adapters 628

Extending the STL 634

Summary 671

CHAPTER 21: ADVANCED TEMPLATES 673

More about Template Parameters 673

Class Template Partial Specialization 679

Emulating Function Partial Specialization with Overloading 683

Template Recursion 685

Type Inference 689

Variadic Templates 691

Metaprogramming 695

Summary 705

CHAPTER 22: MEMORY MANAGEMENT 707

Working with Dynamic Memory 708

Array-Pointer Duality 720

Low-Level Memory Operations 722

Smart Pointers 727

Common Memory Pitfalls 734

Summary 740

CHAPTER 23: MULTITHREADED PROGRAMMING WITH C++ 741

Introduction 742

Threads 746

Atomic Operations Library 755

Mutual Exclusion 758

Condition Variables 767

Futures 770

Example: Multithreaded Logger Class 772

Thread Pools 776

Threading Design and Best Practices 777

Summary 778

Part V: C++ SOFTWAR E ENGINEERING

CHAPTER 24: MAXIMIZING SOFTWARE ENGINEERING METHODS 781

The Need for Process 782

Software Life Cycle Models 783

Software Engineering Methodologies 789

Building Your Own Process and Methodology 796

Source Code Control 797

Summary 799

CHAPTER 25: WRITING EFFICIENT C++ 801

Overview of Performance and Efficiency 802

Language-Level Efficiency 803

Design-Level Efficiency 808

Profiling 813

Summary 825

CHAPTER 26: CONQUERING DEBUGGING 827

The Fundamental Law of Debugging 828

Bug Taxonomies 828

Avoiding Bugs 828

Planning for Bugs 829

Debugging Techniques 842

Summary 861

APPENDIX A: C++ INTERVIEWS 863

Chapter 1: A Crash Course in C++ and the STL 863

Chapters 2 and 18: Strings, Localization, and Regular Expressions 864

Chapter 3: Coding with Style 865

Chapter 4: Designing Professional C++ Programs 866

Chapter 5: Designing with Objects 868

Chapter 6: Designing for Reuse 868

Chapters 7 and 8: Classes and Objects 869

Chapter 9: Discovering Inheritance Techniques 872

Chapter 10: C++ Quirks, Oddities, and Incidentals 873

Chapters 11 and 21: Templates 875

Chapter 12: Demystifying C++ I/O 875

Chapter 13: Handling Errors 876

Chapter 14: Overloading C++ Operators 877

Chapters 15, 16, 17, and 20: The Standard Template Library 878

Chapter 19: Additional Library Utilities 878

Chapter 22: Memory Management 879

Chapter 23: Multithreaded Programming with C++ 880

Chapter 24: Maximizing Software Engineering Methods 881

Chapter 25: Writing Efficient C++ 882

Chapter 26: Conquering Debugging 882

APPENDIX B: ANNOTATED BIBLIOGRAPHY 885

C++ 885

C 889

Unified Modeling Language, Uml 889

Algorithms and Data Structures 890

Random Numbers 890

Open-Source Software 890

Software Engineering Methodology 891

Programming Style 892

Computer Architecture 892

Efficiency 893

Testing 893

Debugging 893

Design Patterns 893

Operating Systems 894

Multithreaded Programming 894

APPENDIX C: STANDARD LIBRARY HEADER FILES 895

The C Standard Library 895

Containers 897

Algorithms, Iterators, and Allocators 898

General Utilities 898

Mathematical Utilities 899

Exceptions 899

I/O Streams 900

Threading Library 901

INDEX 903

Read More Show Less

Customer Reviews

Average Rating 3.5
( 2 )
Rating Distribution

5 Star

(0)

4 Star

(1)

3 Star

(1)

2 Star

(0)

1 Star

(0)

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

Reminder:

  • - 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 2 Customer Reviews
  • Anonymous

    Posted January 28, 2013

    Epic hard knowledge

    Good but difficult

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

    Posted September 3, 2012

    Eh

    I'll give it a C++

    Was this review helpful? Yes  No   Report this review
Sort by: Showing all of 2 Customer Reviews

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