TECH-THINKER

Angelo Yin (阴平)'s invitation is awaiting your response

2015-01-26T02:20:00.001-08:00

Angelo Yin (阴平) would like to connect on LinkedIn. How would you like to respond?

Senior Software Developer at Schlumberger

You received an invitation to connect. LinkedIn will use your email address to make suggestions to our members in features like People You May Know. Unsubscribe

If you need assistance or have questions, please contact LinkedIn Customer Service.

Angelo Yin (阴平)'s invitation is awaiting your response

2015-01-20T01:15:00.001-08:00

Angelo Yin (阴平) would like to connect on LinkedIn. How would you like to respond?

Angelo Yin (阴平)

Senior Software Developer at Schlumberger

Confirm you know Angelo

You received an invitation to connect. LinkedIn will use your email address to make suggestions to our members in features like People You May Know. Unsubscribe

If you need assistance or have questions, please contact LinkedIn Customer Service.

I'd like to add you to my professional network on LinkedIn

2015-01-18T19:48:00.001-08:00

Angelo Yin (阴平) would like to stay in touch on LinkedIn.

I'd like to add you to my professional network on LinkedIn.

- Angelo

Confirm that you know Angelo

Angelo Yin (阴平)

Senior Software Developer at Schlumberger

Huhehaote, Inner Mongolia, China

You received an invitation to connect. LinkedIn will use your email address to make suggestions to our members in features like People You May Know. Unsubscribe

Learn why we included this.

If you need assistance or have questions, please contact LinkedIn Customer Service.

C++ Primer, Fourth Edition:Notes Chapter 14. Overloaded Operations and Conversions

2011-02-15T21:16:00.000-08:00

C++ lets us redefine the meaning of the operators when applied to objects of class type. It also lets us define conversion operations for class types. Class-type conversions are used like the built-in conversions to implicitly convert an object of one type to another type when needed
Operator overloading allows the programmer to define versions of the operators for operands of class type
Through operator overloading, we can redefine most of the operators from Chapter 5 to work on objects of class type. Judicious use of operator overloading can make class types as intuitive to use as the built-in types
Allowing programs to use expressions rather than named functions can make the programs much easier to write and read.

Section 14.1 Defining an Overloaded Operator

Overloaded operators are functions with special names: the keyword operator followed by the symbol for the operator being defined. Like any other function, an overloaded operator has a return type and a parameter list
With the exception of the function-call operator, an overloaded operator has the same number of parameters (including the implicit this pointer for member functions) as the operator has operands. The function-call operator takes any number of operands

Overloaded Operator Names

Table 14.1. Overloadable Operators
`+`	`-`	`*`	`/`	`%`	`^`
`&`	`\|`	`~`	`!`	`,`	`=`
`<`	`>`	`<=`	`>=`	`++`	`--`
`<<`	`>>`	`==`	`!=`	`&&`	`\|\|`
`+=`	`-=`	`/=`	`%=`	`^=`	`&=`
`\|=`	`*=`	`<<=`	`>>=`	`[]`	`()`
`->`	`->*`	`new`	`new []`	`delete`	`delete[]`

Table 14.2. Operators That Cannot Be Overloaded
`::`	`.*`	`.`	`?:`

New operators may not be created by concatenating other legal symbols

Overloaded Operators Must Have an Operand of Class Type
- The meaning of an operator for the built-in types may not be changed.Nor may additional operators be defined for the built-in data types
- An overloaded operator must have at least one operand of class or enumeration (Section 2.7, p. 62) type. This rule enforces the requirement that an overloaded operator may not redefine the meaning of the operators when applied to objects of built-in type
Precedence and Associativity Are Fixed
- The precedence (Section 5.10.1, p. 168), associativity, or number of operands of an operator cannot be changed
- Four symbols (+, -, *, and &) serve as both unary and binary operators. Either or both of these operators can be overloaded. Which operator is being defined is controlled by the number of operands. Default arguments for overloaded operators are illegal, except for operator(), the function-call operator
Short-Ciruit Evaluation Is Not Preserved
- Overloaded operators make no guarantees about the order in which operands are evaluated. In particular, the operand-evaluation guarantees of the built-in logical AND, logical OR (Section 5.2, p. 152), and comma (Section 5.9, p. 168) operators are not preserved. Both operands to an overloaded version of && or || are always evaluated. The order in which those operands are evaluated is not stipulated. The order in which the operands to the comma are evaluated is also not defined. For this reason, it is usually a bad idea to overload &&, ||, or the comma operator.
Class Member versus Nonmember
- Most overloaded operators may be defined as ordinary nonmember functions or as class member functions
- Overloaded functions that are members of a class may appear to have one less parameter than the number of operands. Operators that are member functions have an implicit this parameter that is bound to the first operand
Operator Overloading and Friendship
- When operators are defined as nonmember functions, they often must be made friends (Section 12.5, p. 465) of the class(es) on which they operate
Using Overloaded Operators
- We can use an overloaded operator in the same way that we'd use the operator on operands of built-in type
- We also can call an overloaded operator function in the same way that we call an ordinary function: We name the function and pass an appropriate number of arguments of the appropriate type
  - cout << item1 + item2 << endl;
    
    // equivalent direct call to nonmember operator function
    // This call has the same effect as the expression that added item1 and item2.
    cout << operator+(item1, item2) << endl;
- We call a member operator function the same way we call any other member function: We name an object on which to run the function and then use the dot or arrow operator to fetch the function we wish to call passing the required number and type of arguments. In the case of a binary member operator function, we must pass a single operand

14.1.1. Overloaded Operator Design

Don't Overload Operators with Built-in Meanings
- The assignment, address of, and comma operators have default meanings for operands of class types. If there is no overloaded version specified, the compiler defines its own version of these operators
- The synthesized assignment operator (Section 13.2, p. 482) does memberwise assignment: It uses each member's own assignment operator to assign each member in turn
- By default the address of (&) and comma (,) operators execute on class type objects the same way they do on objects of built-in type. The address of operator returns the address in memory of the object to which it is applied. The comma operator evaluates each expression from left to right and returns the value of its rightmost operand
- The built-in logical AND (&&) and OR(||) operators apply short-circuit evaluation (Section 5.2, p. 152). If the operator is redefined, the short-circuit nature of the operators is lost
- It is usually not a good idea to overload the comma, address-of, logical AND, or logical OR operators. These operators have built-in meanings that are useful and become inaccessible if we define our own versions
- We sometimes must define our own version of assignment. When we do so, it should behave analogously to the synthesized operators: After an assignment, the values in the left-hand and right-hand operands should be the same and the operator should return a reference to its left-hand operand. Overloaded assignment should customize the built-in meaning of assignment, not circumvent it
Most Operators Have No Meaning for Class Objects
- Operators other than assignment, address-of, and comma have no meaning when applied to an operand of class type unless an overloaded definition is provided. When designing a class, we decide which, if any, operators to support
- The best way to design operators for a class is first to design the class' public interface. Once the interface is defined, it is possible to think about which operations should be defined as overloaded operators. Those operations with a logical mapping to an operator are good candidates
Compound Assignment Operators
- If a class has an arithmetic (Section 5.1, p. 149) or bitwise (Section 5.3, p. 154) operator, then it is usually a good idea to provide the corresponding compound-assignment operator as well

Equality and Relational Operators

Classes that will be used as the key type of an associative container should define the < operator. The associative containers by default use the < operator of the key type. Even if the type will be stored only in a sequential container, the class ordinarily should define the equality (==) and less-than (<) operators. The reason is that many algorithms assume that these operators exist

If the class defines the equality operator, it should also define !=. Users of the class will assume that if they can compare for equality, they can also compare for inequality. The same argument applies to the other relational operators as well. If the class defines <, then it probably should define all four relational operators (>, >=, <, and <=)

Caution: Use Operator Overloading Judiciously

Each operator has an associated meaning from its use on the built-in types. Binary +, for example, is strongly identified with addition. Mapping binary + to an analogous operation for a class type can provide a convenient notational shorthand. For example, the library string type, following a convention common to many programming languages, uses + to represent concatenation"adding" one string to the other.

Operator overloading is most useful when there is a logical mapping of a built-in operator to an operation on our type. Using overloaded operators rather than inventing named operations can make our programs more natural and intuitive. Overuse or outright abuse of operator overloading can make our classes incomprehensible.

Obvious abuses of operator overloading rarely happen in practice. As an example, no responsible programmer would define operator+ to perform subtraction. More common, but still inadvisable, are uses that contort an operator's "normal" meaning to force a fit to a given type. Operators should be used only for operations that are likely to be unambiguous to users. An operator with ambiguous meaning, in this sense, is one that supports equally well a number of different interpretations.

When the meaning of an overloaded operator is not obvious, it is better to give the operation a name. It is also usually better to use a named function rather than an operator for operations that are rarely done. If the operation is unusual, the brevity of using an operator is unnecessary.

Choosing Member or Nonmember Implementation
- The following guidelines can be of help when deciding whether to make an operator a member or an ordinary nonmember function
  - The assignment (=), subscript ([]), call (()), and member access arrow (->) operators must be defined as members. Defining any of these operators as a nonmember function is flagged at compile time as an error
  - Like assignment, the compound-assignment operators ordinarily ought to be members of the class. Unlike assignment, they are not required to be so and the compiler will not complain if a nonmember compound-assignment operator is defined
  - Other operators that change the state of their object or that are closely tied to their given typesuch as increment, decrement, and dereferenceusually should be members of the class
  - Symmetric operators, such as the arithmetic, equality, relational, and bitwise operators, are best defined as ordinary nonmember functions

Section 14.2 Input and Output Operators

Classes that support I/O ordinarily should do so by using the same interface as defined by the iostream library for the built-in types. Thus, many classes provide overloaded instances of the input and output operators

14.2.1. Overloading the Output Operator <<

To be consistent with the IO library, the operator should take an ostream& as its first parameter and a reference to a const object of the class type as its second. The operator should return a reference to its ostream parameter

// general skeleton of the overloaded output operatorostream&    operator <<(ostream& os, const ClassType &object){    // any special logic to prepare object     // actual output of members    os << // ...         // return ostream object        return os;}

The Sales_item Output Operator
Output Operators Usually Do Minimal Formatting
- Class designers face one significant decision about output: whether and how much formatting to perform
- Generally, output operators should print the contents of the object, with minimal formatting. They should not print a newline
- The output operators for the built-in types do little if any formatting and do not print newlines. Given this treatment for the built-in types, users expect class output operators to behave similarly. By limiting the output operator to printing just the contents of the object, we let the users determine what if any additional formatting to perform. In particular, an output operator should not print a newline. If the operator does print a newline, then users would be unable to print descriptive text along with the object on the same line. By having the output operator perform minimal formatting, we let users control the details of their output
IO Operators Must Be Nonmember Functions
- When we define an input or output operator that conforms to the conventions of the iostream library, we must make it a nonmember operator
- We cannot make the operator a member of our own class.If we did, then the left-hand operand would have to be an object of our class type
- Instead, if we want to use the overloaded operators to do IO for our types, we must define them as a nonmember functions. IO operators usually read or write the nonpublic data members. As a consequence, classes often make the IO operators friends
14.2.2. Overloading the Input Operator >>
- Similar to the output operator, the input operator takes a first parameter that is a reference to the stream from which it is to read, and returns a reference to that same stream. Its second parameter is a nonconst reference to the object into which to read. The second parameter must be nonconst because the purpose of an input operator is to read data into this object
- A more important, and less obvious, difference between input and output operators is that input operators must deal with the possibility of errors and end-of-file
- The Sales_item Input Operator
- Errors During Input
  - The kinds of errors that might happen include:
  - Any of the read operations could fail because an incorrect value was provided.
  - Any of the reads could hit end-of-file or some other error on the input stream
  - Rather than checking each read, we check once before using the data we read
- Handling Input Errors
  - If an input operator detects that the input failed, it is often a good idea to make sure that the object is in a usable and consistent state. Doing so is particularly important if the object might have been partially written before the error occurred
  - When designing an input operator, it is important to decide what to do about error-recovery, if anything
- Indicating Errors
  - In addition to handling any errors that might occur, an input operator might need to set the condition state (Section 8.2, p. 287) of its input istream parameter
  - Some input operators do need to do additional checking.
  - Usually an input operator needs to set only the failbit. Setting eofbit would imply that the file was exhausted, and setting badbit would indicate that the stream was corrupted. These errors are best left to the IO library itself to indicate.

Section 14.3 Arithmetic and Relational Operators

Ordinarily, we define the arithmetic and relational operators as nonmember functions
Note that to be consistent with the built-in operator, addition returns an rvalue, not a reference
An arithmetic operator usually generates a new value that is the result of a computation on its two operands. That value is distinct from either operand and is calculated in a local variable. It would be a run-time error to return a reference to that variable
Classes that define both an arithmetic operator and the related compound assignment ordinarily ought to implement the arithmetic operator by using the compound assignment
It is simpler and more efficient to implement the arithmetic operator (e.g., +) in terms of the compound-assignment operator (e.g., +=) rather than the other way around. If we implemented += by calling +, then += would needlessly create and destroy a temporary to hold the result from +.
14.3.1. Equality Operators
- Ordinarily, classes in C++ use the equality operator to mean that the objects are equivalent. That is, they usually compare every data member and treat two objects as equal if and only if all corresponding members are the same
- The definition of these functions is trivial. More important are the design principles that these functions embody
  - If a class defines the == operator, it defines it to mean that two objects contain the same data
  - If a class has an operation to determine whether two objects of the type are equal, it is usually right to define that function as operator== rather than inventing a named operation. Users will expect to be able to compare objects using ==, and doing so is easier than remembering a new name
  - If a class defines operator==, it should also define operator!=. Users will expect that if they can use one operator, then the other will also exist
  - The equality and inequality operators should almost always be defined in terms of each other. One operator should do the real work to compare objects. The other should call the one that does the real work
- Classes that define operator== are easier to use with the standard library. Some algorithms, such as find, use the == operator by default. If a class defines ==, then these algorithms can be used on that class type without any specialization
14.3.2. Relational Operators
- Classes for which the equality operator is defined also often have relational operators. In particular, because the associative containers and some of the algorithms use the less-than operator, it can be quite useful to define an operator<.
- Because the logical definition of < is inconsistent with the logical definition of ==, it is better not to define < at all. We'll see in Chapter 15 how to use a separate named function to compare Sales_items when we want to store them in an associative container
- The associative containers, as well as some of the algorithms, use the < operator by default. Ordinarily, the relational operators, like the equality operators, should be defined as nonmember functions

Section 14.4 Assignment Operators

We covered the assignment of one object of class type to another object of its type in Section 13.2 (p. 482). The class assignment operator takes a parameter that is the class type. Usually the parameter is a const reference to the class type. However, the parameter could be the class type or a nonconst reference to the class type. This operator will be synthesized by the compiler if we do not define it ourselves. The class assignment operator must be a member of the class so the compiler can know whether it needs to synthesize one
Additional assignment operators that differ by the type of the right-hand operand can be defined for a class type

Assignment operators can be overloaded. Unlike the compound-assignment operators, every assignment operator, regardless of parameter type, must be defined as a member function

// illustration of assignment operators for class stringclass string {public:    string& operator=(const string &);      // s1 = s2;    string& operator=(const char *);        // s1 = "str";    string& operator=(char);                // s1 = 'c';    // .... };

Assignment Should Return a Reference to *this
- The string assignment operators return a reference to string, which is consistent with assignment for the built-in types. Moreover, because assignment returns a reference there is no need to create and destroy a temporary copy of the result. The return value is usually a reference to the left-hand operand
- Ordinarily, assignment operators and compound-assignment operators ought to return a reference to the left-hand operand

Section 14.5 Subscript Operator

Classes that represent containers from which individual elements can be retrieved usually define the subscript operator, operator[]. The library classes, string and vector, are examples of classes that define the subscript operator

The subscript operator must be defined as a class member function

Providing Read and Write Access

One complication in defining the subscript operator is that we want it to do the right thing when used as either the left- or right-hand operand of an assignment

It is also a good idea to be able to subscript const and nonconst objects. When applied to a const object, the return should be a const reference so that it is not usable as the target of an assignment

Ordinarily, a class that defines subscript needs to define two versions: one that is a nonconst member and returns a reference and one that is a const member and returns a const reference

Prototypical Subscript Operator

#include "stdafx.h"#include <vector>using namespace  std;class Foo {public:    int &operator[] (const size_t);    const int &operator[] (const size_t) const;    // other interface membersprivate:    vector<int> data;    // other member data and private utility functions}; int& Foo::operator[] (const size_t index){    return data[index];  // no range checking on index}const int& Foo::operator[] (const size_t index) const{    return data[index];  // no range checking on index}

Section 14.6 Member Access Operators

2011.2.21 here

Section 14.7 Increment and Decrement Operators

Section 14.8 Call Operator and Function Objects

Section 14.9 Conversions and Class Types

C++ Primer, Fourth Edition:Notes Chapter 17. Tools for Large Programs

2011-02-15T01:37:00.003-08:00

Section 17.1 Exception Handling

Section 17.2 Namespaces

Section 17.3 Multiple and Virtual Inheritance

C++ Primer, Fourth Edition:Notes Chapter 16. Templates and Generic Programming

2011-02-15T01:37:00.001-08:00

Section 16.1 Template Definitions

Section 16.2 Instantiation

Section 16.3 Template Compilation Models

Section 16.4 Class Template Members

Section 16.5 A Generic Handle Class

Section 16.6 Template Specializations

Section 16.7 Overloading and Function Templates

C++ Primer, Fourth Edition:Notes Chapter 15. Object-Oriented Programming

2011-02-15T01:36:00.001-08:00

Section 15.1 OOP: An Overview

Section 15.2 Defining Base and Derived Classes

Section 15.3 Conversions and Inheritance

Section 15.4 Constructors and Copy Control

Section 15.5 Class Scope under Inheritance

Section 15.6 Pure Virtual Functions

Section 15.7 Containers and Inheritance

Section 15.8 Handle Classes and Inheritance

Section 15.9 Text Queries Revisited

C++ Primer, Fourth Edition:Notes Chapter Chapter 18. Specialized Tools and Techniques

2011-02-15T01:34:00.003-08:00

Section 18.1 Optimizing Memory Allocation

Section 18.2 Run-Time Type Identification

Section 18.3 Pointer to Class Member

Section 18.4 Nested Classes

Section 18.5 Union: A Space-Saving Class

Section 18.6 Local Classes

Section 18.7 Inherently Nonportable Features

C++ Primer, Fourth Edition:Notes Chapter 13. Copy Control

2011-02-10T02:06:00.001-08:00

Each type, whether a built-in or class type, defines the meaning of a (possibly empty) set of operations on objects of that type
Each type also defines what happens when objects of the type are created. Initialization of objects of class type is defined by constructors. Types also control what happens when objects of the type are copied, assigned, or destroyed. Classes control these actions through special member functions: the copy constructor, the assignment operator, and the destructor. This chapter covers these operations
When we define a new type, we specifyexplicitly or implicitlywhat happens when objects of that type are copied, assigned, and destroyed. We do so by defining special members: the copy constructor, the assignment operator, and the destructor. If we do not explicitly define the copy constructor or the assignment operator, the compiler will (usually) define them for us
The copy constructor is a special constructor that has a single parameter that is a (usually const) reference to the class type. The copy constructor is used explicitly when we define a new object and initialize it from an object of the same type. It is used implicitly when we pass or return objects of that type to or from functions
The destructor is complementary to the constructors: It is applied automatically when an object goes out of scope or when a dynamically allocated object is deleted. The destructor is used to free resources acquired when the object was constructed or during the lifetime of the object. Regardless of whether a class defines its own destructor, the compiler automatically executes the destructors for the nonstatic data members of the class
Like constructors, the assignment operator may be overloaded by specifying different types for the right-hand operand. The version whose right-hand operand is of the class type is special: If we do not write one, the compiler will synthesize one for us
Collectively, the copy constructor, assignment operator, and destructor are referred to as copy control. The compiler automatically implements these operations, but the class may define its own versions
Copy control is an essential part of defining any C++ class. Programmers new to C++ are often confused by having to define what happens when objects are copied, assigned, or destroyed. This confusion is compounded because if we do not explicitly define these operations, the compiler defines them for usalthough they might not behave as we intend
Often the compiler-synthesized copy-control functions are finethey do exactly the work that needs to be done. But for some classes, relying on the default definitions leads to disaster. Frequently, the most difficult part of implementing the copy-control operations is recognizing when we need to override the default versions. One especially common case that requires the class to define its own the copy-control members is if the class has a pointer member

Section 13.1 The Copy Constructor

