『Accelerated C++』ノート抜粋

1. A variable is an object that has a name. it is possible to have 
   objects that do not have names,but variable must have a name. the 
   limited lifetime of local variables is one reason that it is 
   important to distinguish between variables and objects 
2. std::cin >> name; 
   when we ask the library to read a string , it begins by discarding 
 whitespace characters (space, tab, backspace or the end of the 
   line) from input, then reads characters into name until it en 
   encounters another whitespace character or end-of-line 
3. we can determine what the + operator does by examining the types 
   of its operands. when an operator has different meanings for 
   operands of different types, we says that the operator is 
 overloaded. 
4. whenever we define a variable that contains the size of a 
   particular data structure, it is a good habit to use the type that 
   the library defines as being appropriate for that specific 
   purpose. (e.std::string::size_type , unsigned integral type that 
   can hold the size of any string) 
5. There are several ways in which trying to read from a stream can 
   be unsuccessful 
   * we might have reached the end of the input file(end-of-file). 
   * we might have encountered input that is incompatible with the 
     type of the variable that we are trying to read, such as might 
     happen if we try to read an int and find something that isn't a 
     number. 
   * the system might have detected a hardware failure on the input 
     device. 
6. if we define a nonconst reference---a reference that allows 
   writing, we can not make it refer to a const object or reference. 
   if the function paremeter is a const reference, we can call this 
   function on behalf of both const and nonconst object. 
   a reference parameter without a const usually signals an intent to 
   modify the object that is the function's argument. 
7. An lvalue is a value that denotes a nontemporary object. for 
   example, a variable is an lvalue, as is a reference, or the result 
   of calling a function that returns a reference. A expression that 
   genenates an arithmetic value, such as sum / count, is not an 
   lvalue, the result of calling a function that returns a local 
   variable is not an lvalue. 
8. A good rule of thumb is to avoid more than one side effect in a 
   single statement. 
9. A predicate is a function that yields a truth value, typically of 
   type bool. 
10. std::string spaces(greeting.size(), ' '); --> definition 
    string(maxlen + 1 - students[i].name.size(), ' '); --> expression 
 (operand);
    The expression constructs a nameless object of type string. this 
    expression is similar to the definition of spaces, but it omits 
    the name of the variable. this omission effectively turn the 
    definition into an expression 
    like the: new classname(para1, pare2, …) --→ operator operand 
11. we can optionally qualify a function definition with inline, the 
    compiler needs to be able to see the function definition, so 
    inlines are usually defined in header files, rather than in 
    source files.
12. Vector, which is optimized for fast random access. One price of 
    that optimization is that is can be expensive to insert or delete 
    elements other than at the end of the vector.
13. if we know that our program uses only those operations that a 
    particular type of container supports efficiently, then we can 
    make our program more efficient by using that kind of container.
14. An iterator is a value that
    * Identifies a container and an element in the container
    * Lets us examine the value stored in that element
   * Provides operations for moving between elements in the container
    * Restrict the available operations in ways that correspond to 
      what the container can handle efficiently
15. by calling the dereference operator, *.when applied to an 
    iterator, the * operator returns an lvalue that is the element to 
    which the iterator refers.
16. if students were a container that did not support random-access 
    indexing, it is likely that students.begin() would be of a type 
    that did not have + defined.
17. in fact, calling erase on a vector invalidates all iterators that
    refer to elements after the one that just erased.Fortunately, 
    erase returns an iterator that is positioned on the element that 
    follows the one that we just erased.
18. Just as vectors are optimized for fast random-access, lists are 
    optimized for fast insertion and deletion anywhere within the 
    container. Like a vector, a list is a container that can hold 
    objects of most any type. As we'll see, lists and vectors share 
    many operations, One key operation that vectors support, but 
    lists do not,is indexing
19. For lists, the erase and pushback operations do not invalidate 
 iterators to other elements(while vectors will). Only iterators 
 that refer to the element actually erased are invalidated, 
 because that element no longer exists.
20. if we need to use this type more than once, we start by defining
 a shorter synonym for this type use typedef.
21. A generic algorithm is an algorithm that is not part of any 
 particular kind of container, but instead takes a cue from its 
 arguments' types about how to access data it uses. like copy(). 
22. iterator adaptors, which are functions that yields iterators 
 with properties that are related to their arguments in useful 
 ways. Like backinserter().
23. although the string type does not support all of the container 
 operations, it does support iterators and indexing.
24. It's not easy to pass an overloaded function directly as an 
 argument to a template function. The trouble is that the compiler 
 doesn't know which version of the overloaded function we mean, 
 because we haven't supplied any argument that compiler might use 
 to select a version.
25. if a container supports indexing, so do its iterators.
26. Algorithm act on container elements–they do not act on containers
 if the function like erase change the size of container, the 
 function must be a member of container, because it acts directly 
 on the container, not just on its elements.
27.In the case of vectors and strings, operations such as erase or 
 insert also invalidate any iterator denoting elements after the 
 one erased or inserted.Because these operations can invalidate 
 iterators, we must be careful about saving iterator values if we 
 are using these operations.Similarly, function such as partition 
 or remove_if, which can move elements around within the container, 
 will change which element is denoted by particular iterators.After 
 running one of these functions, we cannot rely on an iterator 
 continuing to denote a specific element.
28. because associative container are self-ordering, our own program 
 must not do anything that changes the order of the elements. For 
 that reason, algorithms that change the contents of containers 
 often don't work for associative container.
29. Each element in a map is really a pair, with a first member that 
 contains the key and a second member that contains the 
 associatived value.
30. There is no built-in concatencation operation for vectors.
31. When you try to index a map with nonexistent key, it 
 automatically creates an element with that key. because using 
 [](indexes the map using a key) to access a map might create a 
 new element,so [] isn't defined on a const map.
32. Such a function that we do not know what function's argument or 
 result type will be until we use it is called a generic function. 
 The language feature that implements generic function is called 
 template function. The template parameter types are inferred from 
 the argument types.
33. Each iterator category(five) correspond to a strategy for 
 accessing container elements. Thus, the iterator category give us 
 a way to understand which containers can use which algorithms.
34. It is worth noting that the “write-once” property is a 
 requirement on programs that use iterators ,not on iterators 
 themselves.
35. generic function : the part that is inside the language is the 
 idea that the ways in which a function uses a parameter of 
 unknown type constrain that parameter's type.the part that is 
 outside the language is the way in which the standard library 
 organizes the constraints on its function's parameters.
36. The vector and string iterators are random-access iterators.(the 
 sort function use this), however, the list iterator is not, it 
 support only bidirectional iterators. So the only way to navigate 
 through a list is to look at each element in sequence.
37. when we say that find function requires input iterators as its 
 argument, we are saying that we can give find argument of any 
 type that meets the input-iterator requirements, including 
 iterators that support additional operations.
38. template < class T > T zero() { return 0;}
 defines zero to be a template function with single type parameter 
 , which is used to name the return type. In calling this 
 function, we must supply the return type explicitly. double x = 
 zero<double> ();
39. code that is intended for use by others should contain the 
 minimal number of declarations necessary.
40. There is no way to call the size function from class string 
 without nominating a string object.
41. Putting :: in front of a name insists on using a version of that 
 name that is not a member of anything.
42. Member function that are const may not change the internal state 
 of the object on which they are excuting.
43. As always, argument types must be identical between the function 
 declaration and definition.
44. constructors are special member functions that define how objects 
 are initialized.There is no way to call a constructor explicitly.
 Instead, creating an object of class type calls the appropriate 
 constructor automatically as a side effect. The constructor that 
 takes no arguments is known as the default constructor.