The constructor that takes a single parameter that is a (usually const) reference to an object of the class type itself is called the copy constructor. Like the default constructor, the copy constructor can be implicitly invoked by the compiler. The copy constructor is used to
- Explicitly or implicitly initialize one object from another of the same type
- Copy an object to pass it as an argument to a function
- Copy an object to return it from a function
- Initialize the elements in a sequential container
- Initialize elements in an array from a list of element initializers
Forms of Object Definition
- Recall that C++ supports two forms of initialization (Section 2.3.3, p. 48): direct and copy. Copy-initialization uses the = symbol, and direct-initialization places the initializer in parentheses
- The copy and direct forms of initialization, when applied to objects of class type, are subtly different. Direct-initialization directly invokes the constructor matched by the arguments. Copy-initialization always involves the copy constructor. Copy-initialization first uses the indicated constructor to create a temporary object (Section 7.3.2, p. 247). It then uses the copy constructor to copy that temporary into the one we are creating
- For objects of class type, copy-initialization can be used only when specifying a single argument or when we explicitly build a temporary object to copy
- The copy form of initialization is primarily supported for compatibility with C usage. When it can do so, the compiler is permitted (but not obligated) to skip the copy constructor and create the object directly
- Usually the difference between direct- or copy-initialization is at most a matter of low-level optimization. However, for types that do not support copying, or when using a constructor that is nonexplicit (Section 12.4.4, p. 462) the distinction can be essential
Parameters and Return Values
- As we know, when a parameter is a nonreference type (Section 7.2.1, p. 230), the argument is copied. Similarly, a nonreference return value (Section 7.3.2, p. 247) is returned by copying the value in the return statement
- When the parameter or return type is a class type, the copy is done by the copy constructor
Initializing Container Elements
- The copy constructor is used to initialize the elements in a sequential container
- As a general rule (Section 9.1.1, p. 307), unless you intend to use the default initial value of the container elements, it is more efficient to allocate an empty container and add elements as the values for those elements become known
Constructors and Array Elements
- If we provide no element initializers for an array of class type, then the default constructor is used to initialize each element. However, if we provide explicit element initializers using the normal brace-enclosed array initialization list (Section 4.1.1, p. 111), then each element is initialized using copy-initialization. An element of the appropriate type is created from the specified value, and then the copy constructor is used to copy that value to the corresponding element
13.1.1. The Synthesized Copy Constructor
- If we do not otherwise define the copy constructor, the compiler synthesizes one for us. Unlike the synthesized default constructor (Section 12.4.3, p. 458), a copy constructor is synthesized even if we define other constructors. The behavior of the synthesized copy constructor is to memberwise initialize the new object as a copy of the original object
- By memberwise, we mean that taking each nonstatic member in turn, the compiler copies the member from the existing object into the one being created. With one exception, the type of each member determines what it means to copy it. The synthesized copy constructor directly copies the value of members of built-in type. Members of class type are copied by using the copy constructor for that class. The one exception concerns array members. Even though we ordinarily cannot copy an array, if a class has a member that is an array, then the synthesized copy constructor will copy the array. It does so by copying each element
- The simplest conceptual model of memberwise initialization is to think of the synthesized copy constructor as one in which each data member is initialized in the constructor initializer list
13.1.2. Defining Our Own Copy Constructor
- The copy constructor is the constructor that takes a single parameter that is a (usually const) reference to the class type
```
class Foo {
```
```
     public:
```
```
        Foo();           // default constructor
```
```
        Foo(const Foo&); // copy constructor
```
```
        // ...
```
```
     };
```
- Usually the parameter is a const reference, although we can also define the copy constructor to take a nonconst reference. Because the constructor is used (implicitly) to pass and return objects to and from functions, it usually should not be made explicit (Section 12.4.4, p. 462). The copy constructor should copy the members from its argument into the object that is being constructed
- For many classes, the synthesized copy constructor does exactly the work that is needed. Classes that contain only members that are of class type or members that are of built-in (but not pointer type) often can be copied without explicitly defining the copy constructor
- However, some classes must take control of what happens when objects are copied. Such classes often have a data member that is a pointer or that represents another resource that is allocated in the constructor. Other classes have bookkeeping that must be done whenever a new object is created. In both these cases, the copy constructor must be defined
- Often the hardest part about defining a copy constructor is recognizing that a copy constructor is needed. Defining the constructor is usually pretty easy once the need for the constructor is recognized. The copy constructor itself is defined like any other constructor: It has the same name as the name of the class, it has no return value, it may (should) use a constructor initializer to initialize the members of the newly created object, and it may do any other necessary work inside a function body
13.1.3. Preventing Copies
- Some classes need to prevent copies from being made at all
- To prevent copies, a class must explicitly declare its copy constructor as private
- If the copy constructor is private, then user code will not be allowed to copy objects of the class type. The compiler will reject any attempt to make a copy
- However, the friends and members of the class could still make copies. If we want to prevent copies even within the friends and members, we can do so by declaring a (private) copy constructor but not defining it
- Most Classes Should Define Copy and Default Constructors
  - Classes that do not define the default constructor and/or the copy constructor impose serious limits on users of the class. Objects of classes that do not allow copies may be passed to (or returned from) a function only as a reference. They also may not be used as elements in a container
  - It is usually best to defineeither implicitly or explicitlythe default and copy constructors. The default constructor is synthesized only if there are no other constructors. If the copy constructor is defined, then the default constructor must be defined as well

Section 13.2 The Assignment Operator

Just as classes control how objects are initialized, they also define what happens when objects of their type are assigned
As with the copy constructor, the compiler synthesizes an assignment operator if the class does not define its own
Introducing Overloaded Assignment
- Overloaded operators are functions that have the name operator followed by the symbol for the operator being defined. Hence, we define assignment by defining a function named operator=. Like any other function, an operator function has a return type and a parameter list. The parameter list must have the same number of parameters (including the implicit this parameter if the operator is a member) as the operator has operands. Assignment is binary, so the operator function has two parameters: The first parameter corresponds to the left-hand operand, and the second to the right-hand operand
- Most operators may be defined as member or nonmember functions. When an operator is a member function, its first operand is implicitly bound to the this pointer. Some operators, assignment among them, must be members of the class for which the operator is defined. Because assignment must be a member of its class, this is bound to a pointer to the left-hand operand. The assignment operator, therefore, takes a single parameter that is an object of the same class type. Usually, the right-hand operand is passed as a const reference
- The return type from the assignment operator should be the same as the return from assignment for the built-in types (Section 5.4.1, p. 160). Assignment to a built-in type returns a reference to its left-hand operand. Therefore, the assignment operator also returns a reference to the same type as its class
The Synthesized Assignment Operator
- The synthesized assignment operator operates similarly to the synthesized copy constructor. It performs memberwise assignment: Each member of the right-hand object is assigned to the corresponding member of the left-hand object. Except for arrays, each member is assigned in the usual way for its type. For arrays, each array element is assigned
- The synthesized assignment operator assigns each member in turn, using the built-in or class-defined assignment operator as appropriate to the type of the member. The operator returns *this, which is a reference to the left-hand object
Copy and Assign Usually Go Together
- Classes that can use the synthesized copy constructor usually can use the synthesized assignment operator as well
- However, a class may define its own assignment operator. In general, if a class needs a copy constructor, it will also need an assignment operator
- In fact, these operations should be thought of as a unit. If we require one, we almost surely require the other

Section 13.3 The Destructor

The destructor is a special member function that can be used to do whatever resource deallocation is needed. It serves as the complement to the constructors of the class
When a Destructor Is Called
- The destructor is called automatically whenever an object of its class is destroyed
- An object that is dynamically allocated is destroyed only when a pointer pointing to the object is delete d. If we do not delete a pointer to a dynamically allocated object, then the destructor is never run on that object. The object will persist forever, leading to a memory leak. Moreover, any resources used inside the object will also not be released
- The destructor is not run when a reference or a pointer to an object goes out of scope. The destructor is run only when a pointer to a dynamically allocated object is deleted or when an actual object (not a reference to the object) goes out of scope
- Destructors are also run on the elements of class type in a container whether a library container or built-in array when the container is destroyed
- The elements in the container are always destroyed in reverse order: The element indexed by size() - 1 is destroyed first, followed by the one indexed by size() - 2 and so on until element [0], which is destroyed last
When to Write an Explicit Destructor
- Many classes do not require an explicit destructor. In particular, a class that has a constructor does not necessarily need to define its own destructor. Destructors are needed only if there is work for them to do. Ordinarily they are used to relinquish resources acquired in the constructor or during the lifetime of the object
- A useful rule of thumb is that if a class needs a destructor, it will also need the assignment operator and a copy constructor. This rule is often referred to as the Rule of Three, indicating that if you need a destructor, then you need all three copy-control members
- A destructor is not limited only to relinquishing resources. A destructor, in general, can perform any operation that the class designer wishes to have executed subsequent to the last use of an object of that class
The Synthesized Destructor
- Unlike the copy constructor or assignment operator, the compiler always synthesizes a destructor for us. The synthesized destructor destroys each nonstatic member in the reverse order from that in which the object was created. In consequence, it destroys the members in reverse order from which they are declared in the class. For each member that is of class type, the synthesized destructor invokes that member's destructor to destroy the object
- Destroying a member of built-in or compound type has no effect. In particular, the synthesized destructor does not delete the object pointed to by a pointer member
How to Write a Destructor
- Classes that do allocate resources usually need to define a destructor to free those resources. The destructor is a member function with the name of the class prefixed by a tilde (~). It has no return value and takes no parameters. Because it cannot specify any parameters, it cannot be overloaded. Although we can define multiple class constructors, we can provide only a single destructor to be applied to all objects of our class
- An important difference between the destructor and the copy constructor or assignment operator is that even if we write our own destructor, the synthesized destructor is still run

Section 13.4 A Message-Handling Example

The Message Class

Copy Control for the Message Class

When we write our own copy constructor, we must explicitly copy any members that we want copied. An explicitly defined copy constructor copies nothing automatically

As with any other constructor, if we do not initialize a class member, then that member is initialized using the member's default constructor. Default initialization in a copy constructor does not use the member's copy constructor

The put_Msg_in_Folders Member

Message Assignment Operator

The assignment operator starts by checking that the left- and right-hand operands are not the same. We do this check for reasons that will become apparent as we walk through the rest of the function

Assignment involves obliterating the left-hand operand. Once the members of the left-hand operand are destroyed, those in the right-hand operand are assigned to the corresponding left-hand members. If the objects were the same, then destroying the left-hand members would also destroy the right-hand members

It is crucially important for assignment operators to work correctly, even when an object is assigned to iself. A common way to ensure this behavior is by checking explicitly for self-assignment

The remove_Msg_from_Folders Member

The Message Destructor

The assignment operator often does the same work as is needed in the copy constructor and destructor. In such cases, the common work should be put in private utility functions

Section 13.5 Managing Pointer Members

Classes that contain pointers require careful attention to copy control. The reason they must do so is that copying a pointer copies only the address in the pointer. Copying a pointer does not copy the object to which the pointer points.

When designing a class with a pointer member, the first decision a class author must make is what behavior that pointer should provide. When we copy one pointer to another, the two pointers point to the same object. When two pointers point to the same object, it is possible to use either pointer to change the underlying object. Similarly, it is possible for one pointer to delete the object even though the user of the other pointer still thinks the underlying object exists

By default, a pointer member has the same behavior as a pointer object. However, through different copy-control strategies we can implement different behavior for pointer members

Most C++ classes take one of three approaches to managing pointer members

The pointer member can be given normal pointer like behavior. Such classes will have all the pitfalls of pointers but will require no special copy control.

The class can implement so-called "smart pointer" behavior. The object to which the pointer points is shared, but the class prevents dangling pointers.

The class can be given value like behavior. The object to which the pointer points will be unique to and managed separately by each class object.

In this section we look at three classes that implement each of these different approaches to managing their pointer members.

A Simple Class with a Pointer Member

Default Copy/Assignment and Pointer Members

Classes that have pointer members and use default synthesized copy control have all the pitfalls of ordinary pointers. In particular, the class itself has no way to avoid dangling pointers

Pointers Share the Same Object

Dangling Pointers Are Possible

13.5.1. Defining Smart Pointer Classes

An alternative to having a pointer member behave exactly like a pointer is to define what is sometimes referred to as a smart pointer class. A smart pointer behaves like an ordinary pointer except that it adds functionality.

In this case, we'll give our smart pointer the responsibility for deleting the shared object. Users will dynamically allocate an object and pass the address of that object to our new HasPtr class. The user may still access the object through a plain pointer but must not delete the pointer. The HasPtr class will ensure that the object is deleted when the last HasPtr that points to it is destroyed.

Our new HasPtr class will need a destructor to delete the pointer. However, the destructor cannot delete the pointer unconditionally. If two HasPtr objects point to the same underlying object, we don't want to delete the object until both objects are destroyed. To write the destructor, we need to know whether this HasPtr is the last one pointing to a given object

Introducing Use Counts

A common technique used in defining smart pointers is to use a use count. The pointerlike class associates a counter with the object to which the class points. The use count keeps track of how many objects of the class share the same pointer. When the use count goes to zero, then the object is deleted. A use count is sometimes also referred to as a reference count

Each time a new object of the class is created, the pointer is initialized and the use count is set to 1. When an object is created as a copy of another, the copy constructor copies the pointer and increments the associated use count. When an object is assigned to, the assignment operator decrements the use count of the object to which the left-hand operand points (and deletes that object if the use count goes to zero) and increments the use count of the object pointed to by the right-hand operand. Finally, when the destructor is called, it decrements the use count and deletes the underlying object if the count goes to zero

The Use-Count Class

There are two classic strategies for implementing a use count, one of which we will use here; the other approach is described in Section 15.8.1 (p. 599). In the approach we use here, we'll define a separate concrete class to encapsulate the use count and the associated pointer

Using the Use-Counted Class

Assignment and Use Counts

This assignment operator guards against self-assignment by incrementing the use count of rhs before decrementing the use count of the left-hand operand

Changing Other Members

Advice: Managing Pointer Members

Objects with pointer members often need to define the copy-control members. If we rely on the synthesized versions, then the class puts a burden on its users. Users must ensure that the object to which the member points stays around for at least as long as the object that points to it does.

To manage a class with pointer members, we must define all three copy-control members: the copy constructor, assignment operator, and the destructor. These members can define either pointerlike or valuelike behavior for the pointer member.

Valuelike classes give each object its own copy of the underlying values pointed to by pointer members. The copy constructor allocates a new element and copies the value from the object it is copying. The assignment operator destroys the existing object it holds and copies the value from its right-hand operand into its left-hand operand. The destructor destroys the object.

As an alternative to defining either valuelike behavior or pointerlike behavior some classes are so-called "smart pointers." These classes share the same underlying value between objects, thus providing pointerlike behavior. But they use copy-control techniques to avoid some of the pitfalls of regular pointers. To implement smart pointer behavior, a class needs to ensure that the underlying object stays around until the last copy goes away. Use counting (Section 13.5.1, p. 495), is a common technique for managing smart pointer classes. Each copy of the same underlying value is given a use count. The copy constructor copies the pointer from the old object into the new one and increments the use count. The assignment operator decrements the use count of the left-hand operand and increments the count of the right-hand operand. If the use count of the left-hand operand goes to zero, the assignment operator must delete the object to which it points. Finally, the assignment operator copies the pointer from the right-hand operand into its left-hand operand. The destructor decrements the use count and deletes the underlying object if the count goes to zero.

These approaches to managing pointers occur so frequently that programmers who use classes with pointer members must be thoroughly familiar with these programming techniques.

13.5.2. Defining Value like Classes

A completely different approach to the problem of managing pointer members is to give them value semantics. Simply put, classes with value semantics define objects that behave like the arithmetic types: When we copy a valuelike object, we get a new, distinct copy. Changes made to the copy are not reflected in the original, and vice versa. The string class is an example of a valuelike class

The copy constructor no longer copies the pointer. It now allocates a new int object and initializes that object to hold the same value as the object of which it is a copy. Each object always holds its own, distinct copy of its int value. Because each object holds its own copy, the destructor unconditionally deletes the pointer

As always, the assignment operator must be correct even if we're assigning an object to itself. In this case, the operations are inherently safe even if the left- and right-hand objects are the same. Thus, there is no need to explicitly check for self-assignment

C++ Primer, Fourth Edition:Notes Chapter 11. Generic Algorithms

2011-02-09T21:08:00.001-08:00

Section 11.1 Overview

Section 11.2 A First Look at the Algorithms

Section 11.3 Revisiting Iterators

Section 11.4 Structure of Generic Algorithms

Section 11.5 Container-Specific Algorithms

Good windows live writer code format plugin

2011-02-09T01:55:00.001-08:00

Please download it here:http://wlwplugincollection.codeplex.com/releases/view/9392

C++ Primer, Fourth Edition:Notes Chapter 12. Classes

2011-02-09T00:43:00.000-08:00

Section 12.1 Class Definitions and Declarations

In C++ we use classes to define our own abstract data types. By defining types that mirror concepts in the problems we are trying to solve, we can make our programs easier to write, debug, and modify

Classes are the most important feature in C++. Early versions of the language were named "C with Classes," emphasizing the central role of the class facility. As the language evolved, support for building classes increased. A primary goal of the language design has been to provide features that allow programmers to define their own types that are as easy and intuitive to use as the built-in types. This chapter presents many of the basic features of classes

12.1.1. Class Definitions: A Recap
- Most fundamentally, a class defines a new type and a new scope
- Class Members
  - Each class defines zero or more members. Members can be either data, functions, or type definitions
  - A class may contain multiple public, private, and protected sections
  - All members must be declared inside the class; there is no way to add members once the class definition is complete
- Constructors
  - When we create an object of a class type, the compiler automatically uses a constructor (Section 2.3.3, p. 49) to initialize the object. A constructor is a special member function that has the same name as the class. Its purpose is to ensure that each data member is set to sensible initial values
  - A constructor generally should use a constructor initializer list (Section 7.7.3, p. 263), to initialize the data members of the object
  - The constructor initializer list is a list of member names and parenthesized initial values. It follows the constructor's parameter list and begins with a colon
- Member Functions
  - Member functions must be declared, and optionally may be defined, inside the class; functions defined inside the class are inline (Section 7.6, p. 256) by default
  - Member functions defined outside the class must indicate that they are in the scope of the class. The definition of Sales_item::avg_price uses the scope operator (Section 1.2.2, p. 8) to indicate that the definition is for the avg_price function of the Sales_item class
  - Member functions take an extra implicit argument that binds the function to the object on behalf of which the function is calledwhen we write trans.avg_price() we are calling the avg_price function on the object named trans. If TRans is a Sales_item object, then references to a member of the Sales_item class inside the avg_price function are to the members in trans.
  - A const member may not change the data members of the object on which it operates. The const must appear in both the declaration and definition. It is a compile-time error for the const to be indicated on one but not the other

12.1.2. Data Abstraction and Encapsulation

The fundamental ideas behind classes are data abstraction and encapsulation
Data abstraction is a programming (and design) technique that relies on the separation of interface and implementation. The class designer must worry about how a class is implemented, but programmers that use the class need not know about these details. Instead, programmers who use a type need to know only the type's interface; they can think abstractly about what the type does rather than concretely about how the type works
Encapsulation is a term that describes the technique of combining lower-level elements to form a new, higher-level entity. A function is one form of encapsulation: The detailed actions performed by the function are encapsulated in the larger entity that is the function itself. Encapsulated elements hide the details of their implementationwe may call a function but have no access to the statements that it executes. In the same way, a class is an encapsulated entity: It represents an aggregation of several members, and most (well-designed) class types hide the members that implement the type
Access Labels Enforce Abstraction and Encapsulation
- Members defined after a public label are accessible to all parts of the program. The data-abstraction view of a type is defined by its public members
- Members defined after a private label are not accessible to code that uses the class. The private sections encapsulate (e.g., hide) the implementation from code that uses the type
- There are no restrictions on how often an access label may appear. Each access label specifies the access level of the succeeding member definitions. The specified access level remains in effect until the next access label is encountered or the closing right brace of the class body is seen
- A class may define members before any access label is seen. The access level of members defined after the open curly of the class and before the first access label depend on how the class is defined. If the class is defined with the struct keyword, then members defined before the first access label are public; if the class is defined using the class keyword, then the members are private

Advice: Concrete and Abstract Types

Not all types need to be abstract. The library pair class is a good example of a useful, well-designed class that is concrete rather than abstract. A concrete class is a class that exposes, rather than hides, its implementation.

Some classes, such as pair, really have no abstract interface. The pair type exists to bundle two data members into a single object. There is no need or advantage to hiding the data members. Hiding the members in a class like pair would only complicate the use of the type.

Even so, such types often have member functions. In particular, it is a good idea for any class that has data members of built-in or compound type to define constructor(s) to initialize those members. The user of the class could initialize or assign to the data members but it is less error-prone for the class to do so.

Different Kinds of Programming Roles

When designing the interface to a class, the class designer should think about how easy it will be to use the class. When using the class, the designer shouldn't think about how the class works
C++ programmers tend to speak of "users" interchangably as users of the application or users of a class

Key Concept: Benefits of Data Abstraction and Encapsulation

Data abstraction and encapsulation provide two important advantages:

Class internals are protected from inadvertent user-level errors, which might corrupt the state of the object.
The class implementation may evolve over time in response to changing requirements or bug reports without requiring change in user-level code.

By defining data members only in the private section of the class, the class author is free to make changes in the data. If the implementation changes, only the class code needs to be examined to see what affect the change may have. If data are public, then any function that directly accesses the data members of the old representation might be broken. It would be necessary to locate and rewrite all those portions of code that relied on the old representation before the program could be used again.

Similarly, if the internal state of the class is private, then changes to the member data can happen in only a limited number of places. The data is protected from mistakes that users might introduce. If there is a bug that corrupts the object's state, the places to look for the bug are localized: When data are private, only a member function could be responsible for the error. The search for the mistake is limited, greatly easing the problems of maintenance and program correctness.

If the data are private and if the interface to the member functions does not change, then user functions that manipulate class objects require no change.

Because changing a class definition in a header file effectively changes the text of every source file that includes that header, code that uses a class must be recompiled when the class changes.

12.1.3. More on Class Definitions
- Multiple Data Members of the Same Type
  - One way in which member declarations and ordinary declarations are the same is that if a class has multiple data members with the same type, these members can be named in a single member declaration
- Using Typedefs to Streamline Classes
  - In addition to defining data and function members, a class can also define its own local names for types
  - Type names defined by a class obey the standard access controls of any other member. We put the definition of index in the public part of the class because we want users to use that name