45. When we create a new class object, sequence steps happen:
 (1)The implements allocates memory to hold the object(stack/heap)
 (2)It initializes the object using initial values as specified
 in the initializer list.
 (3)It executes the constructor body.
 The constructor initializers initializes all data members(the
 other members are initializerd implicitly by corresponding 
 type's default constructor)even if the initializer list does not 
 mention the members at all.
46. One way to determine the right interface is to look at the kind 
 of programs we want our users to be able to write.
47. The explicit keyword makes sense only in the definition of a 
 constructor that takes a single argument. When we say that a 
 constructor is explicit, we're saying that the compiler will use 
 the constructor only in contexts in which the user expressly 
 invokes the constructor, and not otherwise.
 Vec<int> vi(100); //ok,explicit construct the Vec from an int
 Vec<int> vi = 100; //error:implicitly construct the Vec and copy 
 it to vi.
48. If the operator is defined as a member function, then its left 
 operand(if it is a binary operator)or its only operand(if it is
 a unary operator)is implicitly bound to the object on which the 
 operator is invoked.
49. The this keyword is valid only inside a member function, where it 
 denotes a pointer to the object on which the member function is 
 operating.For a binary operator, such as assigment, this is bound 
 to the left-hand operand.
50. It is important to note that if a class defines any constructor
 explicitly, even a copy constructor, then the compiler will not 
 synthesize a default constructor for that class. If the class 
 author does not specify these operations, the compiler synthesizes 
 default versions of the unspecified operations to operate 
 recursively---copying, assigning, or destroying each data element 
 according to the appropriate rules for the type of that 
 element(class or built-in)
51. Remember that objects may be created, copied or destroyed 
 implicitly.Whether implicitly or explicitly, the compiler will 
 involve the appropriate operation.
52. The new operator both allocates and initializes memory, when 
 used to allocate an array of type T, it needs the default 
 constructor for T; when used to allocate a object of type T with
 arguments, it needs the appropriate constructor for T. 
53. The <memory> header provides a class, called allocator<T>, that 
 allocates a block of uninitialized memory that is intended to 
 contain objects of type T, and return a pointer to the initial
 element of that memory.
54. constructors are involved as a side effect of creating or copying
 objects; the assignment operator is involved in expressions 
 involving assignment; and the destructor is run automatically 
 when objects are destroyed or go out of scope.
55. In general,a class that needs no destructor(the class itself does
 no memory allocation may be)doesn't need an explicit copy 
 constructor or assignment operator either.(rule of three)
56. To control how every object of class T deals with its resourses,
 you need
 T::T() one or more constructors, perhaps with arguments
 T::~T() the destructor
 T::T(const T &) the copy constructor
 T & T::operator=(const T &) the assignment operator
57. we suggested that one way to decide whether one function should 
 be a member of class was to ask whether the operation affects the 
 state of the object.But like the input operator certainly changes 
 its'object's state, however,we don't make it a member function.
58. A friend has the same access rights as a member. Classed can also
 be named friends.
59. like the assignment operator itself, all of the compound 
 assignment operators(like +=, -=, *=, /=)should be members 
 of class,then that the operator's left operand cannot be 
 the result of an automatic conversion(a temporary object).
60. In general, it is useful to make explicit the constructors that
 define the structure of the object being constructed, rather than
 its contents. Those constructors whose arguments become part of 
 the object usually should not be explicit.The compiler will not 
 use an explicit constructor to create objects implicitly by 
 converting operands in expression or function calls.
61. A class can define conversion in two ways: It can convert from
 other types to its type, or from its type to other types.
 User-defined conversions say how to transform to and from objects 
 of class type. some nonexplicit constructors may be 
 acts as a user-defined conversion.
62. Conversion operators must be defined as a member of a class,like
 class student_info {
 public:
 operator double() const;
 };
 would say how to create a double from a student_info object.the
 meaning of this conversion would depend on the definition of the
 operator
63. Conversion operators are most often useful converting from a 
 class type to a built-in type, but they can also be useful when
 converting to another class type for which we do not own the code
 if two classes define conversions to each other's types, 
 ambiguities can result.
64. The standard library defines a conversion from type istream to 
 void *(it's a pointer that can point to any type of object)(the
 class istream define operator void*),using a value of any
 arithmetic or pointer type automatically converts the value to 
 type bool.so we can write if (cin >> x) {}
65. Derived objects are constructed by
 * Allocating space for the entire object(base-class members as 
 well as derived members)
 * Calling the base-class constructor to initializer the 
 base-class parts of the object.(two steps)
 * Initializing the members of the derived class as directed by 
 the constructor initializer
 * Executing the body of the derived-class constructor, if any.
66. The virtual keyword may be used only inside the class definition. 
 it will determine which function to run at run time by
 inspecting each object that we pass an argument to function.
67. The phrase dynamic binding captures the notion that functions may
 be bound at run time(through a reference or pointer), as opposed 
 to static binding that happen at compile time(through a object). 
68. C++ supports polymorphism through the dynamic binding properties
 of virtual function.
69. The virtual functions must be defined, regardless of whether the
 program calls them .Nonvirtual functions may be declared but not
 defined, as long as the program does not call them.
70. The synthesized destructor will run the destructor for each data 
 element in the class.
71. a static member function is associated with class, not with a 
 particular object. As such, they cannot access the nonstatic data
 members of objects of the class.Their names are within the scope
 of their class.
72. Ordinarily, when a derived class redefines a function from the 
 base class, it does so exactly:the parameter list and the return
 type are identical.However, if the base-class function returns a 
 pointer(or reference)to a base class, then the derived-class 
 function can return a pointer(or reference) to a corresponding 
 derived class.
73. It is important to realize that when a base- and derived-class 
 function have the same name, but they don't match exactly in 
 number and types of parameters ,they behave as if they were
 completely unrelated functions.
74. If a pointer to the base class is used to delete an object that
 might actually be a derived-class object, then the base class
 needs a virtual destructor. It's inherited by the derived classes
 and there is no need to redefine the destructor in the derived 
 classes.
75. calls to virtual function from inside a constructor are 
 statically bound to the version for the type being constructed.
76. Using pointers leading to pitfalls:
 *Copying a pointer does not copy the corresponding object,leading
 to surprises if two pointers inadvertently point to the 
 same object.
 *Destroying a pointer does not destroy its object, leading to
 memory leak.
 *Deleting an object without destroying a pointer to it leads to a 
 dangling pointer, which also causes undefined behaviour if the 
 program uses the pointer.
 *Creating a pointer without initializing it leaves the pointer 
 unbound, which also causes undefined behaviour if the 
 program use it.
77. template<> at the beginning of the function indicates that the 
 function is a template specialization. Such specializations 
 defines a particular version of a template function for the
 specific argument type.
78. Remember that conversions are not applied to the left operand of 
 the . Operator 
79. The way that we specify that we don't intend to implement a 
 virtual function is to say = 0. Doing so makes it a pure virtual
 function. By giving a class even a single pure virtual function,
 we are also implicitly specifying that there will never be 
 objects of that class. Such classes are called abstract base 
 classes, because they exist only to capture an abstract interface
 for an inheritance hierarchy. They are purely abstract: There are 
 no objects of that base class itself. Once we give a class any 
 pure virtuals, the compiler will enforce our design by preventing 
 us from creating any objects of an abstract class.
80. As with virtual itself, the fact that a function is pure virtual
 is inherited. If a derived class defines all of its inherited 
 pure virtual functions. It becomes a concrete class, and we can 
 create objects of that class.
81. It is important to realize that abstract classes may define data
 members, and(ordinary)member functions, as well as static ones. 
 These functions will access the base-class objects that are part 
 of derived objects.
82. Static members(both functions and data members)are useful in that
 they let us minimize the names that are defined globally.
83. A member of a derived class can access the protected members of 
 the base-class parts of objects of its own class, or of other
 classes derived from it, but it cannot access the protected 
 members of base-class objects that stand alone----that is , that
 are not part of a derived-class object.

 :         ,      ,       .