- Member Functions May Be Overloaded
  - With the exception of overloaded operators (Section 14.9.5, p. 547)which have special rulesa member function overloads only other member functions of its own class. A class member function is unrelated to, and cannot overload, ordinary nonmember functions or functions declared in other classes. The same rules apply to overloaded member functions as apply to plain functions: Two overloaded members cannot have the same number and types of parameters
- Defining Overloaded Member Functions
- Explicitly Specifying inline Member Functions
  - We can specify that a member is inline as part of its declaration inside the class body. Alternatively, we can specify inline on the function definition that appears outside the class body. It is legal to specify inline both on the declaration and definition. One advantage of defining inline functions outside the class is that it can make the class easier to read
  - As with other inlines, the definition of an inline member function must be visible in every source file that calls the function. The definition for an inline member function that is not defined within the class body ordinarily should be placed in the same header file in which the class definition appears
12.1.4. Class Declarations versus Definitions
- A class is completely defined once the closing curly brace appears. Once the class is defined, all the class members are known
- The size required to store an object of the class is known as well
- A class may be defined only once in a given source file. When a class is defined in multiple files, the definition in each file must be identical.
- By putting class definitions in header files, we can ensure that a class is defined the same way in each file that uses it. By using header guards (Section 2.9.2, p. 69), we ensure that even if the header is included more than once in the same file, the class definition will be seen only once
- It is possible to declare a class without defining it
- This declaration, sometimes referred to as a forward declaration, introduces the name Screen into the program and indicates that Screen refers to a class type. After a declaration and before a definition is seen, the type Screen is an incompete typeit's known that Screen is a type but not known what members that type contains
- An incomplete type can be used only in limited ways. Objects of the type may not be defined. An incomplete type may be used to define only pointers or references to the type or to declare (but not define) functions that use the type as a paremeter or return type
- A data member can be specified to be of a class type only if the definition for the class has already been seen. If the type is incomplete, a data member can be only a pointer or a reference to that class type
- However, a class is considered declared as soon as its class name has been seen. Therefore, a class can have data members that are pointers or references to its own type
- A common use of class forward declarations is to write classes that are mutually dependent on one another
12.1.5. Class Objects
- When we define a class, we are defining a type. Once a class is defined, we can define objects of that type. Storage is allocated when we define objects, but (ordinarily) not when we define types
- Each object has its own copy of the class data members. Modifying the data members of item does not change the data members of any other Sales_item object
- Defining Objects of Class Type
  - Using the class name directly as a type name
- Why a Class Definition Ends in a Semicolon
  - A semicolon is required because we can follow a class definition by a list of object definitions. As always, a definition must end in a semicolon
  - Ordinarily, it is a bad idea to define an object as part of a class definition. Doing so obscures what's happening. It is confusing to readers to combine definitions of two different entitiesthe class and a variablein a single statement

Section 12.2 The Implicit this Pointer

member functions have an extra implicit parameter that is a pointer to an object of the class type. This implicit parameter is named this, and is bound to the object on which the member function is called
Member functions may not define the this parameter; the compiler does so implicitly. The body of a member function may explicitly use the this pointer, but is not required to do so. The compiler treats an unqualified reference to a class member as if it had been made through the this pointer
When to Use the this Pointer
- there is one case in which we must do so: when we need to refer to the object as a whole rather than to a member of the object
Returning *this
Returning *this from a const Member Function
- In an ordinary nonconst member function, the type of this is a const pointer (Section 4.2.5, p. 126) to the class type. We may change the value to which this points but cannot change the address that this holds
- In a const member function, the type of this is a const pointer to a const class-type object. We may change neither the object to which this points nor the address that this holds
- We cannot return a plain reference to the class object from a const member function. A const member function may return *this only as a const reference
Overloading Based on const
- We can overload a member function based on whether it is const for the same reasons that we can overload a function based on whether a pointer parameter points to const
- A const object will use only the const member. A nonconst object could use either member, but the nonconst version is a better match

Mutable Data Members

It sometimes (but not very often) happens that a class has a data member that we want to be able to modify, even inside a const member function. We can indicate such members by declaring them as mutable

A mutable data member is a member that is never const, even when it is a member of a const object. Accordingly, a const member function may change a mutable member

Advice: Use Private Utility Functions for Common Code

Some readers might be surprised that we bothered to define a separate do_display operation. After all, the calls to do_display aren't much simpler than the action done inside do_display. Why bother? We do so for several reasons:

A general desire to avoid writing the same code in more than one place.
The display operation can be expected to become more complicated as our class evolves. As the actions involved become more complex, it makes more obvious sense to write those actions in one place, not two.
It is likely that we might want to add debugging information to do_display during development that would be eliminated in the final product version of the code. It will be easier to do so if only one definition of do_display needs to be changed to add or remove the debugging code.
There needn't be any overhead involved in this extra function call. We made do_display inline, so the run-time performance between calling do_display or putting the code directly into the display operations should be identical.

In practice, well-designed C++ programs tend to have lots of small functions such as do_display that are called to do the "real" work of some other set of functions.

Section 12.3 Class Scope

Every class defines its own new scope and a unique type. The declarations of the class members within the class body introduce the member names into the scope of their class. Two different classes have two different class scopes
Even if two classes have exactly the same member list, they are different types. The members of each class are distinct from the members of any other class (or any other scope).
Using a Class Member
1. Outside the class scope, members may be accessed only through an object or a pointer using member access operators dot or arrow, respectively
2. Some members are accessed using the member access operators; others are accessed directly from the class using the scope operator, (::). Ordinary data or function members must be accessed through an object. Members that define types, such as Screen::index, are accessed using the scope operator
Scope and Member Definitions
1. Member definitions behave as if they are in the scope of the class, even if the member is defined outside the class body
Parameter Lists and Function Bodies Are in Class Scope
1. These are defined inside the class scope and so may refer to other class members without qualification
Function Return Types Aren't Always in Class Scope
1. If the function is defined outside the class body, then the name used for the return type is outside the class scope. If the return type uses a type defined by the class, it must use the fully qualified name
12.3.1. Name Lookup in Class Scope
1. In the programs we've written so far, name lookup (the process of finding which declaration is matched to a given use of a name) has been relatively straightforward
  1. First, look for a declaration of the name in the block in which the name was used. Only names declared before the use are considered.
  2. If the name isn't found, the enclosing scope(s) are searched.
2. If no declaration is found, then the program is in error. In C++ programs, all names must be declared before they are used
3. Class scopes may seem to behave a bit differently, but in reality they obey this same rule. Confusion can arise due to the way names are resolved inside a function defined within the class body itself
4. Class definitions are actually processed in two phases
  1. First, the member declarations are compiled
  2. Only after all the class members have been seen are the definitions themselves compiled
5. Of course, the names used in class scope do not always have to be class member names. Name lookup in class scope finds names declared in other scopes as well. During name lookup, if a name used in class scope does not resolve to a class member name, the scopes surrounding the class or member definition are searched to find a declaration for the name
6. Name Lookup for Class Member Declarations
  1. Names used in the declarations of a class member are resolved as follows
    1. The declarations of the class members that appear before the use of the name are considered
    2. If the lookup in step 1 is not successful, the declarations that appear in the scope in which the class is defined, and that appear before the class definition itself, are considered
  2. Names of types defined in a class must be seen before they are used as the type of a data member or as the return type or parameter type(s) of a member function
  3. The compiler handles member declarations in the order in which they appear in the class. As usual, a name must be defined before it can be used. Moreover, once a name has been used as the name of a type, that name may not be redefined
7. Name Lookup in Class Member Definitions
  1. A name used in the body of a member function is resolved as follows
    1. Declarations in the member-function local scopes are considered first
    2. If the a declaration for the name is not found in the member function, the declarations for all the class members are considered
    3. If a declaration for the name is not found in the class, the declarations that appear in scope before the member function definition are considered
8. Class Members Follow Normal Block-Scope Name Lookup
  1. Programs that illustrate how name lookup works often have to rely on bad practices. The next several programs contain bad style deliberately
  2. The following function uses the same name for a parameter and a member, which normally should be avoided
  3. Even though the class member is hidden, it is still possible to use it by qualifying the member's name with the name of its class or by using the this pointer explicitly
9. After Function Scope, Look in Class Scope
10. After Class Scope, Look in the Surrounding Scope
  1. Even though the global object is hidden, it is still possible to use it by qualifying the name with the global scope resolution operator
11. Names Are Resolved Where They Appear within the File
  1. When a member is defined outside the class definition, the third step of name lookup not only considers the declarations in global scope that appear before the definition of class Screen, but also considers the global scope declarations that appear before the member function definition

Section 12.4 Constructors

Constructors (Section 2.3.3, p. 49) are special member functions that are executed whenever we create new objects of a class type. The job of a constructor is to ensure that the data members of each object start out with sensible initial values
Constructors have the same name as the name of the class and may not specify a return type. Like any other function, they may define zero or more parameters
Constructors May Be Overloaded
1. There is no constraint on the number of constructors we may declare for a class, provided that the parameter list of each constructor is unique. How can we know which or how many constructors to define? Ordinarily, constructors differ in ways that allow the user to specify differing ways to initialize the data members
Arguments Determine Which Constructor to Use
1. The argument type(s) used to initialize an object determines which constructor is used
Constructors Are Executed Automatically
1. The compiler runs a constructor whenever an object of the type is created
Constructors for const Objects
1. A constructor may not be declared as const
2. There is no need for a const constructor. When we create a const object of a class type, an ordinary constructor is run to initialize the const object. The job of the constructor is to initialize an object. A constructor is used to initialize an object regardless of whether the object is const
12.4.1. The Constructor Initializer
1. Like any other function, a constructor has a name, a parameter list, and a function body. Unlike other functions, a constructor may also contain a constructor initializer list
2. The constructor initializer starts with a colon, which is followed by a comma-separated list of data members each of which is followed by an initializer inside parentheses
3. As with any member function, constructors can be defined inside or outside of the class. The constructor initializer is specified only on the constructor definition, not its declaration
4. The constructor initializer is a feature that many reasonably experienced C++ programmers have not mastered
5. Data members of class type are always initialized in the initialization phase, regardless of whether the member is initialized explicitly in the constructor initializer list. Initialization happens before the computation phase begins
6. Each member that is not explicitly mentioned in the constructor initializer is initialized using the same rules as those used to initialize variables (Section 2.3.4, p. 50). Data members of class type are initialized by running the type's default constructor. The initial value of members of built-in or compound type depend on the scope of the object: At local scope those members are uninitialized, at global scope they are initialized to 0
7. Constructor Initializers Are Sometimes Required
  1. If an initializer is not provided for a class member, then the compiler implicitly uses the default constructor for the member's type. If that class does not have a default constructor, then the attempt by the compiler to use it will fail. In such cases, an initializer must be provided in order to initialize the data member
  2. Some members must be initialized in the constructor initializer. For such members, assigning to them in the constructor body doesn't work. Members of a class type that do not have a default constructor and members that are const or reference types must be initialized in the constructor initializer regardless of type
  3. Remember that we can initialize but not assign to const objects or objects of reference type. By the time the body of the constructor begins executing, initialization is complete. Our only chance to initialize const or reference data members is in the constructor initializer
    Advice: Use Constructor Initializers
    
    In many classes, the distinction between initialization and assignment is strictly a matter of low-level efficiency: A data member is initialized and assigned when it could have been initialized directly. More important than the efficiency issue is the fact that some data members must be initialized.
    
    We must use an initializer for any const or reference member or for any member of a class type that does not have a default constructor.
    
    By routinely using constructor initializers, we can avoid being surprised by compile-time errors when we have a class with a member that requires a constructor initializer.
8. Order of Member Initialization
  1. Not surprisingly, each member may be named only once in the constructor initializer. After all, what might it mean to give a member two initial values? What may be more surprising is that the constructor initializer list specifies only the values used to initialize the members, not the order in which those initializations are performed. The order in which members are initialized is the order in which the members are defined. The first member is initialized first, then the next, and so on
  2. The order of initialization often doesn't matter. However, if one member is initialized in terms of another, then the order in which members are initialized is crucially important
  3. It is a good idea to write constructor initializers in the same order as the members are declared. Moreover, when possible, avoid using members to initialize other members
  4. It is often the case that we can avoid any problems due to order of execution for initializers by (re)using the constructor's parameters rather than using the object's data members
9. Initializers May Be Any Expression
  1. An initializer may be an arbitrarily complex expression
10. Initializers for Data Members of Class Type
  1. When we initialize a member of class type, we are specifying arguments to be passed to one of the constructors of that member's type. We can use any of that type's constructors

12.4.2. Default Arguments and Constructors

We can combine these constructors by supplying a default argument for the string initializer
We prefer to use a default argument because it reduces code duplication.

class Sales_item {     public:         // default argument for book is the empty string         Sales_item(const std::string &book = ""):                   isbn(book), units_sold(0), revenue(0.0) { }         Sales_item(std::istream &is);         // as before     };  

12.4.3. The Default Constructor
1. The default constructor is used whenever we define an object but do not supply an initializer. A constructor that supplies default arguments for all its parameters also defines the default constructor
2. The Synthesized Default Constructor
  1. If a class defines even one constructor, then the compiler will not generate the default constructor. The basis for this rule is that if a class requires control to initialize an object in one case, then the class is likely to require control in all cases
  2. The compiler generates a default constructor automatically only if a class defines no constructors
  3. The synthesized default constructor initializes members using the same rules as those that apply for how variables are initialized. Members that are of class type are initialized by running each member's own default constructor. Members of built-in or compound type, such as pointers and arrays, are initialized only for objects that are defined at global scope. When objects are defined at local scope, then members of built-in or compound type are uninitialized
  4. If a class contains data members of built-in or compound type, then the class should not rely on the synthesized default constructor. It should define its own constructor to initialize these members
3. Classes Should Usually Define a Default Constructor
  1. In certain cases, the default constructor is applied implicitly by the compiler. If the class has no default constructor, then the class may not be used in these contexts
  2. In practice, it is almost always right to provide a default constructor if other constructors are being defined. Ordinarily the initial values given to the members in the default constructor should indicate that the object is "empty."
4. Using the Default Constructor
12.4.4. Implicit Class-Type Conversions
1. To define an implicit conversion to a class type, we need to define an appropriate constructor.
2. Suppressing Implicit Conversions Defined by Constructors
  1. We can prevent the use of a constructor in a context that requries an implicit conversion by declaring the constructor explicit
  2. The explicit keyword is used only on the constructor declaration inside the class. It is not repeated on a definition made outside the class body
  3. When a constructor is declared explicit, the compiler will not use it as a conversion operator
3. Explicitly Using Constructors for Conversions
  1. An explicit constructor can be used to generate a conversion as long as we do so explicitly
  2. Making a constructor explicit turns off only the use of the constructor implicitly. Any constructor can be used to explicitly create a temporary object
  3. Ordinarily, single-parameter constructors should be explicit unless there is an obvious reason to want to define an implicit conversion. Making constructors explicit may avoid mistakes, and a user can explicitly construct an object when a conversion is useful
12.4.5. Explicit Initialization of Class Members
1. Although most objects are initialized by running an appropriate constructor, it is possible to initialize the data members of simple nonabstract classes directly. Members of classes that define no constructors and all of whose data members are public may be initialized in the same way that we initialize array elements
```
struct Data {
```
```
    int ival;
```
```
    char *ptr;
```
```
};
```
```
// val1.ival = 0; val1.ptr = 0
```
```
Data val1 = { 0, 0 };
```
```
 
```
```
// val2.ival = 1024;
```
```
// val2.ptr = "Anna Livia Plurabelle"
```
```
Data val2 = { 1024, "Anna Livia Plurabelle" };
```
2. This form of initialization is inherited from C and is supported for compatibility with C programs. There are three significant drawbacks to explicitly initializing the members of an object of class type
  1. It requires that all the data members of the class be public
  2. It puts the burden on the programmer to initialize every member of every object. Such initialization is tedious and error-prone because it is easy to forget an initializer or to supply an inappropriate initializer
  3. If a member is added or removed, all initializations have to be found and updated correctly
3. It is almost always better to define and use constructors. When we provide a default constructor for the types we define, we allow the compiler to automatically run that constructor, ensuring that every class object is properly initialized prior to the first use of that object

Section 12.5 Friends

In some cases, it is convenient to let specific nonmember functions access the private members of a class while still preventing general access

The friend mechanism allows a class to grant access to its nonpublic members to specified functions or classes. A friend declaration begins with the keyword friend. It may appear only within a class definition. Friend declarations may appear anywhere in the class: Friends are not members of the class granting friendship, and so they are not affected by the access control of the section in which they are declared

Ordinarily it is a good idea to group friend declarations together either at the beginning or end of the class definition

Friendship: An Example

A friend may be an ordinary, nonmember function, a member function of another previously defined class, or an entire class. In making a class a friend, all the member functions of the friend class are given access to the nonpublic members of the class granting friendship

Making Another Class' Member Function a Friend

When we declare a member function to be a friend, the name of the function must be qualified by the name of the class of which it is a member

Friend Declarations and Scope

Interdependencies among friend declarations and the definitions of the friends can require some care in order to structure the classes correctly

More generally, to make a member function a friend, the class containing that member must have been defined. On the other hand, a class or nonmember function need not have been declared to be made a friend

A friend declaration introduces the named class or nonmember function into the surrounding scope. Moreover, a friend function may be defined inside the class. The scope of the function is exported to the scope enclosing the class definition

Overloaded Functions and Friendship

A class must declare as a friend each function in a set of overloaded functions that it wishes to make a friend

Section 12.6 static Class Members

It is sometimes necessary for all the objects of a particular class type to access a global object. Perhaps a count is needed of how many objects of a particular class type have been created at any one point in the program, or the global object may be a pointer to an error-handling routine for the class, or it may be a pointer to the free-store memory for objects of this class type

Ordinary, nonstatic data members exist in each object of the class type. Unlike ordinary data members, a static data member exists independently of any object of its class; each static data member is an object associated with the class, not with the objects of that class

Just as a class may define shared static data members, it may also define static member functions. A static member function has no this parameter. It may directly access the static members of its class but may not directly use the nonstatic members

Advantages of Using Class static Members

The name of a static member is in the scope of the class, thereby avoiding name collisions with members of other classes or global objects

Encapsulation can be enforced. A static member can be a private member; a global object cannot

It is easy to see by reading the program that a static member is associated with a particular class. This visibility clarifies the programmer's intentions

Defining static Members

Amember ismade static by prefixing the member declaration with the keyword static. The static members obey the normal public/private access rules

Using a Class static Member

A static member can be invoked directly from the class using the scope operator or indirectly through an object, reference, or pointer to an object of its class type

As with other members, a class member function can refer to a class static member without the use of the scope operator

12.6.1. static Member Functions

When we define a static member outside the class, we do not respecify the static keyword.

static Functions Have No this Pointer

A static member is part of its class but not part of any object. Hence, a static member function does not have a this pointer. Referring to this either explicitly or implicitly by using a nonstatic member is a compile-time error

Because a static member is not part of any object, static member functions may not be declared as const. After all, declaring a member function as const is a promise not to modify the object of which the function is a member. Finally, static member functions may also not be declared as virtual

12.6.2. static Data Members

static data members can be declared to be of any type. They can be consts, references, arrays, class types, and so forth

static data members must be defined (exactly once) outside the class body. Unlike ordinary data members, static members are not initialized through the class constructor(s) and instead should be initialized when they are defined

The best way to ensure that the object is defined exactly once is to put the definition of static data members in the same file that contains the definitions of the class noninline member functions

static data members are defined in the same way that other class members and other variables are defined. The member is defined by naming its type followed by the fully qualified name of the member

As with any class member, when we refer to a class static member outside the class body, we must specify the class in which the member is defined. The static keyword, however, is used only on the declaration inside the class body. Definitions are not labeled static

Integral const static Members Are Special

Ordinarily, class static members, like ordinary data members, cannot be initialized in the class body. Instead, static data members are normally initialized when they are defined.

When a const static data member is initialized in the class body, the data member must still be defined outside the class definition

When an initializer is provided inside the class, the definition of the member must not specify an initial value

static Members Are Not Part of Class Objects

Ordinary members are part of each object of the given class. static members exist independently of any object and are not part of objects of the class type. Because static data members are not part of any object, they can be used in ways that would be illegal for nonstatic data members

the type of a static data member can be the class type of which it is a member. A nonstatic data member is restricted to being declared as a pointer or a reference to an object of its class

Similarly, a static data member can be used as a default argument

A nonstatic data member may not be used as a default argument because its value cannot be used independently of the object of which it is a part. Using a nonstatic data member as a default argument provides no object from which to obtain the member's value and so is an error

C++ Primer, Fourth Edition:Notes Chapter 10 Associative Containers

2011-01-21T04:52:00.000-08:00

Associative containers differ in a fundamental respect from the sequential containers: Elements in an associative container are stored and retrieved by a key, in contrast to elements in a sequential container, which are stored and accessed sequentially by their position within the container

Associative containers support efficient lookup and retrieval by a key. The two primary associative-container types are map and set. The elements in a map are keyvalue pairs: The key serves as an index into the map, and the value represents the data that are stored and retrieved. A set contains only a key and supports efficient queries to whether a given key is present

In general, a set is most useful when we want to store a collection of distinct values efficiently, and a map is most useful when we wish to store (and possibly modify) a value associated with each key

We might use a set to hold words that we want to ignore when doing some kind of text processing. A dictionary would be a good use for a map: The word would be the key, and its definition would be the value

An object of the map or set type may contain only a single element with a given key. There is no way to add a second element with the same key. If we need to have multiple instances with a single key, then we can use multimap or multi set, which do allow multiple elements with a given key

Table 10.1. Associative Container Types
`map`	Associative array; elements stored and retrieved by key
`set`	Variable-sized collection with fast retrieval by key
`multimap`	`map` in which a key can appear multiple times
`multiset`	`set` in which a key can appear multiple times

Section 10.1 Preliminaries: the pair Type

Before we look at the associative containers, we need to know about a simple companion library type named pair, which is defined in the utility header.

Creating and Initializing pairs

A pair holds two data values. Like the containers, pair is a template type. Unlike the containers we've seen so far, we must supply two type names when we create a pair: A pair holds two data members, each of which has the corresponding named type
When we create pair objects with no initializer, the default constructor value-initializes the members

The pair type can be unwieldy to type, so when we wish to define a number of objects of the same pair type, it is convenient to use a typedef

Table 10.2. Operations on `pairs`
`pair<T1, T2> p1;`	Create an empty `pair` with two elements of types `T1` and `T2`. The elements are value-initialized (Section 3.3.1, p. 92).
`pair<T1, T2> p1(v1, v2);`
	Create a `pair` with types `T1` and `T2` initializing the `first` member from `v1` and the `second` from `v2`.
`make_pair(v1, v2)`	Creates a new `pair` from the values `v1` and `v2`. The type of the `pair` is inferred from the types of `v1` and `v2`.
`p1 < p2`	Less than between two pair objects. Less than is defined as dictionary ordering: Returns `true` if `p1.first < p2.first` or if `!(p2.first < p1.first) && p1.second < p2.second`.
`p1 == p2`	Two `pair`s are equal if their `first` and `second` members are respectively equal. Uses the underlying element `==` operator.
`p.first`	Returns the (`public`) data member of `p` named `first`.
`p.second`	Returns the (`public`) data member of `p` named `second`.

Operations on pairs
1. Unlike other library types, the pair class gives us direct access to its data members: Its members are public

Generating a New pair

In addition to the constructors, the library defines the make_pair function, which generates a new pair from its two arguments. We might use this function to make a new pair to assign to an existing pair

// EXE-10.1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <utility>
#include <string>
#include <iostream>
#include <vector>

using namespace std;

int main()
{
	typedef pair<string, string> Author;
	if("Creating and Initializing pairs")
	{
		pair<string, string> anon;       // holds two strings
		pair<string, int> word_count;    // holds a string and an int
		pair< string, vector<int> > line; // holds string and vector<int>
		pair<string, string> author("James", "Joyce");
		
		Author proust("Marcel", "Proust");
		Author joyce("James", "Joyce");

	}
	if("Operations on pairs")
	{
		Author author("James","Joyce");
		string firstBook;
		// access and test the data members of the pair
		if (author.first == "James" && author.second == "Joyce")
			firstBook = "Stephen Hero";

	}
	if("Generating a New pair")
	{
		pair<string, string> next_auth;
		string first, last;
		while (cin >> first >> last) {
			// generate a pair from first and last
			next_auth = make_pair(first, last);

			// use pair constructor to make first and last into a pair
			//next_auth = pair<string, string>(first, last);

			// process next_auth...
		}
	}

	int screen_hold;
	cin >> screen_hold;

	return 0;
}

Section 10.2 Associative Containers

The operations common to sequential and associative containers are
1. The first three constructors described in Table 9.2 (p. 307):
2. ```
     C<T> c;          // creates an empty container
     // c2 must be same type as c1
     C<T> c1(c2);    // copies elements from c2 into c1
     // b and e are iterators denoting a sequence
     C<T> c(b, e);   // copies elements from the sequence into c
```
3. The relational operations described in Section 9.3.4 (p. 321
4. The begin, end, rbegin, and rend operations of Table 9.6 (p. 317
5. The typedefs listed in Table 9.5 (p. 316). Note that for map, the value_type is not the same as the element type. Instead, value_type is a pair representing the types of the keys and associated values. Section 10.3.2 (p. 361) explains the typedefs for maps in more detail
6. The swap and assignment operator described in Table 9.11 (p. 329). Associative containers do not provide the assign functions
7. The clear and erase operations from Table 9.10 (p. 326), except that the erase operation on an associative container returns void
8. The size operations in Table 9.8 (p. 324) except for resize, which we cannot use on an associative container
Elements Are Ordered by Key
1. The associative container types define additional operations beyond the ones just listed. They also redefine the meaning or return type of operations that are in common with the sequential containers. The differences in these common operations reflect the use of keys in the associative containers
2. There is one important consequence of the fact that elements are ordered by key: When we iterate across an associative container, we are guaranteed that the elements are accessed in key order, irrespective of the order in which the elements were placed in the container

Section 10.3 The map Type

A map is a collection of keyvalue pairs. The map type is often referred to as an associative array: It is like the built-in array type, in that the key can be used as an index to fetch a value. It is associative in that values are associated with a particular key rather than being fetched by position in the array

10.3.1. Defining a map

To use a map, we must include the map header

Table 10.3. Constructors for `map`
`map<k, v> m;`	Create an empty `map` named `m` with key and value types `k` and `v`.
`map<k, v> m(m2);`	Create `m` as a copy of `m2`; `m` and `m2` must have the same key and value types.
`map<k, v> m(b, e);`	Create `m` as a copy of the elements from the range denoted by iterators `b` and `e`. Elements must have a type that can be converted to `pair<const k, v>`.

Constraints on the Key Type
1. Whenever we use an associative container, its keys have not only a type, but also an associated comparison function. By default, the library uses the < operator for the key type to compare the keys
2. Whichever comparison function we use must define a strict weak ordering over the key type. We can think of a strict weak ordering as "less than," although we might choose to define a more complicated comparison function. However we define it, such a comparison function must always yield false when we compare a key with itself. Moreover, if we compare two keys, they cannot both be "less than" each other, and if k1 is "less than" k2, which in turn is "less than" k3, then k1 must be "less than" k3. If we have two keys, neither of which is "less than" the other, the container will treat them as equal. When used as a key to a map, either value could be used to access the corresponding element
3. In practice, what's important is that the key type must define the < operator and that that operator should "do the right thing."
4. The key type needs to support only the < operator. There is no requirement that it support the other relational or equality operators

10.3.2. Types Defined by map

The elements of a map are keyvalue pairs That is, each element has two parts: its key and the value associated with that key. The value_type for a map reflects this fact. This type is more complicated than those we've seen for other containers: value_type is a pair that holds the key and value of a given element. Moreover, the key is const

Table 10.4. Types Defined by the `map` Class
`map<K, V>::key_type`	The type of the keys used to index the `map`.
`map<K, V>::mapped_type`	The type of the values associated with the keys in the `map`.
`map<K, V>::value_type`	A pair whose first element has type `const`
	`map<K, V>::key_type` and `second` has type
	`map<K, V>::mapped_type`.

When learning the map interface, it is essential to remember that the value_type is a pair and that we can change the value but not the key member of that pair
Dereferencing a map Iterator Yields a pair
1. When we dereference an iterator, we get a reference to a value of the container's value_type
Additional map Typedefs
1. The map class defines two additional types, key_type and mapped_type, that let us access the type of either the key or the value

10.3.3. Adding Elements to a map
1. We can do so either by using the insert member or by fetching an element using the subscript operator and then assigning a value to the element returned. In both cases, the fact that there can be only a single element for a given key affects the behavior of these operations
2. The following steps take place
  1. word_count is searched for the element whose key is Anna. The element is not found.
  2. A new keyvalue pair is inserted into word_count. The key is a const string holding Anna. The value is value initialized, meaning in this case that the value is 0.
  3. The new keyvalue pair is inserted into word_count.
  4. The newly inserted element is fetched and is given the value 1.
3. Subscripting a map behaves quite differently from subscripting an array or vector: Using an index that is not already present adds an element with that index to the map
4. As with other subscript operators, the map subscript takes an index (that is, a key) and fetches the value associated with that key. When we look for a key that is already in the map, then the behavior is the same for a map subscript or a vector subscript: The value associated with the key is returned. For maps only, if the key is not already present, a new element is created and inserted into the map for that key. The associated value is value-initialized: An element of class type is initialized using the default constructor for the element type; a built-in type is initialized to 0
5. Using the Value Returned from a Subscript Operation
  1. Unlike vector or string, the type returned by map subscript operator differs from the type obtained by dereferencing a map iterator
6. Programming Implications of the Subscript Behavior
10.3.4. Subscripting a map

10.3.5. Using map::insert

The insert members operate similarly to the operations on sequential containers (Section 9.3.3, p. 318), with one important caveat: We must account for the effect of the key.
The key impacts the argument types: The versions that insert a single element take a value that is a keyvalue pair. Similarly, for the version that takes an iterator pair, the iterators must refer to elements that are keyvalue pairs. The other difference is the return type from the version of insert that takes a single value, which we will cover in the remainder of this section

Using insert Instead of Subscripting

Alternatively, we could insert the element directly by using the syntactically more intimidating insert member

Table 10.5. `insert` Operations on maps
`m.insert(e)`	`e` is a value of the `value_type` for `m`. If the key(`e.first)` is not in `m`, inserts a new element with value `e.second`. If the key is in `m`, then `m` is unchanged. Returns a `pair` containing a `map` iterator referring to the element with key `e.first` and a `bool` indicating whether the element was inserted or not.
`m.insert(beg, end)`	`beg` and `end` are iterators that denote a range of values that are keyvalue `pair`s with the same type as `m`'s `value_type`. For each element in the range, if the given key is not already in `m`, it inserts the key and its associated value into `m`. Returns `void`.
`m.insert(iter, e)`	`e is` a value of the `value_type` for `m`. If the key(`e.first)` is not in `m`, inserts the new element using the iterator `iter` as a hint for where to begin the search for where the new element should be stored. Returns an iterator that refers to the element in `m` with given key.

// if Anna not already in word_count, inserts new element with value 1
     word_count.insert(map<string, int>::value_type("Anna", 1));

Remember that value_type is a synonym for the type pair<const K, V>, where K is the key type and V is the type of the associated value. The argument to insert constructs a new object of the appropriate pair type to insert into the map
By using insert, we can avoid the extraneous initialization of the value that happens when we insert a new map element as a side-effect of using a subscript

Testing the Return from insert
1. However, the version of insert that takes a single keyvalue pair does return a value. That value is a pair that contains an iterator that refers to the element in the map with the corresponding key, and a bool that indicates whether the element was inserted
Unwinding the Syntax

10.3.6. Finding and Retrieving a map Element
10.3.7. Erasing Elements from a map
10.3.8. Iterating across a map
10.3.9. A Word Transformation Map

Section 10.4 The set Type

1. In contrast, a set is simply a collection of keys

2. A set is most useful when we simply want to know whether a value is present

3. With two exceptions, set supports the same operations as map

o All the common container operations listed in Section 10.2 (p. 358).

o The constructors described in Table 10.3 (p. 360).

o The insert operations described in Table 10.5 (p. 365).

o The count and find operations described in Table 10.6 (p. 367).

o The erase operations described in Table 10.7 (p. 369).

4. The exceptions are that set does not provide a subscript operator and does not define mapped_type. In a set, the value_type is not a pair; instead it and key_type are the same type. They are each the type of the elements stored in the set

5. As with map, the keys of a set must be unique and may not be changed

6. 10.4.1. Defining and Using sets

1. To use a set, we must include the set header. The operations on sets are essentially identical to those on maps

2. Adding Elements to a set

3. Fetching an Element from a set

1. There is no subscript operator on sets

2. To fetch an element from a set by its key, we use the find operation. If we just want to know whether the element is present, we could also use count, which returns the number of elements in the set with a given key

3. Just as we cannot change the key part of a map element, the keys in a set are also const

7. 10.4.2. Building a Word-Exclusion Set

Section 10.5 The multimap and multiset Types

1. The types multiset and a multimap allow multiple instances of a key.
2. The multimap and multiset types are defined in the same headers as the corresponding single-element versions: the map and set headers, respectively
3. The operations supported by multimap and multiset are the same as those on map and set, respectively, with one exception: multimap does not support subscripting
4. We cannot subscript a multimap because there may be more than one value associated with a given key
5. The insert operations described in Table 10.5 (p. 365) and the erase operations described in Table 10.7 (p. 369) are used to add and remove elements of a multimap or multiset
6. Because keys need not be unique, insert always adds an element
7. The version of erase that takes a key removes all elements with that key. It returns a count of how many elements were removed
8. The versions that take an iterator or an iterator pair remove only the indicated element(s).
10.5.1. Adding and Removing Elements
- We noted that maps and sets store their elements in order
- The multimap and multiset types do so as well. As a result, when a multimap or multiset has multiple instances of a given key, those instances will be adjacent elements within the container
- We are guaranteed that iterating across a multimap or multiset returns all the elements with a given key in sequence
10.5.2. Finding Elements in a multimap or multiset
- It turns out that there are three strategies we might use to find and print all the books by a given author. Each of these strategies relies on the fact that we know that all the entries for a given author will be adjacent within the multimap
Using find and count

A Different, Iterator-Oriented Solution

They can be used with (plain) maps or sets but are most often used with multimaps or multisets. Each of these operations takes a key and returns an iterator
Calling lower_bound and upper_bound on the same key yields an iterator range (Section 9.2.1, p. 314) that denotes all the elements with that key. If the key is in the container, the iterators will differ: the one returned from lower_bound will refer to the first instance of the key, whereas upper_bound will return an iterator referring just after the last instance. If the element is not in the multimap, then lower_bound and upper_bound will return equal iterators; both will refer to the point at which the key could be inserted without disrupting the order
The iterator returned from lower_bound may or may not refer to an element with the given key. If the key is not in the container, then lower_bound refers to the first point at which this key could be inserted while preserving the element order within the container
These operations say nothing about whether the key is present. The important point is that the return values act like an iterator range

If there is no element for this key, then lower_bound and upper_bound will be equal: They will both refer to the same element or they will both point one past the end of the multimap. They both will refer to the point at which this key could be inserted while maintaining the container order

Table 10.8. Associative Container Operations Returning Iterators
`m.lower_bound(k)`	Returns an iterator to the first element with key not less than `k`.
`m.upper_bound(k)`	Returns an iterator to the first element with key greater than `k`.
`m.equal_range(k)`	Returns a `pair` of iterators. The `first` member is equivalent to `m.lower_bound(k)` and `second` is equivalent to `m.upper_bound(k)`.

The equal_range Function
- Instead of calling upper_bound and lower_bound, we can call equal_range. This function returns a pair of iterators. If the value is present, then the first iterator refers to the first instance of the key and the second iterator refers one past the last instance of the key. If no matching element is found, then both the first and second iterator refer to the position where this key could be inserted

Section 10.6 Using Containers: Text-Query Program

To conclude this chapter, we'll implement a simple text-query program
10.6.1. Design of the Query Program
1. A good way to start the design of a program is to list the program's operations. Knowing what operations we need to provide can then help us see what data structures we'll need and how we might implement those actions
  1. It must allow the user to indicate the name of a file to process. The program will store the contents of the file so that we can display the original line in which each word appears
  2. The program must break each line into words and remember all the lines in which each word appears. When it prints the line numbers, they should be presented in ascending order and contain no duplicates
  3. The result of querying for a particular word should be the line numbers on which that word appeared
  4. To print the text in which the word appeared, it must be possible to fetch the line from the input file corresponding to a given line number
10.6.2. TextQuery Class
1. Our class will have two data members: a vector to hold the input file and a map to associate each input word with the set of line numbers on which it appears
2. For the reasons described on page 80, this class definition uses fully qualified std:: names for all references to library entities
10.6.3. Using the TextQuery Class
10.6.4. Writing the Member Functions

C++ Primer, Fourth Edition Notes Chapter 18. Specialized Tools and Techniques

2011-01-17T22:40:00.005-08:00

Section 18.1 Optimizing Memory Allocation

Section 18.2 Run-Time Type Identification

Section 18.3 Pointer to Class Member

Section 18.4 Nested Classes

Section 18.5 Union: A Space-Saving Class

Section 18.6 Local Classes

Section 18.7 Inherently Nonportable Features

C++ Primer, Fourth Edition Notes Chapter 17. Tools for Large Programs

2011-01-17T22:40:00.003-08:00

Part V covers additional features that, although useful in the right context, are not needed by every C++ programmer. These features divide into two clusters: those that are useful for large-scale problems and those that are applicable to specialized problems rather than general ones.

Section 17.1 Exception Handling

Section 17.2 Namespaces

Section 17.3 Multiple and Virtual Inheritance

C++ Primer, Fourth Edition Notes Chapter 15. Object-Oriented Programming

2011-01-17T22:40:00.001-08:00

Writing our own object-oriented or generic types requires a fairly good understanding of C++. Fortunately, we can use OO and generic types without understanding the details of how to build them. In fact, the standard library uses the facilities we'll study in Chapters 15 and 16 extensively, and we've used the library types and algorithms without needing to know how they are implemented. Readers, therefore, should understand that Part IV covers advanced topics. Writing templates or object-oriented classes requires a good understanding of the basics of C++ and a good grasp of how to define more basic classes

Section 15.1 OOP: An Overview

Section 15.2 Defining Base and Derived Classes

Section 15.3 Conversions and Inheritance

Section 15.4 Constructors and Copy Control

Section 15.5 Class Scope under Inheritance

Section 15.6 Pure Virtual Functions

Section 15.7 Containers and Inheritance

Section 15.8 Handle Classes and Inheritance

Section 15.9 Text Queries Revisited

Reading Plan

2011-01-17T22:38:00.001-08:00

Reading plan

C++ primer

C++ - Data Structures And Algorithms With Object-oriented Design Patterns In C++3.Pratical Algorithms

Windows via C/C++, Fifth Edition

Practical.Algorithms.for.Programmers

Writing Secure Code

Programming.Pearls

Mastering Algorithms with C

Algorithms in a Nutshell

C++ Reserved or Non-graphic Characters

2011-01-17T21:55:00.001-08:00

Character	ASCII Representation	ASCII Value	Escape Sequence
Newline	NL (LF)	10	\n
Horizontal tab	HT	9	\t
Vertical tab	VT	11	\v
Backspace	BS	8	\b
Carriage return	CR	13	\r
Formfeed	FF	12	\f
Alert	BEL	7	\a
Backslash	\	92	\\
Question mark	?	63	\?
Single quotation mark	'	39	\'
Double quotation mark	"	34	\"
Octal number	ooo	--	\ooo
Hexadecimal number	hhh	--	\xhhh
Null character	NUL	0	\0

Pro.ASP.NET.4.in.CSharp.2010.4th-Introducing ASP.NET

2011-01-17T21:53:00.001-08:00

The Seven Pillars of ASP.NET

ASP.NET Is Integrated with the .NET Framework
ASP.NET Is Compiled, Not Interpreted
ASP.NET Is Multilanguage
ASP.NET Is Hosted by the Common Language Runtime
ASP.NET Is Object-Oriented
ASP.NET Supports all Browser
ASP.NET Is Easy to Deploy and Configure

The Evolution of ASP.NET

ASP.NET 1.0 and 1.1
ASP.NET 2.0
ASP.NET 3.5
LINQ
ASP.NET AJAX
ASP.NET 4
ASP.NET MVC
ASP.NET Dynamic Data
Silverlight

Visual Studio

Web Forms

Server Controls

ASP.NET Applications

State Management

Algorithms in a Nutshell-Note:Chapter 1: Algorithms Matter

2011-01-17T21:52:00.001-08:00

It’s the question that drives us, Neo. It’s the question that brought you here.You know the question, just as I did.

We intend this book to be used frequently by experienced programmers looking for appropriate solutions to their problems. Here you will find solutions to the problems you must overcome as a programmer every day. You will learn what decisions lead to an improved performance of key algorithms that are essential for the success of your software applications. You will find real code that can be adapted to your needs and solution methods that you can learn.

C++ Primer, Fourth Edition Notes Chapter 9 Exercise

2011-01-17T19:06:00.001-08:00

Exercise 9.1:

Explain the following initializations. Indicate if any are in error, and if so, why.

     int ia[7] = { 0, 1, 1, 2, 3, 5, 8 };
     string sa[6] = {
         "Fort Sumter", "Manassas", "Perryville",
         "Vicksburg", "Meridian", "Chancellorsville" };
     (a) vector<string> svec(sa, sa+6);
     (b) list<int> ilist( ia+4, ia+6);
     (c) vector<int> ivec(ia, ia+8);
     (d) list<string> slist(sa+6, sa);

Exercise 9.2:

Show an example of each of the four ways to create and initialize a vector. Explain what values each vector contains.

Exercise 9.3:

Explain the differences between the constructor that takes a container to copy and the constructor that takes two iterators.

Exercise 9.4:

Define a list that holds elements that are deques that hold ints.

Exercise 9.5:

Why can we not have containers that hold iostream objects?

Exercise 9.6:

Given a class type named Foo that does not define a default constructor but does define a constructor that takes int values, define a list of Foo that holds 10 elements.

Exercise 9.7:

What is wrong with the following program? How might you correct it?

     list<int> lst1;
     list<int>::iterator iter1 = lst1.begin(),
                         iter2 = lst1.end();
     while (iter1 < iter2) /* . . . */

Exercise 9.8:

Assuming vec_iter is bound to an element in a vector that holds strings, what does this statement do?

     if (vec_iter->empty()) /* . . . */

Exercise 9.9:

Write a loop to write the elements of a list in reverse order.

Exercise 9.10:

Which, if any, of the following iterator uses are in error?

     const vector< int > ivec(10);
     vector< string >    svec(10);
     list< int >         ilist(10);

     (a) vector<int>::iterator    it = ivec.begin();
     (b) list<int>::iterator      it = ilist.begin()+2;
     (c) vector<string>::iterator it = &svec[0];
     (d) for (vector<string>::iterator
                  it = svec.begin(); it != 0; ++it)
                     // ...

Exercise 9.11:

What are the constraints on the iterators that form iterator ranges?

Exercise 9.12:

Write a function that takes a pair of iterators and an int value. Look for that value in the range and return a bool indicating whether it was found.

Exercise 9.13:

Rewrite the program that finds a value to return an iterator that refers to the element. Be sure your function works correctly if the element does not exist.

Exercise 9.14:

Using iterators, write a program to read a sequence of strings from the standard input into a vector. Print the elements in the vector.

Exercise 9.15:

Rewrite the program from the previous exercise to use a list. List the changes you needed to change the container type.

Exercise 9.16:

What type should be used as the index into a vector of ints?

Exercise 9.17:

What type should be used to read the elments in a list of strings?

Exercise 9.18:

Write a program to copy elements from a list of ints into two deques. The list elements that are even should go into one deque and those that are odd into the second.

Exercise 9.19:

Assuming iv is a vector of ints, what is wrong with the following program? How might you correct the problem(s)?

     vector<int>::iterator mid = iv.begin() + iv.size()/2;
     while (vector<int>::iterator iter != mid)
         if (iter == some_val)
             iv.insert(iter, 2 * some_val);

Exercise 9.20:

Write a program to compare whether a vector<int> contains the same elements as a list<int>.

Exercise 9.21:

Assuming c1 and c2 are containers, what constraints does the following usage place on the element types in c1 and c2?

     if (c1 < c2)

What, if any, constraints are there on c1 and c2?

Exercise 9.22:

Given that vec holds 25 elements, what does vec.resize(100) do? What if we next wrote vec.resize(10)?

Exercise 9.23:

What, if any, restrictions does using resize with a single size argument place on the element types?

Exercise 9.24:
Write a program that fetches the first element in a vector. Do so using at, the subscript operator, front, and begin. Test the program on an empty vector.

Exercise 9.25:

What happens in the program that erased a range of elements if val1 is equal to val2. What happens if either val1 or val2 or both are not present.

Exercise 9.26:

Using the following definition of ia, copy ia into a vector and into a list. Use the single iterator form of erase to remove the elements with odd values from your list and the even values from your vector.

     int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };

Exercise 9.27:

Write a program to process a list of strings. Look for a particular value and, if found, remove it. Repeat the program using a deque.

Exercise 9.28:

Write a program to assign the elements from a list of char* pointers to C-style character strings to a vector of strings.

Exercise 9.29:
Explain the difference between a vector's capacity and its size. Why is it necessary to support the notion of capacity in a container that stores elements contiguously but not, for example, in a list?
Exercise 9.30:
Write a program to explore the allocation stragegy followed by the library you use for vector objects.
Exercise 9.31:
Can a container have a capacity less than its size? Is a capacity equal to its size desirable? Initially? After an element is inserted? Why or why not?
Exercise 9.32:
Explain what the following program does:
     vector<string> svec;
     svec.reserve(1024);
     string text_word;
     while (cin >> text_word)
             svec.push_back(text_word);
     svec.resize(svec.size()+svec.size()/2);
If the program reads 256 words, what is its likely capacity after it is resized? What if it reads 512? 1,000? 1,048?

Exercise 9.33:

Which is the most appropriatea vector, a deque, or a listfor the following program tasks? Explain the rationale for your choice. If there is no reason to prefer one or another container explain why not?

Read an unknown number of words from a file for the purpose of generating English language sentences.
Read a fixed number of words, inserting them in the container alphabetically as they are entered. We'll see in the next chapter that associative containers are better suited to this problem.
Read an unknown number of words. Always insert new words at the back. Remove the next value from the front.
Read an unknown number of integers from a file. Sort the numbers and then print them to standard output.

Exercise 9.34:

Use iterators to change the characters in a string to uppercase.

Exercise 9.35:

Use iterators to find and to erase each capital letter from a string.

Exercise 9.36:

Write a program that initializes a string from a vector<char>.

Exercise 9.37:

Given that you want to read a character at a time into a string, and you know that the data you need to read is at least 100 characters long, how might you improve the performance of your program?

Exercise 9.38:

Write a program that, given the string

     "ab2c3d7R4E6"

finds each numeric character and then each alphabetic character. Write two versions of the program. The first should use find_first_of, and the second find_first_not_of.

Exercise 9.39:

Write a program that, given the strings

     string line1 = "We were her pride of 10 she named us:";
     string line2 = "Benjamin, Phoenix, the Prodigal"
     string line3 = "and perspicacious pacific Suzanne";

     string sentence = line1 + ' ' + line2 + ' ' + line3;

counts the number of words in sentence and identifies the largest and smallest words. If several words have the largest or smallest length, report all of them.

Exercise 9.40:

Write a program that accepts the following two strings:

     string q1("When lilacs last in the dooryard bloom'd");
     string q2("The child is father of the man");

Using the assign and append operations, create the string

     string sentence("The child is in the dooryard");

Exercise 9.41:

Write a program that, given the strings

     string generic1("Dear Ms Daisy:");
     string generic2("MrsMsMissPeople");

implements the function

     string greet(string form, string lastname, string title,
                  string::size_type pos, int length);

using the replace operations, where lastname replaces Daisy and pos indexes into generic2 of length characters replacing Ms. For example, the following

     string lastName("AnnaP");
     string salute = greet(generic1, lastName, generic2, 5, 4);

returns the string

     Dear Miss AnnaP:

Exercise 9.42:

Write a program to read a series of words into a stack.

Exercise 9.43:

Use a stack to process parenthesized expressions. When you see an open parenthesis, note that it was seen. When you see a close parenthesis after an open parenthesis, pop elements down to and including the open parenthesis off the stack. push a value onto the stack to indicate that a parenthesized expression was replaced

C++ Primer, Fourth Edition Notes Chapter 9 Sequential Containers

2011-01-17T18:16:00.001-08:00

We've said that C++ is about efficient programming with abstractions. The Standard Library is a good example: The library defines a number of container classes and a family of generic algorithms that let us write programs that are succinct, abstract, and efficient. The library worries about bookkeeping detailsin particular, taking care of memory managementso that our programs can worry about the actual problems we need to solve

The library is designed so that the container types provide a common interface: If two containers offer a similar operation, then that operation will be defined identically for both containers

Because the container operations and algorithms are defined consistently, learning the library becomes easier: Once you understand how an operation works, you can apply that same operation to other containers. More importantly, this commonality of interface leads to more flexible programs. It is often possible to take a program written to use one container type and change it to use a different container without having to rewrite code. As we'll see, the containers offer different performance tradeoffs, and the ability to change container types can be valuable when fine-tuning the performance of a system

Each container type offers a different set of time and functionality tradeoffs.

The library defines three kinds of sequential containers: vector, list, and deque (short for "double-ended queue" and pronounced "deck"). These types differ in how elements are accessed and the relative run-time cost of adding or removing element. The library also provides three container adaptors. Effectively, an adaptor adapts an underlying container type by defining a new interface in terms of the operations provided by the original type. The sequential container adaptors are stack, queue, and priority_queue.

Table 9.1. Sequential Container Types
Sequential Containers
`vector`	Supports fast random access
`list`	Supports fast insertion/deletion
`deque`	Double-ended queue
Sequential Container Adaptors
`stack`	Last in/First out stack
`queue`	First in/First out queue
`priority_queue`	Priority-managed queue

Section 9.1 Defining a Sequential Container

For reasons that shall become clear shortly, the most commonly used container constructor is the default constructor. In most programs, using the default constructor gives the best run-time performance and makes using the container easier.

9.1.1. Initializing Container Elements

Table 9.2. Container Constructors
`C<T> c;`	Create an empty container named `c`. `C` is a container name, such as `vector`, and `T` is the element type, such as `int` or `string`. Valid for all containers.
`C c(c2);`	Create `c` as a copy of container `c2`; `c` and `c2` must be the same container type and hold values of the same type. Valid for all containers.
`C c(b, e);`	Create `c` with a copy of the elements from the range denoted by iterators `b` and `e`. Valid for all containers.
`C c(n, t);`	Create `c` with `n` elements, each with value `t`, which must be a value of the element type of `C` or a type convertible to that type. Sequential containers only.
`C c(n);`	Create `c` with `n` value-initialized (Section 3.3.1, p. 92) elements. Sequential containers only.

Intializing a Container as a Copy of Another Container
1. When we initialize a sequential container using any constructor other than the default constructor, we must indicate how many elements the container will have. We must also supply initial values for those elements
2. When we copy one container into another, the types must match exactly: The container type and element type must be the same
Initializing as a Copy of a Range of Elements
1. Although we cannot copy the elements from one kind of container to another directly, we can do so indirectly by passing a pair of iterators (Section 3.4, p. 95). When we use iterators, there is no requirement that the container types be identical. The element types in the containers can differ as long as they are compatible. It must be possible to convert the element we copy into the type held by the container we are constructing
2. The iterators denote a range of elements that we want to copy. These elements are used to initialize the elements of the new container. The iterators mark the first and one past the last element to be copied. We can use this form of initialization to copy a container that we could not copy directly. More importantly, we can use it to copy only a subsequence of the other container
3. Recall that pointers are iterators, so it should not be surprising that we can initialize a container from a pair of pointers into a built-in array
Allocating and Initializing a Specified Number of Elements
2. The constructors that take a size are valid only for sequential containers; they are not supported for the associative containers

9.1.2. Constraints on Types that a Container Can Hold
1. Most types meet these minimal element type requirements. All of the built-in or compound types, with the exception of references, can be used as the element type
2. References do not support assignment in its ordinary meaning, so we cannot have containers of references
3. With the exception of the IO library types (and the auto_ptr type, which we cover in Section 17.1.9 (p. 702)), all the library types are valid container element types
4. The IO library types do not support copy or assignment. Therefore, we cannot have a container that holds objects of the IO types
5. Container Operations May Impose Additional Requirements
  1. In addition, some container operations impose additional requirements on the element type. If the element type doesn't support the additional requirement, then we cannot perform that operation: We can define a container of that type but may not use that particular operation
6. Containers of Containers
  1. Note the spacing used when specifying a container element type as a container
  2. We must separate the two closing > symbols with a space to indicate that these two characters represent two symbols. Without the space, >> is treated as a single symbol, the right shift operator, and results in a compile-time error

// EXE-9.1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <vector>
#include <list>
#include <deque>
#include <string>
#include <iostream>

using namespace std;
class Foo
{
public:
	Foo( int size)
	{
		this->size = size;
	}
	Foo():size(0){};
	void Foo::PrintOut();
protected:
private:
	int size;
};
int main(int argc, _TCHAR* argv[])
{
	vector<string>    svec;       // empty vector that can hold strings
	list<int>         ilist;      // empty list that can hold ints
	//deque<Sales_item> items;      // empty deque that holds Sales_items


	if("Intializing a Container as a Copy of Another Container")
	{
		vector<int> ivec;
		vector<int> ivec2(ivec);   // ok: ivec is vector<int>
		//list<int>   ilist(ivec);   // error: ivec is not list<int>
		//vector<double> dvec(ivec); // error: ivec holds int not double
		
	}
	if("Initializing as a Copy of a Range of Elements")
	{
		vector<string> svec(10,"*");
		vector<string>::iterator it = svec.begin();
		while(it != svec.end())
		{
			cout << *it++ << endl;
		}
		// initialize slist with copy of each element of svec
		list<string> slist(svec.begin(), svec.end());

		cout << "The list size is:" << slist.size() << endl;
		// find midpoint in the vector
		vector<string>::iterator mid = svec.begin() + svec.size()/2;

		// initialize front with first half of svec: The elements up to but not including *mid
		deque<string> front(svec.begin(), mid);
		cout << "The deque is copied from begin to mid and its size is:" << front.size() << endl;
		// initialize back with second half of svec: The elements *mid through end of svec
		deque<string> back(mid, svec.end());
		cout << "The deque is copied from mid to end and its size is:" << back.size() << endl;

		char *words[] = {"stately", "plump", "buck", "mulligan","a","ab"};

		// calculate how many elements in words
		// to get the size of the string array
		size_t words_size = sizeof(words)/sizeof(char *);

		// use entire array to initialize words2
		list<string> words2(words, words + words_size);
		list<string>::iterator itL = words2.begin();
		while( itL != words2.end())
		{
			cout << *itL++ << endl;
		}

	}

	if("Allocating and Initializing a Specified Number of Elements")
	{
		const list<int>::size_type list_size = 64;
		list<string> slist(list_size, "eh?"); // 64 strings, each is eh?
		list<string>::iterator it_slist = slist.begin();
		while(it_slist != slist.end())
			cout << *it_slist ++ ;
		cout << endl;
		
		list<int> ilist(list_size); // 64 elements, each initialized to 0
		list<int>::iterator it_ilist = ilist.begin();
		while( it_ilist != ilist.end())
			cout << *it_ilist++ ;
		cout << endl;

		// svec has as many elements as the return value from get_word_count
		extern unsigned get_word_count(const string &file_name);
		vector<string> svec(get_word_count("Chimera"));
		vector<string>::iterator it_svec = svec.begin();
		while( it_svec != svec.end())
			cout << *it_svec ++ ;
		cout << endl;

	}
	if("Container Operations May Impose Additional Requirements")
	{
		vector<Foo> empty;     // ok: no need for element default constructor
		vector<Foo> bad(10);   // it's ok to call now with the default constructor // error: no default constructor for Foo
		vector<Foo> ok(10, 1); // ok: each element initialized to 1
		vector<Foo>::iterator it = ok.begin();
		while( it != ok.end())
		{
			it->PrintOut();
			++it;
		}
	}
	if("Containers of Containers")
	{
		// note spacing: use ">>" not ">>" when specifying a container element type
		vector< vector<string> > lines0; // vector of vectors
		vector< vector<string> > lines1; // ok: space required between close >
		// actually not comple error in VSTS 2010
		vector<vector<string>> lines2; // error: >> treated as shift operator

	}

	int i;
	cin >> i;

	return 0;
}

unsigned get_word_count(const string &file_name)
{
	return file_name.size();
}
inline void Foo::PrintOut()
{
	cout << "The fool's size is:" << this->size << endl;
}

Section 9.2 Iterators and Iterator Ranges

Table 9.3. Common Iterator Operations
`*iter`	Return a reference to the element referred to by the iterator `iter`.
`iter->mem`	Dereference `iter` and fetch the member named `mem` from the underlying element. Equivalent to `(*iter).mem`.
`++iter iter++`	Increment `iter` to refer to the next element in the container.
`--iter iter--`	Decrement `iter` to refer to the previous element in the container.
`iter1 == iter2 iter1 != iter2`	Compare two iterators for equality (inequality). Two iterators are equal if they refer to the same element of the same container or if they are the off-the-end iterator (Section 3.4, p. 97) for the same container.

Iterators on vector and deque Support Additional Operations

There are two important sets of operations that only vector and deque support: iterator arithmetic (Section 3.4.1, p. 100) and the use of the relational operators (in addition to == and !=) to compare two iterators

Table 9.4. Operations Supported by `vector` and `deque` Iterators
`iter + n iter - n`	Adding (subtracting) an integral value `n` to (from) an iterator yields an iterator that many elements forward (backward) within the container. The resulting iterator must refer to an element in the container or one past the end of the container.
`iter1 += iter2 iter1 -= iter2`	Compound-assignment versions of iterator addition and subtraction. Assigns the value of adding or subtracting `iter1` and `iter2` into `iter1`.
`iter1 - iter2`	Subtracting two iterators yields the number that when added to the right-hand iterator yields the left-hand iterator. The iterators must refer to elements in the same container or one past the end of the container. Supported only for `vector` and `deque`.
`>, >=, <, <=`	Relational operators on iterators. One iterator is less than another if it refers to an element whose position in the container is ahead of the one referred to by the other iterator. The iterators must refer to elements in the same container or one past the end of the container. Supported only for `vector` and `deque`.

The reason that only vector and deque support the relational operators is that only vector and deque offer fast, random access to their elements

9.2.1. Iterator Ranges

The concept of an iterator range is fundamental to the standard library.
An iterator range is denoted by a pair of iterators that refer to two elements, or to one past the last element, in the same container. These two iterators, often referred to as first and last, or beg and end, mark a range of elements from the container.
The second iterator never refers to the last element of the range. Instead, it refers to a point one past the last element. The elements in the range include the element referred to by first and every element from first tHRough the element just before last. If the iterators are equal, then the range is empty

This element range is called a left-inclusive interval

Requirements on Iterators Forming an Iterator Range

Two iterators, first and last, form an iterator range, if

They refer to elements of, or one-past-the-end of, the same container.
If the iterators are not equal, then it must be possible to reach last by repeatedly incrementing first. In other words, last must not precede first in the container.

The compiler cannot itself enforce these requirements. It does not know to which container an iterator is bound, nor does it know how many elements are in a container. Failing to meet these requirements results in undefined run-time behavior
Programming Implications of Using Left-Inclusive Ranges

9.2.2. Some Container Operations Invalidate Iterators
1. In the sections that follow, we'll see that some container operations change the internal state of a container or cause the elements in the container to be moved. Such operations invalidate all iterators that refer to the elements that are moved and may invalidate other iterators as well. Using an invalidated iterator is undefined, and likely to lead to the same kinds of problems as using a dangling pointer
2. When writing programs that use iterators, we must be aware of which operations can invalidate the iterators. It is a serious run-time error to use an iterator that has been invalidated
3. There is no way to examine an iterator to determine whether it has been invalidated. There is no test we can perform to detect that it has gone bad. Any use of an invalidated iterator is likely to yield a run-time error, but there is no guarantee that the program will crash or otherwise make it easy to detect the problem
4. When using iterators, it is usually possible to write the program so that the range of code over which an iterator must stay valid is relatively short. It is important to examine each statement in this range to determine whether elements are added or removed and adjust iterator values accordingly

Section 9.3 Sequence Container Operations

Each sequential container defines a set of useful typedefs and supports operations that let us

Add elements to the container
Delete elements from the container
Determine the size of the container
Fetch the first and last elements from the container, if any

9.3.1. Container Typedefs

Table 9.5. Container-Defined Typedefs
`size_type`	Unsigned integral type large enough to hold size of largest possible container of this container type
`iterator`	Type of the iterator for this container type
`const_iterator`	Type of the iterator that can read but not write the elements
`reverse_iterator`	Iterator that addresses elements in reverse order
`const_reverse_iterator`	Reverse iterator that can read but not write the elements
`difference_type`	Signed integral type large enough to hold the difference, which might be negative, between two iterators
`value_type`	Element type
`reference`	Element's lvalue type; synonym for `value_type&`
`const_reference`	Element's const lvalue type; same as `const value_type&`

9.3.2. begin and end Members

The begin and end operations yield iterators that refer to the first and one past the last element in the container.

Table 9.6. Container `begin` and `end` Operations
`c.begin()`	Yields an iterator referring to the first element in `c`
`c.end()`	Yields an iterator referring to the one past the last element in `c`
`c.rbegin()`	Yields a reverse iterator referring to the last element in `c`
`c.rend()`	Yields a reverse iterator referring one past (i.e., before) the first element in `c`

9.3.3. Adding Elements to a Sequential Container

Every sequential container supports push_back, which appends an element to the back of the container
The call to push_back creates a new element at the end of container, increasing the size of container by one. The value of that element is a copy of text_word. The type of container can be any of list, vector, or deque

In addition to push_back, the list and deque containers support an analogous operation named push_front. This operation inserts a new element at the front of the container

Key Concept: Container Elements Are Copies

When we add an element to a container, we do so by copying the element value into the container. Similarly, when we initialize a container by providing a range of elements, the new container contains copies of the original range of elements. There is no relationship between the element in the container and the value from which it was copied. Subsequent changes to the element in the container have no effect on the value that was copied, and vice versa.

Table 9.7. Operations that Add Elements to a Sequential Container
`c.push_back(t)`	Adds element with value `t` to the end of `c`. Returns `void`.
`c.push_front(t)`	Adds element with value `t` to front of `c`. Returns `void`. Valid only for `list` or `deque`.
`c.insert(p,t)`	Inserts element with value `t` before the element referred to by iterator `p`. Returns an iterator referring to the element that was added.
`c.insert(p,n,t)`	Inserts `n` elements with value `t` before the element referred to by iterator `p`. Returns `void`.
`c.insert(p,b,e)`	Inserts elements in the range denoted by iterators `b` and `e` before the element referred to by iterator `p`. Returns `void`.

Adding Elements at a Specified Point in the Container
Inserting a Range of Elements
Inserting Elements Can Invalidate Iterators
1. As we'll see in Section 9.4 (p. 330), adding elements to a vector can cause the entire container to be relocated. If the container is relocated, then all iterators into the container are invalidated. Even if the vector does not have to be relocated, any iterator to an element after the one inserted is invalidated
2. Iterators may be invalidated after doing any insert or push operation on a vector or deque. When writing loops that insert elements into a vector or a deque, the program must ensure that the iterator is refreshed on each trip through the loop
Avoid Storing the Iterator Returned from end
1. When we add elements to a vector or deque, some or all of the iterators may be invalidated. It is safest to assume that all iterators are invalid. This advice is particularly true for the iterator returned by end. That iterator is always invalidated by any insertion anywhere in the container
2. Don't cache the iterator returned from end. Inserting or deleting elements in a deque or vector will invalidate the cached iterator

9.3.4. Relational Operators
1. The containers must be the same kind of container and must hold elements of the same type
2. Comparing two containers is based on a pairwise comparison of the elements of the containers. The comparison uses the same relational operator as defined by the element type: Comparing two containers using != uses the != operator for the element type
  These operators work similarly to the string relationals (Section 3.2.3, p. 85):
  - If both containers are the same size and all the elements are equal, then the two containers are equal; otherwise, they are unequal.
  - If the containers have different sizes but every element of the shorter one is equal to the corresponding element of the longer one, then the shorter one is considered to be less than the other.
  - If neither container is an initial subsequence of the other, then the comparison depends on comparing the first unequal elements
3. Relational Operators Use Their Element's Relational Operator
  1. We can compare two containers only if the same relational operator defined for the element types

9.3.5. Container Size Operations

Table 9.8. Sequential Container Size Operations
`c.size()`	Returns the number of elements in `c`. Return type is `c::size_type`.
`c.max_size()`	Returns maximum number of elements `c` can contain. Return type is `c::size_type`.
`c.empty()`	Returns a `bool` that indicates whether `size` is 0 or not.
`c.resize(n)`	Resize `c` so that it has `n` elements. If `N < c.size()`, the excess elements are discarded. If new elements must be added, they are value initialized.
`c.resize(n,t)`	Resize `c` to have `n` elements. Any elements added have value `t`.

resize can invalidate iterators. A resize operation on a vector or deque potentially invalidates all iterators
For any container type, if resize shrinks the container, then any iterator to an element that is deleted is invalidated

9.3.6. Accessing Elements

If a container is not empty, then the front and back members return references bound to the first or last elements in the container

Table 9.9. Operations to Access Elements in a Sequential Container
`c.back()`	Returns a reference to the last element in `c`. Undefined if `c` is empty.
`c.front()`	Returns a reference to the first element in `c`. Undefined if `c` is empty.
`c[n]`	Returns a reference to the element indexed by `n`. Undefined if `n <0` or `n >= c.size()`. Valid only for `vector` and `deque`.
`c.at(n)`	Returns a reference to the element indexed by `n`. If index is out of range, throws `out_of_range` exception. Valid only for `vector` and `deque`.

This program uses two different approaches to fetch a reference to the first and last elements in ilist. The direct approach is to call front or back. Indirectly, we can obtain a reference to the same element by dereferencing the iterator returned by begin or the element one before the iterator returned by end. Two things are noteworthy in this program: The end iterator refers "one past the end" of the container so to fetch the last element we must first decrement that iterator. The other important point is that before calling front or back or dereferencing the iterators from begin or end we check that ilist isn't empty. If the list were empty all of the operations in the if would be undefined
```
            // check that there are elements before dereferencing an iterator
		// or calling front or back
		list<int> ilist;
		if (!ilist.empty()) {
			// val and val2 refer to the same element
			list<int>::reference val = *ilist.begin();
			list<int>::reference val2 = ilist.front();

			// last and last2 refer to the same element
			list<int>::reference last = *--ilist.end();
			list<int>::reference last2 = ilist.back(); 
		}
```
When we introduced subscripting in Section 3.3.2 (p. 94), we noted that the programmer must ensure that an element exists at the indicated subscript location. The subscript operator itself does not check. The same caution applies to using the front or back operations. If the container is empty, these operations yield an undefined result
Using a subscript that is out-of-range or calling front or back on an empty container are serious programming errors
An alternative to subscripting is to use the at member. This function acts like the subscript operation but if the index is invalid, at throws an out_of_range exception

9.3.7. Erasing Elements

specific push_front and push_back operations to add elements only at the front or back. Similarly, there is a general erase and specific pop_front and pop_back operations to remove elements

Removing the First or Last Element

The pop_front and pop_back functions remove the first and last elements in the container. There is no pop_front operation for vectors.These operations remove the indicated element and return void

The pop_front and pop_back return void; they do not return the value of the element popped. To examine that value, it is necessary to call front or back prior to popping the element

Table 9.10. Operations to Remove Elements from a Sequential Container
`c.erase(p)`	Removes element referred to by the iterator `p`. Returns an iterator referring to the element after the one deleted, or an off-the-end iterator if `p` referred to the last element. Undefined if `p` is an off-the-end iterator.
`c.erase(b,e)`	Removes the range of elements denoted by the iterators `b` and `e`. Returns an iterator referring after the last one in the range that was deleted, or an off-the-end iterator if `e` is itself an off-the-end iterator.
`c.clear()`	Removes all the elements in `c`. Returns `void`.
`c.pop_back()`	Removes the last element in `c`. Returns `void`. Undefined if `c` is empty.
`c.pop_front()`	Removes the first element in `c`. Returns `void`. Undefined if `c` is empty. Valid only for `list` or `deque`.

Removing an Element From within the Container
1. The more general way to remove an element, or range of elements, is through erase.
2. As usual, the erase operations don't check their argument(s). It is up to the programmer to ensure that the iterator or iterator range is valid
3. The easiest way to find a given element is to use the library find algorithm. We'll see more about find in Section 11.1 (p. 392). To use find or any other generic algorithm, we must include the algorithm header. The find function takes a pair of iterators that denote a range in which to look, and a value to look for within that range. find returns an iterator referring to the first element with that value or the off-the-end iterator
4. Note that we check that the iterator is not the end iterator before erasing the element. When we ask erase to erase a single element, the element must existthe behavior of erase is undefined if we ask it to erase an off-the-end iterator
Removing All the Elements in a Container
1. To delete all the elements in a container, we could either call clear or pass the iterators from begin and end to erase
2. The erase, pop_front, and pop_back functions invalidate any iterators that refer to the removed elements. For vectors, iterators to elements after the erasure point are also invalidated. For deque, if the erase does not include either the first or last element, all iterators into the deque are invalidated

9.3.8. Assignment and swap

The assignment-related operators act on the entire container. Except for swap, they can be expressed in terms of erase and insert operations. The assignment operator erases the entire range of elements in the left-hand container and then inserts the elements of the right-hand container object into the left-hand container
Assignment and the assign operations invalidate all iterators into the left-hand container. swap does not invalidate iterators. After swap, iterators continue to refer to the same elements, although those elements are now in a different container

Using assign

The assign operation deletes all the elements in the container and then inserts new elements as specified by the arguments. Like the constructor that copies elements from a container, the assignment operator (=) can be used to assign one container to another only if the container and element type are the same. If we want to assign elements of a different but compatible element type and/or from a different container type, then we must use the assign operation.

Table 9.11. Sequential Container Assignment Operations
`c1 = c2`	Deletes elements in `c1` and copies elements from `c2` into `c1`. `c1` and `c2` must be the same type.
`c1.swap(c2)`	Swaps contents: After the call `c1` has elements that were in `c2`, and `c2` has elements that were in `c1`. `c1` and `c2` must be the same type. Execution time usually much faster than copying elements from `c2` to `c1`.
`c.assign(b,e)`	Replaces the elements in `c` by those in the range denoted by iterators `b` and `e`. The iterators `b` and `e` must not refer to elements in `c`.
`c.assign(n,t)`	Replaces the elements in `c` by `n` elements with value `t`.

Because the original elements are deleted, the iterators passed to assign must not refer to elements in the container on which assign is called
The assign operator that takes an iterator pair lets us assign elements of one container type to another

Using swap to Avoid the Cost of Deleting Elements
1. The swap operation swaps the values of its two operands. The types of the containers must match: The operands must be the same kind of container, and they must hold values of the same type. After the call to swap, the elements that had been in the right-hand operand are in the left, and vice versa
2. The important thing about swap is that it does not delete or insert any elements and is guaranteed to run in constant time. No elements are moved, and so iterators are not invalidated
3. The fact that elements are not moved means that iterators are not invalidated. They refer to the same elements as they did before the swap. However, after the swap, those elements are in a different container. For example, had iter referred to the string at position svec1[3] before the swap it will refer to the element at position svec2[3] after the swap

// EXE-9.3.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <vector>
#include <string>
#include <iostream>
#include <list>
#include <deque>
#include <exception>
#include <cassert>
#include <algorithm>

using namespace std;

void PrintOut(list<string> & l);
void clearstream(istream &in);
void PrintOut(vector<string> &svect);
void PrintOut(list<int> & slst);
void process(const list<int>::reference re);
void PrintOut(vector<int> & ivect);

int main(int argc, _TCHAR* argv[])
{

	if("9.3.1. Container Typedefs")
	{
		// iter is the iterator type defined by list<string>
		list<string>::iterator iter;

		// cnt is the difference_type type defined by vector<int>
		vector<int>::difference_type cnt;

	}

	if("9.3.3. Adding Elements to a Sequential Container")
	{
		// read from standard input putting each word onto the end of container
		deque<string> container;
		string text_word;
		/*while (cin >> text_word)
		container.push_back(text_word);*/

		clearstream(cin);

		list<int> ilist;
		// add elements at the end of ilist
		for (size_t ix = 0; ix != 4; ++ix)
			ilist.push_back(ix);

		// add elements to the start of ilist
		for (size_t ix = 0; ix != 4; ++ix)
			ilist.push_front(ix);


		if("Adding Elements at a Specified Point in the Container")
		{
			vector<string> svec;
			list<string> slist;
			string spouse("Beth");

			// equivalent to calling slist.push_front (spouse);
			slist.insert(slist.begin(), spouse);

			// no push_front on vector but we can insert before begin()
			// warning: inserting anywhere but at the end of a vector is an expensive operation
			svec.insert(svec.begin(), spouse);

			list<string> lst;
			list<string>::iterator iter = lst.begin();
			string word;
			/*while (cin >> text_word)
			container.push_back(text_word);*/

			while (cin >> word)
			{
				iter = lst.insert(iter, word); // same as calling push_front
			}
			clearstream(cin);

			PrintOut(lst);
		}

		if("Inserting a Range of Elements")
		{
			vector<string> svec;
			list<string> slist;

			svec.insert(svec.end(), 10, "Anna");

			PrintOut(svec);

			string sarray[4] = {"quasi", "simba", "frollo", "scar"};
			// insert all the elements in sarray at end of slist
			slist.insert(slist.end(), sarray, sarray+4);
			PrintOut(slist);

			list<string>::iterator slist_iter = slist.begin();
			// insert last two elements of sarray before slist_iter
			slist.insert(slist_iter, sarray+2, sarray+4);
			PrintOut(slist);
		}

		if("Avoid Storing the Iterator Returned from end")
		{
			vector<int> v(1,0);

			vector<int>::iterator first = v.begin(), last = v.end(); // cache end iterator
			// diaster: behavior of this loop is undefined
			//while (first != last) {
			//	// do some processing
			//	// insert new value and reassign first, which otherwise would be invalid
			//	first = v.insert(first, 42);
			//	++first;  // advance first just past the element we added
			//}

			// safer: recalculate end on each trip whenever the loop adds/erases elements
			int k(0);
			while (first != v.end() && k != 42) {
				// do some processing
				first = v.insert(first, ++k); // insert new value
				++first; // advance first just past the element we added
			}
		}

	}

	if("9.3.4. Relational Operators")
	{
		//ivec1: 1 3 5 7 9 12
		int ivec1_array[] = {1,3, 5, 7 ,9 ,12};
		vector<int> ivec1(ivec1_array,ivec1_array + sizeof(ivec1_array)/ sizeof(int));
		//ivec2: 0 2 4 6 8 10 12
		int ivec2_array[] = {0,2,4,6,8,10,12};
		vector<int> ivec2(ivec2_array, ivec2_array + sizeof(ivec2_array)/sizeof(int));
		//ivec3: 1 3 9
		int ivec3_array[] = {1,3,9};
		vector<int> ivec3(ivec3_array,ivec3_array + sizeof(ivec3_array)/sizeof(int));
		//ivec4: 1 3 5 7
		int ivec4_array[] = {1,3,5,7};
		vector<int> ivec4(ivec4_array,ivec4_array + sizeof(ivec4_array)/sizeof(int));
		//ivec5: 1 3 5 7 9 12
		int ivec5_array[] = {1,3,5,7,9,12};
		vector<int> ivec5(ivec5_array,ivec5_array + sizeof(ivec5_array)/sizeof(int));

		// ivec1 and ivec2 differ at element[0]: ivec1 greater than ivec2
		cout << "ivec1 < ivec2 = " << (ivec1 < ivec2) << endl; // false
		cout << "ivec2 < ivec1 = " << (ivec2 < ivec1) << endl; // true

		// ivec1 and ivec3 differ at element[2]: ivec1 less than ivec3
		cout << "ivec1 < ivec3 = " << (ivec1 < ivec3 ) << endl; // true

		// all elements equal, but ivec4 has fewer elements, so ivec1 is greater than ivec4
		cout << "ivec1 < ivec4 = " << (ivec1 < ivec4 )<< endl; // false

		cout << "ivec1 == ivec5 = " << (ivec1 == ivec5 )<< endl; // true; each element equal and same number of elements
		cout << "ivec1 == ivec4 = " << (ivec1 == ivec4 )<< endl; // false; ivec4 has fewer elements than ivec1
		cout << "ivec1 != ivec4 = " << (ivec1 != ivec4 )<< endl; // true; ivec4 has fewer elements than ivec1

	}

	if("9.3.5. Container Size Operations")
	{
		list<int> ilist(10, 42);   // 10 ints: each has value 42
		PrintOut(ilist);
		ilist.resize(15);          // adds 5 elements of value 0 to back of ilist
		PrintOut(ilist);
		ilist.resize(25, -1);      // adds 10 elements of value -1 to back of ilist
		PrintOut(ilist);
		ilist.resize(5);           // erases 20 elements from the back of ilist
		PrintOut(ilist);
	}

	if("9.3.6. Accessing Elements")
	{
		// check that there are elements before dereferencing an iterator
		// or calling front or back
		list<int> ilist;
		int i(10);
		while( i != 0)
			ilist.push_front(--i);

		if (!ilist.empty()) {
			// val and val2 refer to the same element
			list<int>::reference val = *ilist.begin();
			list<int>::reference val2 = ilist.front();
			assert(val == val2);
			// last and last2 refer to the same element
			list<int>::reference last = *--ilist.end();
			list<int>::reference last2 = ilist.back(); 
			assert(last == last2);
		}
		// empty vector
		vector<string> svec;
		//try
		//{
		//	cout << svec[0];         // run-time error: There are no elements in svec!
		//}		
		//catch (runtime_error* e)
		//{
		//	cout << "the index access failed!" << endl;
		//	//goto atmethod;
		//}
		//catch (out_of_range* e)
		//{
		//	cout << "the at method access failed!" << endl;
		//}
		//catch (exception& e)
		//{
		//	cout << e.what()<< endl;
		//}
		//try
		//{
		//	cout << svec.at(0);      // throws out_of_range exception
		//}
		//catch (out_of_range* e)
		//{
		//	// do nothing and only print message
		//	cout << "the at method access failed!" << endl;
		//}
		//catch (exception& e)
		//{
		//	cout << e.what()<< endl;
		//}	

	}
	if("9.3.7. Erasing Elements")
	{
		list<int> ilist;
		int i(10);
		while( i!=0)
			ilist.push_back(--i);

		PrintOut(ilist);
		while (!ilist.empty()) {			
			process(ilist.front()); // do something with the current top of ilist
			ilist.pop_front();      // done; remove first element
			PrintOut(ilist);
		}

		if("Removing an Element From within the Container")
		{
			char * words[] = {"a","b","c","d","e","f","Quasimodo","g","Quasimodo","h"};
			list<string> slist(words, words + sizeof(words)/sizeof(char *));
			PrintOut(slist);

			string searchValue("Quasimodo");
			list<string>::iterator iter;
			while( iter = find(slist.begin(), slist.end(), searchValue),iter != slist.end())
			{
				slist.erase(iter);
				PrintOut(slist);
			}

		}

		if("Removing All the Elements in a Container")
		{
			char * words[] = {"a","b","c","d","e","f","Quasimodo","g","Quasimodo","h"};
			list<string> slist(words, words + sizeof(words)/sizeof(char *));
			PrintOut(slist);
			slist.clear(); // delete all the elements within the container
			PrintOut(slist);
			slist.erase(slist.begin(), slist.end()); // equivalent

		}

	}

	if("9.3.8. Assignment and swap")
	{
		vector<int> ivect1(10,1);
		PrintOut(ivect1);
		vector<int> ivect2(20,2);
		PrintOut(ivect2);

		ivect1 = ivect2; // replace contents of c1 with a copy of elements in ivect2
		// equivalent operation using erase and insert
		ivect1.erase(ivect1.begin(), ivect1.end()); // delete all elements in c1
		ivect1.insert(ivect1.begin(), ivect2.begin(), ivect2.end()); // insert ivect2

		if("Using assign")
		{
			list<string> slist1(10,"1");
			list<string> slist2(20,"2");
			PrintOut(slist1);
			PrintOut(slist2);
			// equivalent to slist1 = slist2
			slist1.assign(slist2.begin(), slist2.end());
			PrintOut(slist1);

			// equivalent to: slist1.clear();
			// followed by slist1.insert(slist1.begin(), 10, "Hiya!");
			slist1.assign(10, "Hiya!"); // 10 elements; each one is Hiya!
			PrintOut(slist1);

		}
		if("Using swap to Avoid the Cost of Deleting Elements")
		{
			vector<string> svec1(10,"1"); // vector with 10 elements
			vector<string> svec2(24,"2"); // vector with 24 elements
			vector<string>::iterator it_svec1 = svec1.begin() + 2;
			vector<string>::iterator it_svec2 = svec2.begin() + 3;
			assert(it_svec1 == svec1.begin()  + 2 );
			assert(it_svec2 == svec2.begin() + 3 );
			PrintOut(svec1);
			PrintOut(svec2);
			svec1.swap(svec2);
			assert(it_svec1 == svec2.begin()  + 2 );
			assert(it_svec2 == svec1.begin() + 3 );
			PrintOut(svec1);
			PrintOut(svec2);

		}

	}
	int i;
	cin >> i;
	return 0;
}
void process(const list<int>::reference re)
{
	// print out value
	cout << re << endl;
}
void clearstream(istream &in)
{
	//in.clear(istream::goodbit);
	//in.clear(istream::eofbit);
	in.clear();
	//in.seekg(0,ios_base::beg);
	in.seekg(0);
}
void PrintOut(list<string> & slst)
{
	string a(30,'*');
	cout << a << endl;
	cout << "list size:" << slst.size() << " element: ";

	list<string>::iterator it = slst.begin();
	while( it != slst.end())
		cout << *it++ << ", " ;

	cout << endl;
}
void PrintOut(vector<int> & ivect)
{
	string a(30,'*');
	cout << a << endl;
	cout << "vector size:" << ivect.size() << " element: ";

	vector<int>::iterator it = ivect.begin();
	while( it != ivect.end())
		cout << *it++ << ", " ;

	cout << endl;
}
void PrintOut(list<int> & ilst)
{
	string a(30,'*');
	cout << a << endl;
	cout << "list size:" << ilst.size() << " element: ";

	list<int>::iterator it = ilst.begin();
	while( it != ilst.end())
		cout << *it++ << ", " ;

	cout << endl;
}
void PrintOut(vector<string> &sivect)
{
	string a(30,'*');
	cout << a << endl;
	cout << "vector size:" << sivect.size() << " element: ";

	vector<string>::iterator it = sivect.begin();
	while( it != sivect.end())
		cout << *it++ << ", " ;

	cout << endl;
}

Section 9.4 How a vector Grows

Ordinarily, we should not care about how a library type works: All we should care about is how to use it. However, in the case of vectors, a bit of the implementation leaks into its interface. To support fast random access, vector elements are stored contiguouslyeach element is adjacent to the previous element
Given that elements are contiguous, let's think about what happens when we add an element to a vector: If there is no room in the vector for the new element, it cannot just add an element somewhere else in memory because the elements must be contiguous for indexing to work. Instead, the vector must allocate new memory to hold the existing elements plus the new one, copy the elements from the old location into the new space, add the new element, and deallocate the old memory. If vector did this memory allocation and deallocation each time we added an element, then performance would be unacceptably slow
There is no comparable allocation issue for containers that do not hold their elements contiguously
One might conclude, therefore, that in general it is a good idea to use a list rather than a vector. However, the contrary is usually the case: For most applications the best container to use is a vector. The reason is that library implementors use allocation strategies that minimize the costs of storing elements contiguously. That cost is usually offset by the advantages in accessing elements that contiguous storage allows
The way vectors achieve fast allocation is by allocating capacity beyond what is immediately needed. The vector holds this storage in reserve and uses it to allocate new elements as they are added. Thus, there is no need to reallocate the container for each new element. The exact amount of additional capacity allocated varies across different implementations of the library. This allocation strategy is dramatically more efficient than reallocating the container each time an element is added. In fact, its performance is good enough that in practice a vector usually grows more efficiently than a list or a deque
9.4.1. capacity and reserve Members
1. The vector class includes two members, capacity and reserve, that let us interact with the memory-allocation part of vector's implementation. The capacity operation tells us how many elements the container could hold before it must allocate more space. The reserve operation lets us tell the vector how many elements it should be prepared to hold
2. It is important to understand the difference between capacity and size. The size is the number of elements in the vector; capacity is how many it could hold before new space must be allocated
3. We know that the size of an empty vector is zero, and evidently our library also sets capacity of an empty vector to zero
4. Because we used only reserved capacity, there is no need for the vector to do any allocation. In fact, as long as there is excess capacity, the vector must not reallocate its elements
5. this vector implementation appears to follow a strategy of doubling the current capacity each time it has to allocate new storage
6. Each implementation of vector is free to choose its own allocation strategy. However, it must provide the reserve and capacity functions, and it must not allocate new memory until it is forced to do so. How much memory it allocates is up to the implementation. Different libraries will implement different strategies
7. Moreover, every implementation is required to follow a strategy that ensures that it is efficient to use push_back to populate a vector. Technically speaking, the execution time of creating an n-element vector by calling push_back n times on an initially empty vector is never more than a constant multiple of n
```
// EXE-9.4.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <vector>
#include <iostream>
#include <string>

using namespace std;

int main(int argc, _TCHAR* argv[])
{
	if("9.4.1. capacity and reserve Members")
	{
		vector<int> ivec;

		// size should be zero; capacity is implementation defined
		cout << "ivec: size: " << ivec.size()
			<< " capacity: "  << ivec.capacity() << endl;

		// give ivec 24 elements
		for (vector<int>::size_type ix = 0; ix != 24; ++ix)
			ivec.push_back(ix);

		// size should be 24; capacity will be >= 24 and is implementation defined
		cout << "ivec: size: " << ivec.size()
			<< " capacity: "  << ivec.capacity() << endl;

		ivec.reserve(50);  // sets capacity to at least 50; might be more
		// size should be 24; capacity will be >= 50 and is implementation defined
		cout << "ivec: size: " << ivec.size()
			<< " capacity: "  << ivec.capacity() << endl;

		// add elements to use up the excess capacity
		while (ivec.size() != ivec.capacity())
			ivec.push_back(0);
		// size should be 50; capacity should be unchanged
		cout << "ivec: size: " << ivec.size()
			<< " capacity: "  << ivec.capacity() << endl;
		
		ivec.push_back(42); // add one more element
		// size should be 51; capacity will be >= 51 and is implementation defined
		cout << "ivec: size: " << ivec.size()
			<< " capacity: "  << ivec.capacity() << endl;

	}
	int i;
	cin >> i;

	return 0;
}
```

Section 9.5 Deciding Which Container to Use

Whether elements are stored contiguously has other significant impacts on:

The costs to add or delete elements from the middle of the container
The costs to perform nonsequential access to elements of the container

The degree to which a program does these operations should be used to determine which type of container to use. The vector and deque types provide fast non-sequential access to elements at the cost of making it expensive to add or remove elements anywhere other than the ends of the container. The list type supports fast insertion and deletion anywhere but at the cost of making nonsequential access to elements expensive
How Insertion Affects Choice of Container
1. A list represents noncontiguous memory and allows for both forward and backward traversal one element at a time. It is efficient to insert or erase an element at any point. Inserting or removing an element in a list does not move any other elements. Random access, on the other hand, is not supported. Accessing an element requires traversing the intervening elements
  A deque is a more complicated data structure. We are guaranteed that adding or removing elements from either end of the deque is a fast operation. Adding or removing from the middle will be more expensive. A deque offers some properties of both list and vector:
  - Like vector, it is inefficient to insert or erase elements in the middle of the deque.
  - Unlike vector, a deque offers efficient insert and erase at the front as well as at the back.
  - Unlike list and like vector, a deque supports fast random access to any element.
  - Inserting elements at the front or back of a deque does not invalidate any iterators. Erasing the front or back element invalidates only iterators referring to the element(s) erased. Inserting or erasing anywhere else in the deque invalidates all iterators referring to elements of the deque
How Access to the Elements Affects Choice of Container
1. It is much slower to jump around in a list. the only way to move between the elements of a list is to sequentially follow the pointers. Moving from the 5th to the 15th element requires visiting every element between them
2. In general, unless there is a good reason to prefer another container, vector is usually the right one to use
Hints on Selecting Which Container to Use
1. Deciding which container to use may require profiling the performance of each container type doing the kinds of operations the application requires
2. When you are not certain which container the application should use, try to write your code so that it uses only operations common to both vectors and lists: Use iterators, not subscripts, and avoid random access to elements. By writing your programs this way, it will be easier to change the container from a vector to a list if necessary

Section 9.6 strings Revisited

Table 9.12. `string` Operations Introduced in Section 3.2
`string s;`	Defines a new, empty `string` named `s`.
`string s(cp);`	Defines a new `string` initialized from the null-terminated C-style string pointed to by `cp`.
`string s(s2);`	Defines a new `string` initialized as a copy of `s2`.
`is >> s;`	Reads a whitespace-separated string from the input stream `is` into `s`.
`os << s;`	Writes `s` to the output stream `os`.
`getline(is, s)`	Reads characters up to the first newline from input stream `is` into `s`.
`s1 + s2`	Concatenates `s1` and `s2`, yielding a new `string`.
`s1 += s2`	Appends `s2` to `s1`.
Relational Operators	The equality (`==` and `!=`) and relational (`<, <=, >`, and `>=)` can be used to compare `string`s. `string` comparison is equivalent to (case-sensitive) dictionary ordering.

In addition to the operations we've already used, strings also supports most of the sequential container operations. In some ways, we can think of a string as a container of characters
The container operations that string supports are:
- The typedefs, including the iterator types, listed in Table 9.5 (p. 316).
- The constructors listed in Table 9.2 (p. 307) except for the constructor that takes a single size parameter.
- The operations to add elements listed in Table 9.7 (p. 319) that vector supports. Note: Neither vector nor string supports push_front.
- The size operations in Table 9.8 (p. 324).
- The subscript and at operations listed in Table 9.9 (p. 325); string does not provide back or front operations listed in that table.
- The begin and end operations of Table 9.6 (p. 317).
- The erase and clear operations of Table 9.10 (p. 326); string does not support either pop_back or pop_front.
- The assignment operations in Table 9.11 (p. 329).
- Like the elements in a vector, the characters of a string are stored contiguously. Therefore, string supports the capacity and reserve operations described in Section 9.4 (p. 330).
The string library defines a great number of functions, which use repeated patterns. Given the number of functions supported, this section can be mind-numbing on first reading

9.6.1. Other Ways to Construct strings

The definition of s4 is an error. This form of initialization may be called only with a null-terminated array. Passing an array that does not contain a null is a serious error (Section 4.3, p. 130), although it is an error that the compiler cannot detect. What happens at run time is undefined

Table 9.13. Additional Ways to Construct `string`s
`string s(cp, n)`	Create `s` as a copy of `n` characters from array pointed to by `cp`.
`string s(s2, pos2)`	Create `s` as a copy of characters in the `string s2` starting at index `pos2`. Undefined if `pos2 > s2.size()`.
`string s(s2, pos2, len2)`
	Create `s` as a copy of `len2` characters from `s2` starting at index `pos2`. Undefined if `pos2 > s2.size()`. Regardless of the value of `len2`, copies at most `s2.size() - pos2` characters.
Note: `n, len2` and `pos2` are all `unsigned` values

Using a Substring as the Initializer

9.6.2. Other Ways to Change a string

Table 9.14. `string` Operations in Common with the Containers
`s.insert(p, t)`	Insert copy of value `t` before element referred to by iterator `p`. Returns an iterator referring to the inserted element.
`s.insert(p, n, t)`	Insert `n` copies of `t` before `p`. Returns `void`.
`s.insert(p, b, e)`	Insert elements in range denoted by iterators `b` and `e` before `p`. Returns `void`.
`s.assign(b, e)`	Replace `s` by elements in range denoted by `b` and `e`. For `string`, returns `s`, for the containers, returns `void`.
`s.assign(n, t)`	Replace `s` by `n` copies of value `t`. For `string`, returns `s`, for the containers, returns `void`.
`s.erase(p)`	Erase element referred to by iteartor `p`. Returns an iterator to the element after the one deleted.
`s.erase(b, e)`	Remove elements in range denoted by `b` and `e`. Returns an iterator to the first element after the range deleted.

Table 9.15. `string`-Specific Versions
`s.insert(pos, n, c)`	Insert `n` copies of character `c` before element at index `pos`.
`s.insert(pos, s2)`	Insert copy of `string s2` before `pos`.
`s.insert(pos, s2, pos2, len)`
	Insert `len` characters from `s2` starting at `pos2` before `pos`.
`s.insert(pos, cp, len)`	Insert `len` characters from array pointed to by `cp` before `pos`.
`s.insert(pos, cp)`	Insert copy of null-terminated string pointed to by `cp` before `pos`.
`s.assign(s2)`	Replace `s` by a copy of `s2`.
`s.assign(s2, pos2, len)`	Replace `s` by a copy of `len` characters from `s2` starting at index `pos2` in `s2`.
`s.assign(cp, len)`	Replace `s` by `len` characters from array pointed to by `cp`.
`s.assign(cp)`	Replace `s` by null-terminated array pointed to by `cp`.
`s.erase(pos, len)`	Erase `len` characters starting at `pos`.
Unless noted otherwise, all operations return a reference to `s`.

Position-Based Arguments
Specifying the New Contents
1. The characters to insert or assign into the string can be taken from a character array or another string

9.6.3. string-Only Operations

The string type provides several other operations that the containers do not:
- The substr function that returns a substring of the current string
- The append and replace functions that modify the string
- A family of find functions that search the string
The substr Operation
The append and replace Functions

Table 9.17. Operations to Modify `string`s (args defined in Table 9.18)
`s.append(` args`)`	Append args to `s`. Returns reference to `s`.
`s.replace(pos, len`, args`)`	Remove `len` characters from `s` starting at `pos` and replace them by characters formed by args. Returns reference to `s`. This version does not take args equal to `b2`, `e2`.
`s.replace(b, e`, args`)`	Remove characters in the range denoted by iterators `b` and `e` and replace them by args. Returns reference to `s`. This version does not take args equal to `s2, pos2, len2`.

There is no requirement that the size of the text removed and inserted be the same

Table 9.18. Arguments to `append` and `replace`
`s2`	The `string s2`.
`s2, pos2, len2`	up to `len2` characters from `s2` starting at `pos2`.
`cp`	Null-terminated array pointed to by pointer `cp`.
`cp, len2`	up to `len2` characters from character array pointed to by `cp`.
`n, c`	`n` copies of character `c`.
`b2, e2`	Characters in the range formed by iterators `b2` and `e2`.

9.6.4. string Search Operations

Table 9.19. `string` Search Operations (Arguments in Table 9.20)
`s.find(` args`)`	Find first occurrence of args in `s`.
`s.rfind(` args`)`	Find last occurrence of args in `s`.
`s.find_first_of(` args`)`	Find first occurrence of any character from args in `s`.
`s.find_last_of(` args`)`	Find last occurrence of any character from args in `s`.
`s.find_first_not_of(` args`)`	Find first character in `s` that is not in args.
`s.find_last_not_of(` args`)`	Find last character in `s` that is not in args.

Table 9.20. Arguments to `string find` Operations
`c, pos`	Look for the character `c` starting at position `pos` in `s`. `pos` defaults to 0.
`s2, pos`	Look for the `string s2` starting at position `pos` in `s`. `pos` defaults to 0.
`cp, pos`	Look for the C-style null-terminated string pointed to by the pointer `cp`. Start looking starting at position `pos` in `s`. `pos` defaults to 0.
`cp, pos, n`	Look for the first `n` characters in the array pointed to by the pointer `cp`. Start looking starting at position `pos` in `s`. No default for `pos` or `n`.

Finding an Exact Match
1. By default, the find operations (and other string operations that deal with characters) use the built-in operators to compare characters in the string. As a result, these operations (and other string operations) are case sensitive
2. The find operations return a string::size_type. Use an object of that type to hold the return from find
3. It is essential that we increment pos. Doing so ensures that we start looking for the next number at a point after the number we just found
Find Any Character
Specifying Where to Start the Search
Looking for a Nonmatch
Searching Backward
The find_last Functions

9.6.5. Comparing strings

the string type defines all the relational operators so that we can compare two strings for equality (==), inequality (!=), and the less- or greater-than operations (<, <=, >, >=). Comparison between strings is lexicographicalthat is, string comparison is the same as a case-sensitive, dictionary ordering

The compare Functions

In addition to the relational operators, string provides a set of compare operations that perform lexicographical comparions. The results of these operations are similar to the C library strcmp function
compare returns one of three possible values:
1. A positive value if s1 is greater than the string represented by args
2. A negative value if s1 is less than the string represented by args
3. 0 if s1 is equal to the string represented by args

Table 9.21. `string compare` Operations
`s.compare(s2)`	Compare `s` to `s2`.
`s.compare(pos1, n1, s2)`
	Compares `n1` characters starting at `pos1` from `s` to `s2`.
`s.compare(pos1, n1, s2, pos2, n2)`
	Compares `n1` characters starting at `pos1` from `s` to the `n2` characters starting at `pos2` in `s2`.
`s.compare(cp)`	Compares `s` to the null-terminated string pointed to by `cp`.
`s.compare(pos1, n1, cp)`
	Compares `n1` characters starting at `pos1` from `s` to `cp`.
`s.compare(pos1, n1, cp, n2)`
	Compares `n1` characters starting at `pos1` from `s` to `n2` characters starting from the pointer `cp`.

Section 9.7 Container Adaptor

In addition to the sequential containers, the library provides three sequential container adaptors: queue, priority_queue, and stack

An adaptor is a general concept in the library. There are container, iterator, and function adaptors. Essentially, an adaptor is a mechanism for making one thing act like another. A container adaptor takes an existing container type and makes it act like a different abstract type

Table 9.22. Common Adaptor Operations and Types
`size_type`	Type large enough to hold size of largest object of this type.
`value_type`	Element type.
`container_type`	Type of the underlying container on which the adaptor is implemented.
`A a;`	Create a new empty adaptor named `a`.
`A a(c);`	Create a new adaptor named `a` with a copy of the container `c`.
Relational Operators	Each adaptor supports all the relational operators: `==, !=, <, <=, >, >=`.

Initializing an Adapator
1. Each adaptor defines two constructors: the default constructor that creates an empty object and a constructor that takes a container and makes a copy of that container as its underlying value
Overriding the Underlying Container Type
1. By default both stack and queue are implemented in terms of deque, and a priority_queue is implemented on a vector. We can override the default container type by naming a sequential container as a second type argument when creating the adaptor
2. There are constraints on which containers can be used for a given adapator. We can use any of the sequential containers as the underlying container for a stack
Relational Operations on Adaptors
1. Two adaptors of the same type can be compared for equality, inequality, less-than, greater-than, less-than-equal, and greater-than-equal relationships, provided that the underlying element type supports the equality and less-than operators

9.7.1. Stack Adaptor

Table 9.23. Operations Supported by the Stack Container Adaptor
`s.empty()`	Returns `TRue` if the `stack` is empty; false otherwise.
`s.size()`	Returns a count of the number of elements on the `stack`.
`s.pop()`	Removes, but does not return, the top element from the `stack`.
`s.top()`	Returns, but does not remove, the top element on the `stack`.
`s.push(item)`	Places a new top element on the `stack`.

9.7.2. Queue and Priority Queue

The library queue uses a first-in, first-out (FIFO) storage and retrieval policy. Objects entering the queue are placed in the back. The next object retrieved is taken from the front of the queue. There are two kinds of queues: the FIFO queue, which we will speak of simply as a queue, and a priority queue
A priority_queue lets us establish a priority among the elements held in the queue. Rather than place a newly entered item at the back of the queue, the item is placed ahead of all those items with a lower priority. By default, the library uses the < operator on the element type to determine relative priorities

To use either queue or priority_queue, we must include the queue header

Table 9.24. Operations Supported by Queues and Priority Queues
`q.empty()`	Returns `TRue` if the `queue` is empty; false otherwise.
`q.size()`	Returns a count of the number of elements on the `queue`.
`q.pop()`	Removes, but does not return, the front element from the `queue`.
`q.front()`	Returns, but does not remove, the front element on the `queue`. This operation can be applied only to a `queue`.
`q.back()`	Returns, but does not remove, the back element on the `queue`. This operation can be applied only to a `queue`.
`q.top()`	Returns, but does not remove, the highest-priority element. This operation can be applied only to a `priority_queue`.
`q.push(item)`	Places a new element at the end of the `queue` or at its appropriate position based on priority in a `priority_queue`.

C++ Primer Answer book for 4rd edition Exercise 8-3

2011-01-17T01:26:00.001-08:00

// Exercise 8.3.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>

using namespace std;
ifstream &printOut( ifstream &in);
istream &print( istream &in);
int main(int argc, _TCHAR* argv[])
{
ifstream in("ReadMe.txt");

//ifstream &inf = printOut(in);

//if(inf)
//{
// cout << "Testing the stream input;" << endl;
// string s;
// //Issue here: already clear the stream, but the stream still can't be reused
// while(inf >> s , !inf.eof())
// {
// cout << s << endl;
// }
// inf.close();
//}

ifstream inf1("ReadMe.txt");
print( inf1);

print(cin);
// test the cleared eofbit mark
if(cin.eof())
{
//why it always show it is not cleared here?
cout << "the eof mark is not cleared!" << endl;
}
else
cout << "the eof mark is cleared!" << endl;
int i(0);
cin >> i;
return 0;
}

ifstream &printOut( ifstream &in)
{
string s;
while(in >> s , !in.eof())
{
//print out all to standard output
cout << s << endl;
}
//reset the stream
in.clear( istream::eofbit);
//in.setstate( istream::eofbit);

return in;
}
istream &print( istream &in)
{
string s;
while(in >> s , !in.eof())
{
//print out all to standard output
cout << s << endl;
}
if(in.eof())
{
cout << "The end of file!" << endl;
}
// clear the eofbit mark
in.clear( istream::eofbit);

return in;
}
Angelo Yin

Keep moving forward!

C++ Primer Answer book for 4rd edition-Exercise 8.16

2011-01-17T01:09:00.001-08:00

// Exercise 8.16.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <string>
#include <vector>
#include <iostream>
#include <sstream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}

Angelo Yin

Keep moving forward!

C++ Primer, Fourth Edition Notes Chapter 8. The IO Library

2011-01-10T21:55:00.003-08:00

Section 8.1 An Object-Oriented Library

Conceptually, neither the kind of device nor the character size affect the IO operations we want to perform.
To manage the complexity, the library uses inheritance to define a set of object-oriented classes.
The IO types are defined in three separate headers: iostream defines the types used to read and write to a console window, fstream defines the types used to read and write named files, and sstream defines the types used to read and write in-memory strings

Each of the types in fstream and sstream is derived from a corresponding type defined in the iostream header

Table 8.1. IO Library Types and Headers
Header	Type
`iostream`	`istream` reads from a stream `ostream` writes to a stream `iostream` reads and writes a stream; derived from `istream` and `ostream`,
`fstream`	`ifstream`, reads from a file; derived from `istream` `ofstream` writes to a file; derived from `ostream` `fstream`, reads and writes a file; derived from `iostream`
`sstream`	`istringstream` reads from a `string`; derived from `istream` `ostringstream` writes to a `string`; derived from `ostream` `stringstream` reads and writes a `string`; derived from `iostream`

Using inheritance for the IO types has another important implication: As we'll see in Chapter 15, when we have a function that takes a reference to a base-class type, we can pass an object of a derived type to that function
International Character Support
1. The stream classes described thus far read and write streams composed of type char. The library defines a corresponding set of types supporting the wchar_t type. Each class is distinguished from its char counterpart by a "w" prefix. Thus, the types wostream, wistream, and wiostream read and write wchar_t data to or from a console window. The file input and output classes are wifstream, wofstream, and wfstream. The wchar_t versions of string stream input and output are wistringstream, wostringstream, and wstringstream. The library also defines objects to read and write wide characters from the standard input and standard output. These objects are distinguished from the char counterparts by a "w" prefix: The wchar_t standard input object is named wcin; standard output is wcout; and standard error is wcerr
2. Each of the IO headers defines both the char and wchar_t classes and standard input/output objects. The stream-based wchar_t classes and objects are defined in iostream, the wide character file stream types in fstream, and the wide character stringstreams in sstream.
No Copy or Assign for IO Objects
1. the library types do not allow allow copy or assignment:
2. This requirement has two particularly important implications. As we'll see in Chapter 9, only element types that support copy can be stored in vectors or other container types. Because we cannot copy stream objects, we cannot have a vector (or other container) that holds stream objects
3. The second implication is that we cannot have a parameter or return type that is one of the stream types. If we need to pass or return an IO object, it must be passed or returned as a pointer or reference
4. Typically, we pass a stream as a nonconst reference because we pass an IO object intending to read from it or write to it. Reading or writing an IO object changes its state, so the reference must be nonconst.

Section 8.2 Condition States

Keep in mind that the material we cover in this section and the next applies equally to plain streams, file streams, or string streams

The IO library manages a set of condition state members that indicate whether a given IO object is in a usable state or has encountered a particular kind of error. The library also defines a set of functions and flags, listed in Table 8.2, that give us access to and let us manipulate the state of each stream

Table 8.2. IO Library Condition State
strm`::iostate`	Name of the machine-dependent integral type, defined by each `iostream` class that is used to define the condition states.
strm`::badbit`	strm`::iostate` value used to indicate that a stream is corrupted.
strm`::failbit`	strm`::iostate` value used to indicate that an IO operation failed.
strm`::eofbit`	strm`::iostate` value used to indicate the a stream hit end-of-file.
`s.eof()`	`true` if `eofbit` in the stream `s` is set.
`s.fail()`	`true` if `failbit` in the stream `s` is set.
`s.bad()`	`TRue` if `badbit` in the stream `s` is set.
`s.good()`	`true` if the stream `s` is in a valid state.
`s.clear()`	Reset all condition values in the stream `s` to valid state.
`s.clear(flag)`	Set specified condition state(s) in `s` to valid. Type of `flag` is strm`::iostate`.
`s.setstate(flag)`	Add specified condition to `s`. Type of `flag` is strm`::iostate`.
`s.rdstate()`	Returns current condition of `s` as an strm`::iostate` value.

To be used for input or output, a stream must be in a non-error state. The easiest way to test whether a stream is okay is to test its truth value

          if (cin)
               // ok to use cin, it is in a valid state

          while (cin >> word)
               // ok: read operation successful ...

Condition States
1. Each stream object contains a condition state member that is managed through the setstate and clear operations. This state member has type iostate, which is a machine-dependent integral type defined by each iostream class.
2. Each IO class also defines three const values of type iostate that represent particular bit patterns. These const values are used to indicate particular kinds of IO conditions. They can be used with the bitwise operators (Section 5.3, p. 154) to test or set multiple flags in one operation.
3. The badbit indicates a system level failure, such as an unrecoverable read or write error. It is usually not possible to continue using a stream after such an error.
4. The failbit is set after a recoverable error, such as reading a character when numeric data was expected. It is often possible to correct the problem that caused the failbit to be set.
5. The eofbit is set when an end-of-file is encountered. Hitting end-of-file also sets the failbit
6. If any of bad, fail, or eof are true, then testing the stream itself will indicate that the stream is in an error state. Similarly, the good operation returns TRue if none of the other conditions is true.
7. The clear and setstate operations change the state of the condition member. The clear operations put the condition back in its valid state. They are called after we have remedied whatever problem occurred and we want to reset the stream to its valid state. The setstate operation turns on the specified condition to indicate that a problem occurred. setstate leaves the existing state variables unchanged except that it adds the additional indicated state(s).
Interrogating and Controlling the State of a Stream
1. Recall that the comma operator executes by evaluating each operand and returns its rightmost operand as its result.
Accessing the Condition State
1. The rdstate member function returns an iostate value that corresponds to the entire current condition state of the stream
Dealing with Multiple States
1. Alternatively, we could use the bitwise OR (Section 5.3, p. 154) operator to generate a value to pass two or more state bits in a single call. The bitwise OR generates an integral value using the bit patterns of its operands. For each bit in the result, the bit is 1 if the corresponding bit is 1 in either of its operands
```
// sets both the badbit and the failbit
   is.setstate(ifstream::badbit | ifstream::failbit);
```
tells the object is to turn on both the failbit and the badbit

Section 8.3 Managing the Output Buffer

Each IO object manages a buffer, which is used to hold the data that the program reads and writes
There are several conditions that cause the buffer to be flushedthat is, writtento the actual output device or file
1. The program completes normally. All output buffers are emptied as part of the return from main.
2. At some indeterminate time, the buffer can become full, in which case it will be flushed before writing the next value
3. We can flush the buffer explicitly using a manipulator (Section 1.2.2, p. 7) such as endl
4. We can use the unitbuf manipulator to set the stream's internal state to empty the buffer after each output operation
5. We can tie the output stream to an input stream, in which case the output buffer is flushed whenever the associated input stream is read
Flushing the Output Buffer
1. Our programs have already used the endl manipulator, which writes a newline and flushes the buffer. There are two other similar manipulators. The first, flush, is used quite frequently. It flushes the stream but adds no characters to the output. The second, ends, is used much less often. It inserts a null character into the buffer and then flushes it
```
    cout << "hi!" << flush;      // flushes the buffer; adds no data
    cout << "hi!" << ends;       // inserts a null, then flushes the buffer
    cout << "hi!" << endl;       // inserts a newline, then flushes the buffer
```

The unitbuf Manipulator

If we want to flush every output, it is better to use the unitbuf manipulator. This manipulator flushes the stream after every write

The nounitbuf manipulator restores the stream to use normal, system-managed buffer flushing

Caution: Buffers Are Not Flushed if the Program Crashes

Output buffers are not flushed if the program terminates abnormally. When attempting to debug a program that has crashed, we often use the last output to help isolate the region of program in which the bug might occur. If the crash is after a particular print statement, then we know that the crash happened after that point in the program.

When debugging a program, it is essential to make sure that any output you think should have been written was actually flushed. Because the system does not automatically flush the buffers when the program crashes, it is likely that there is output that the program wrote but that has not shown up on the standard output. It is still sitting in an output buffer waiting to be printed.

If you use the last output to help locate the bug, you need to be certain that all the output really did get printed. Making sure that all output operations include an explicit flush or call to endl is the best way to ensure that you are seeing all the output that the program actually processed.

Countless hours of programmer time have been wasted tracking through code that appeared not to have executed when in fact the buffer simply had not been flushed. For this reason, we tend to use endl rather than \n when writing output. Using endl means we do not have to wonder whether output is pending when a program crashes.

Tying Input and Output Streams Together

When an input stream is tied to an output stream, any attempt to read the input stream will first flush the buffer associated output stream. The library ties cout to cin
Interactive systems usually should be sure that their input and output streams are tied. Doing so means that we are guaranteed that any output, which might include prompts to the user, has been written before attempting to read
The tie function can be called on either istream or an ostream. It takes a pointer to an ostream and ties the argument stream to the object on which tie was called. When a stream ties itself to an ostream, then any IO operation on the stream that called tie flushes the buffer associated with the argument it passed to tie
An ostream object can be tied to only one istream object at a time. To break an existing tie, we pass in an argument of 0.

// EXE-8.3.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <iostream>
#include <string>
using namespace std;

int main(int argc, _TCHAR* argv[])
{
	
	cout << "hi!" << ends;       // inserts a null, then flushes the buffer
	cout << "hi!" << flush;      // flushes the buffer; adds no data
	cout << "hi!" << endl;       // inserts a newline, then flushes the buffer
	
	cout << unitbuf << "first" << " second" << nounitbuf <<endl;
	cout << "first" << flush << " second" << flush;

	cout << endl;
	string tieTest;
	cin.tie(&cout);   // illustration only: the library ties cin and cout for us
	ostream *old_tie = cin.tie();
	cin.tie(0); // break tie to cout, cout no longer flushed when cin is read
	cout << "test";
	cin >> tieTest ;
	cin.tie(&cerr);   // ties cin and cerr, not necessarily a good idea!
	// ...
	cin.tie(0);       // break tie between cin and cerr
	cin.tie(old_tie); // restablish normal tie between cin and cout
	

	int i;
	cin >> i;
	return 0;
}

Section 8.4 File Input and Output

The fstream header defines three types to support file IO:
1. ifstream, derived from istream, reads from a file.
2. ofstream, derived from ostream, writes to a file.
3. fstream, derived from iostream, reads and writes the same file.
In addition to the behavior that fstream types inherit, they also define two new operations of their ownopen and closealong with a constructor that takes the name of a file to open. These operations can be called on objects of fstream, ifstream, or ofstream but not on the other IO types

8.4.1. Using File Stream Objects

When we want to read or write a file, we must define our own objects, and bind them to the desired files
Supplying a file name as an initializer to an ifstream or ofstream object has the effect of opening the specified file
Before we use an fstream object, we must also bind it to a file to read or write

We bind an existing fstream object to the specified file by calling the open member. The open function does whatever system-specific operations are required to locate the given file and open it for reading or writing as appropriate

Caution: File Names in C++

For historical reasons, the IO library uses C-style character strings (Section 4.3, p. 130) rather than C++ strings to refer to file names. When we call open or use a file name as the initializer when creating an fstream object, the argument we pass is a C-style string, not a library string. Often our programs obtain file names by reading the standard input. As usual, it is a good idea to read into a string, not a C-style character array. Assuming that the name of the file we wish to use is in a string, we can use the c_str member (Section 4.3.2, p. 139) to obtain a C-style string.

Checking Whether an Open Succeeded
1. When we test a stream, the effect is to test whether the object is "okay" for input or output. If the open fails, then the state of the fstream object is that it is not ready for doing IO
Rebinding a File Stream to a New File
1. Once an fstream has been opened, it remains associated with the specified file. To associate the fstream with a different file, we must first close the existing file and then open a different file
2. It is essential that we close a file stream before attempting to open a new file. The open function checks whether the stream is already open. If it is open, then it sets its internal state to indicate that a failure has happened. Subsequent attempts to use the file stream will fail
Clearing the State of a File Stream
1. Closing a stream does not change the internal state of the stream object
2. If we reuse a file stream to read or write more than one file, we must clear the stream before using it to read from another file

8.4.2. File Modes

Each fstream class defines a set of values that represent different modes in which the stream could be opened. Like the condition state flags, the file modes are integral constants that we use with the bitwise operators (Section 5.3, p. 154) to set one or more modes when we open a given file. The file stream constructors and open have a default argument (Section 7.4.1, p. 253) to set the file mode. The value of the default varies based on the type of the stream. Alternatively, we can supply the mode in which to open the file. Table 8.3 on the next page lists the file modes and their meanings

Table 8.3. File Modes
`in`	open for input
`out`	open output
`app`	seek to the end before every write
`ate`	seek to the end immediately after the open
`trunc`	truncate an existing stream when opening it
`binary`	do IO operations in binary mode

The modes out, trunc, and app may be specifed only for files associated with an ofstream or an fstream; in may be specified only for files associated with either ifstream or fstream. Any file may be opened in ate or binary mode. The ate mode has an effect only at the open: Opening a file in ate mode puts the file at the end-of-file immediately after the open. A stream opened in binary mode processes the file as a sequence of bytes; it does no interpretation of the characters in the stream

By default, files associated with an ifstream are opened in in mode, which is the mode that permits the file to be read. Files opened by an ofstream are opened in out mode, which permits the file to be written. A file opened in out mode is truncated: All data stored in the file is discarded
In effect, specifying out mode for an ofstream is equivalent to specifying both out and trunc
The only way to preserve the existing data in a file opened by an ofstream is to specify app mode explicitly
Using the Same File for Input and Output
1. An fstream object can both read and write its associated file. How an fstream uses its file depends on the mode specified when we open the file
2. By default, an fstream is opened with both in and out set. A file opened with both in and out mode set is not truncated. If we open the file associated with an fstream with out mode, but not in mode specified, then the file is truncated. The file is also truncated if trunc is specified, regardless of whether in is specified
Mode Is an Attribute of a File, Not a Stream
1. Any time open is called, the file mode is set, either explicitly or implicitly. If a mode is not specified, the default value is used.

Valid Combinations for Open Mode

Not all open modes can be specified at once. Some are nonsensical, such as opening a file setting both in and TRunc. That would yield a stream we intend to read but that we have truncated so that there is no data to read

Table 8.4. File Mode Combinations
`out`	open for output; deletes existing data in the file
`out \| app`	open for output; all writes at end of file
`out \| trunc`	same as `out`
`in`	open for input
`in \| out`	open for both input and output; positioned to read the beginning of the file
`in \| out \| trunc`	open for both input and output, deletes existing data in the file

Any open mode combination may also include ate. The effect of adding ate to any of these modes changes only the initial position of the file. Adding ate to any of these mode combinations positions the file to the end before the first input or output operation is performed

8.4.3. A Program to Open and Check Input Files

// EXE-8.4.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>

using namespace std;

int main(int argc, _TCHAR* argv[])
{

	// construct an ifstream and bind it to the file named ifile
	string filePath = "filestreamtesting.txt";
	ifstream infile1(filePath);
	// check that the open succeeded
	if (!infile1) {
		cerr << "error: unable to open input file: "
			<< infile1 << endl;
		//return -1;
	}
	
	// ofstream output file object to write file named ofile
	ofstream outfile(filePath);
	//char *pO = "try to write the file!";
	
	outfile.write(filePath.c_str(),filePath.length());
	outfile.flush();
	outfile.close();

	ifstream infile(filePath);
	char *p = new char(0);
	infile.read(p,filePath.length());

	for (int i = 0 ; i < filePath.length(); ++i)
	{
		cout <<*(p+ i) ;
	}
	while( *p != 0)
	{
	cout << *p++;
	}
	delete p; // error to delete the p
	p = 0;

	infile.close();

	//ifstream infile("in");      // opens file named "in" for reading
	//infile.close();             // closes "in"
	infile.open("no existing file.txt");        // opens file named "next" for reading
	if(!infile)
	{
		cout << "To open file failed!" << endl;
	}
	infile.close();	


	if("Clearing the State of a File Stream")
	{
		ifstream input;
		vector<string> files;
		files.push_back(filePath);
		files.push_back("ReadMe.txt");
		vector<string>::const_iterator it = files.begin();
		string s;
		//   for each file in the vector
		void process(string s);
		while (it != files.end()) {
			input.open(it->c_str());  // open the file
			// if the file is ok, read and "process" the input
			if (!input)
				break;                    // error: bail out!
			while(input >> s) // do the work on this file
				process(s);
			input.close();        // close file when we're done with it
			input.clear();        // reset state to ok
			++it;                 // increment iterator to get next file
		}
	}	

	if("File Modes")
	{
		//  output mode by default; truncates file named "file1"
		ofstream outfile("file1");
		// equivalent effect: "file1" is explicitly truncated
		ofstream outfile2("file1", ofstream::out | ofstream::trunc);
		//  append mode; adds new data at end of existing file named "file2"
		ofstream appfile("file2", ofstream::app);
	}
	if("Using the Same File for Input and Output")
	{
		// open for input and output
		fstream inOut("copyOut", fstream::in | fstream::out);
	}
	if("Mode Is an Attribute of a File, Not a Stream")
	{
		ofstream outfile;
		// output mode set to out, "scratchpad" truncated
		outfile.open("scratchpad", ofstream::out);
		outfile.close();    // close outfile so we can rebind it
		// appends to file named "precious"
		outfile.open("precious", ofstream::app);
		outfile.close();
		// output mode set by default, "out" truncated
		outfile.open("out");
	}

	if("A Program to Open and Check Input Files")
	{
		// opens in binding it to the given file
		ifstream& open_file(ifstream &in, const string &file);

		
		// failed to build with the following code
		// can't call the code like the following
		//ifstream infile = open_file(infile, filePath);
		ifstream &infile = open_file(infile, filePath);
	}

	int i;
	cin >> i;

	return 0;
}

void process(string s)
{
	cout << s << endl;
}

// opens in binding it to the given file
ifstream& open_file(ifstream &in, const string &file)
{
	in.close();     // close in case it was already open
	in.clear();     // clear any existing errors
	// if the open fails, the stream will be in an invalid state
	in.open(file.c_str()); // open the file we were given
	return in; // condition state is good if open succeeded
}

Section 8.5 String Streams

The iostream library supports in-memory input/output, in which a stream is attached to a string within the program's memory. That string can be written to and read from using the iostream input and output operators. The library defines three kinds of string streams:
- istringstream, derived from istream, reads from a string.
- ostringstream, derived from ostream, writes to a string.
- stringstream, derived from iostream, reads and writes a string
In addition to the operations that the sstream types inherit, these types have a constructor that takes a string. The constructor copies the string argument into the stringstream object. The operations that read and write the stringstream read or write the string in the object. These classes also define a member named str to fetch or set the string value that the stringstream manipulates

Note that although fstream and sstream share a common base class, they have no other interrelationship. In particular, we cannot use open and close on a stringstream, nor can we use str on an fstream

Table 8.5. `stringstream`-Specific Operations
`stringstream strm;`	Creates an unbound `stringstream`.
`stringstream strm(s);`	Creates a `stringstream` that holds a copy of the `string s`.
`strm.str()`	Returns a copy of the `string` that `strm` holds.
`strm.str(s)`	Copies the `string s` into `strm`. Returns `void`.

Using a stringstream
stringstreams Provide Conversions and/or Formatting
1. One common use of stringstreams is when we want to obtain automatic formatting across multiple data types
2. Reading an istringstream automatically converts from the character representation of a numeric value to its corresponding arithmetic value
3. To read input_string, we must parse the string into its component parts. We want the numeric values; to get them we must read (and ignore) the labels that are interspersed with the data we want
4. Because the input operator reads typed values, it is essential that the types of the objects into which we read be compatible with the types of the values read from the stringstream

// EXE-8.5.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
//here for using istringstream must include the sstream
#include <sstream>
#include <string>
#include <vector>

using namespace std;

int main(int argc, _TCHAR* argv[])
{
	if("Using a stringstream")
	{
		string line, word;      // will hold a line and word from input, respectively
		cout << "Please input a string (\\0 for break):" << endl;
		while (getline(cin, line))   {            // read a line from the input into line
			// do per-line processing
			if(line == "\\0")
				break;

			istringstream strIn(line);            // bind to stream to the line we read
			while (strIn >> word){          // read a word from line
				// do per-word processing
				cout << "PrintOut:" << word << endl;
			}
		}

	}

	if("stringstreams Provide Conversions and/or Formatting")
	{
		int val1 = 512, val2 = 1024;
		ostringstream format_message;
		// ok: converts values to a string representation
		format_message << "val1: " << val1 << "\n"
			<< "val2: " << val2 << "\n";

		// str member obtains the string associated with a stringstream
		istringstream input_istring(format_message.str());
		string dump; // place to dump the labels from the formatted message
		// extracts the stored ascii values, converting back to arithmetic types
		input_istring >> dump >> val1 >> dump >> val2;
		cout << val1 << " " << val2 << endl;  // prints 512 1024


	}

	int i;
	cin >> i;

	return 0;
}

TECH-THINKER

Angelo Yin (阴平)'s invitation is awaiting your response

Angelo Yin (阴平)'s invitation is awaiting your response

I'd like to add you to my professional network on LinkedIn

C++ Primer, Fourth Edition:Notes Chapter 14. Overloaded Operations and Conversions

Section 14.1 Defining an Overloaded Operator

Table 14.1. Overloadable Operators

Table 14.2. Operators That Cannot Be Overloaded

Caution: Use Operator Overloading Judiciously

Section 14.2 Input and Output Operators

Section 14.3 Arithmetic and Relational Operators

Section 14.4 Assignment Operators

Section 14.5 Subscript Operator

Section 14.6 Member Access Operators

Section 14.7 Increment and Decrement Operators

Section 14.8 Call Operator and Function Objects

Section 14.9 Conversions and Class Types

C++ Primer, Fourth Edition:Notes Chapter 17. Tools for Large Programs

Section 17.1 Exception Handling

Section 17.2 Namespaces

Section 17.3 Multiple and Virtual Inheritance

C++ Primer, Fourth Edition:Notes Chapter 16. Templates and Generic Programming

Section 16.1 Template Definitions

Section 16.2 Instantiation

Section 16.3 Template Compilation Models

Section 16.4 Class Template Members

Section 16.5 A Generic Handle Class

Section 16.6 Template Specializations

Section 16.7 Overloading and Function Templates

C++ Primer, Fourth Edition:Notes Chapter 15. Object-Oriented Programming

Section 15.1 OOP: An Overview

Section 15.2 Defining Base and Derived Classes

Section 15.3 Conversions and Inheritance

Section 15.4 Constructors and Copy Control

Section 15.5 Class Scope under Inheritance

Section 15.6 Pure Virtual Functions

Section 15.7 Containers and Inheritance

Section 15.8 Handle Classes and Inheritance

Section 15.9 Text Queries Revisited

C++ Primer, Fourth Edition:Notes Chapter Chapter 18. Specialized Tools and Techniques

Section 18.1 Optimizing Memory Allocation

Section 18.2 Run-Time Type Identification

Section 18.3 Pointer to Class Member

Section 18.4 Nested Classes

Section 18.5 Union: A Space-Saving Class

Section 18.6 Local Classes

Section 18.7 Inherently Nonportable Features

C++ Primer, Fourth Edition:Notes Chapter 13. Copy Control

Section 13.1 The Copy Constructor

Section 13.2 The Assignment Operator

Section 13.3 The Destructor

Section 13.4 A Message-Handling Example

Section 13.5 Managing Pointer Members

Advice: Managing Pointer Members

C++ Primer, Fourth Edition:Notes Chapter 11. Generic Algorithms

Section 11.1 Overview

Section 11.2 A First Look at the Algorithms

Section 11.3 Revisiting Iterators

Section 11.4 Structure of Generic Algorithms

Section 11.5 Container-Specific Algorithms

Good windows live writer code format plugin

C++ Primer, Fourth Edition:Notes Chapter 12. Classes

Section 12.1 Class Definitions and Declarations

Advice: Concrete and Abstract Types

Key Concept: Benefits of Data Abstraction and Encapsulation

Section 12.2 The Implicit this Pointer

Advice: Use Private Utility Functions for Common Code

Section 12.3 Class Scope

Section 12.4 Constructors

Advice: Use Constructor Initializers

Section 12.5 Friends

Section 12.6 static Class Members

C++ Primer, Fourth Edition:Notes Chapter 10 Associative Containers

Table 10.1. Associative Container Types

Section 10.1 Preliminaries: the pair Type

Table 10.2. Operations on pairs

Section 10.2 Associative Containers

Section 10.3 The map Type

Table 10.3. Constructors for map

Table 10.4. Types Defined by the map Class

Table 10.2. Operations on `pairs`

Table 10.3. Constructors for `map`

Table 10.4. Types Defined by the `map` Class

Table 10.5. `insert` Operations on maps

Table 9.4. Operations Supported by `vector` and `deque` Iterators

Table 9.6. Container `begin` and `end` Operations

Table 9.12. `string` Operations Introduced in Section 3.2

Table 9.13. Additional Ways to Construct `string`s

Table 9.14. `string` Operations in Common with the Containers

Table 9.15. `string`-Specific Versions

Table 9.17. Operations to Modify `string`s (args defined in Table 9.18)

Table 9.18. Arguments to `append` and `replace`

Table 9.19. `string` Search Operations (Arguments in Table 9.20)

Table 9.20. Arguments to `string find` Operations

Table 9.21. `string compare` Operations