"C + + Primer" Part II: C + + standard library

"C + + Primer" Part II: C + + standard library

Objective

Read the "C + + Primer" Reading a series of notes. This article is part II of the C + + standard library, including the 8th to 12th chapter of the book The Difficult points:

1. IO Library
2. Sequential container
3. Model algorithm
4. Associative containers
5. Dynamic memory

See the GitHub warehouse Cpp-primer-workbook after the revised course.

IO Library

1. Io class inheritance mechanism: Ifstream and istringstream inherit from Istream,ofstream and Ostringstream inherit from Ostream
2. Wide character Io class: prefix the function and type with W, such as Wcin, Wistream
3. No copy assignment of Io object: The function of IO operation is usually passed and returned by reference; The reference to the IO object cannot be const because the read-write changes State
4. Condition State: Iostate represents the type of stream state, which contains 4 constexpr values, Badbit (stream crash), Failbit (recoverable error), Goodbit, eofbit, corresponding 4 function bad (), fail (), good (), EOF ()
5. Manage condition Status: Rdstate () Get status, clear () Clears all error flag bits, clear (flags) and SetState (flags) set status to Flags
6. Flush output buffers: You can use the operator Endl (newline), flush, ends (null character), turn on unitbuf each call flush,nounitbuf dismiss
7. Correlation Flow: An interactive system typically associates input and output streams so that all outputs are printed before the read operation; Each stream is associated with at most one stream, but multiple streams can be associated to the same ostream; associating them to a null pointer can completely unlock the association
8. FStream: Open () opening the file-bound stream, close () closing the binding file, successful opening of the file, and Is_open () not yet closed
9. StringStream unique: Str (s) that copies s to the StringStream object, returns a copy of the saved string str ()

Sequential container

2. Select containers: Standard library container performance is generally better than similar data structures; the C + + standard adds array arrays and forward_list one-way lists; lots of small elements and extra space overhead, no list or forward_list
4. Additional Operations for containers: iterator represents iterator type, size_type unsigned integer, value_type refers to element type, reference and value_type& equivalent
6. Size operation: Returns the number of elements in the container; forward_list no size operation, the size operation of the other container is a constant time
8. Reverse container: reverse_iterator An iterator addressed in reverse order, Rbegin () is a tail iterator, crend () represents a const first-forward iterator,
10. Forward_list: Reverse container iterator not supported and its iterator does not support decrement operation
12. Container initialization: Must be the same container type and save elements of the same type
14. Initialize with size: Only the constructor of the sequential container accepts the size parameter, and the associated container does not support
16. Array: Has a fixed size, the number of list initializations must be equal to or less than the size of the array; curly braces list can only initialize cannot be assigned value
18. Assign: Only sequential container support, the iterator passed to assign cannot point to the container that calls assign; causes an iterator, reference, pointer invalidation to point to the container;
20. Swap: In addition to array, swap does not copy, delete, and insert any elements to ensure constant time is complete; iterators, references, and pointers to other containers do not expire after the swap except string
22. Relational operators: Operands on both sides must be of the same container type and hold elements of the same type
24. Insert element: An iterator that returns the newly added first element, inserts an element into a vector, string, deque, invalidates a pointed iterator, reference, pointer, or inserts an element in the range represented by the iterator and cannot point to the same container as the destination
26. An element is a copy: When you initialize or insert a container with an object, you actually put a copy, and the element in the container is not associated with the object that provides the value
28. Access elements: the at and subscript operations only support string, vector, deque, array; the Access member function returns a reference
30. Delete element: Clear and Pop return Void,erase returns an iterator that points to the element after the last deleted element
32. Special Forward_list operation: Add or remove by changing the element after the given element to complete, define the first front iterator before_begin (); Insert_after () returns the iterator that points to the last inserted element; Erase_after () Returns an iterator that points to the element following the deleted element
34. Change the container size: Resize () can be used to increase or decrease the container, the extra element is removed, and the specified value or default initializer object is filled.

36. Iterator invalidation: Adding or removing elements may invalidate pointers, references, iterators that point to container elements

    	add element	Delete element
    Vector, string	The storage space is not reassigned, then the insertion position is invalidated;	Deleted elements and subsequent invalidation
    Deque	Only iterators expire at the end of the add-in;	Delete the first element only the first element is invalid, the tail element is deleted after the end of the iterator is also invalid;
    List, forward_list	does not affect	Only deleted elements are affected

38. Do not save tail iterator: Insert Delete deque, string, vector element in loop, should call end () every time
40. Manage container size: Capacity () returns the size of the container's reserved memory, the empty container returns 0;reverse () only increases the container's reserved memory size; Reduces the amount of space available shrink_to_fit () requests the space value to be reduced to the number of elements, but does not guarantee that the memory space must be returned
42. Reallocate Memory: If size and capacity are equal when the insert is executed, or if resize, reserve a given size exceeds capacity,vector, the new memory space will be allocated, depending on the underlying implementation
44. Modify the parameters that are allowed by string:replace and insert args depend on how range range and location POS are specified
46. String::npos:string the static member returned by the search failure, the type is const String::size_type, initialized to-1
48. String search: Find () first occurrence, rfind () Last occurrence, find_first_of () The first occurrence of any character in the parameter (), Find_last_not_of () The last occurrence of a character in a non-argument; Not found return NPOs
50. String numeric conversions: s=to_string(val); val = stoi(s, p, b); Val can be any arithmetic type, the corresponding Stoi function is replaced with STOL, Stod, and so on, p represents the index at which the string starts to convert, and B represents the cardinality used for the conversion
52. Container adapter: The container adapter accepts an existing container type so that its behavior looks like a different type
54. Underlying container: Stack and queue default based on Deque,priority_queue vector-based, cannot use an array that cannot add deleted elements, or cannot access the forward_list of the tail element as the underlying container Stack can be constructed with any container other than array and forward_list, and queue may use list or Deque,priority_queue to be based on a vector or deque
56. Adapter operation: Each adapter defines its own special action based on the operation of the underlying container type, only using the adapter operation, not using the underlying container operation

Model algorithm

2. Model algorithm: Implements the common interface of some classical algorithms, can be used for different types of elements, multiple types of containers, other types of sequences
4. Iterators and algorithms: The algorithm works on the iterator, which makes the algorithm independent of the container, but relies on the operation of the element type; the algorithm never performs container operations, so it does not change the size of the underlying container
6. Input range: The standard library algorithm typically operates on a range of elements, with two iterator parameters representing left closed right open intervals
8. Algorithm classification: Whether to read elements, change elements, rearrange element order
10. Read-only algorithm: read without changing the element, preferably with a const iterator; If you plan to change the value of an element by using an iterator returned by the algorithm, you pass the very constant parameter
12. Write algorithm: The algorithm does not check the write operation, all assume that the destination space is large enough, common errors have fill_n or other write operations on the empty container just defined, and ensure that the algorithm has enough element space to accommodate the output available insert iterator
14. Iterator parameters: Some algorithms read two sequences, do not require strict matching of container or element type, only require elements in two sequences to compare
16. Copy algorithm: Copy returns the value of the destination iterator (increment), multiple algorithms provide a "copy" version, accept an additional purpose iterator parameter, copy the new sequence to the inside without altering the sequence of the original input range
18. Reflow algorithm: The way to remove duplicate elements of a container is to first call the rearrangement algorithm sort and unique, and then use the container to manipulate erase
20. Custom actions: The algorithm uses the < or = = Operator By default, but allows us to pass any type of callable object, using custom actions instead of the default operator
22. Callable objects: Functions, function pointers, classes that overload the function call (), lambda expressions
24. predicate: Returns a function that can be converted to bool, typically used to determine an element relationship, divided into a unary predicate and a two-tuple predicate based on the number of accepted parameters
26. Lambda expression: [Capture list] (parameter list), return type {function body}; parameter list and return type can be omitted at some time; cannot have default parameters
28. Capture list: Just capture local non-static variables, divided into value capture and reference capture; The value of the variable captured by the value is a copy of the lambda creation, to change the need to add the mutable keyword after the parameter list; Reference capture to ensure that the variable still exists when the lambda executes, whether it is mutable by a constant reference
30. Implicit capture: Let the compiler infer which variables to use based on the code in the lambda body, use & or = parameters to represent reference captures or value captures, and mix implicit and explicit captures in a different way
32. Lambda returns: The lambda Body contains only one return statement to omit the return type, otherwise the lambda defaults to return void, and the return type must be specified
34. Bind function: Auto newcallable = bind (callable, arg_list); The parameters passed to Newcallable are passed to arg_list in the order of the placeholder parameters in callable
36. Placeholder: Shaped like _n,n is an integer; defined in std::p laceholders namespace
38. Binding reference Parameters: Parameters of bind that are not placeholders are copied to the callable object by default, and you want to pass it to bind an object without copying it, you must define it in the header file functianal using ref or Cref;bind, placeholders, ref.
40. Insert iterators: Back_inserter, Inserter, Front_inserter call container operations push_back, INSERT, Push_front;*it, ++it, it++ return it
42. Stream iterator: treats the corresponding stream as a sequence of elements of a particular type; Istream_iterator input, ostream_iterator output
44. Istream_iterator: An empty istream_iterator can be used as a trailing iterator; compare two istream_iterator if equality must read the same type, if both are trailing iterators or bound to the same input is equal
46. Ostream_iterator:It, ++it, it++ all return to it; It is recommended to be consistent with the use of other iterators and easier to modify in the future
48. Reverse iterator: rbegin points to the tail element, rend to the first element, the increment operation to the previous element, and the base operation of the reverse iterator to the normal iterator, but the forward and backward iterators point to different elements when they convert to each other.
50. The iterator required by the algorithm: input iterator, output iterator, forward iterator, bidirectional iterator, random access iterator, C + + standard indicates the minimum class for each iterator parameter of the algorithm, but the compiler usually does not report the error
52. Algorithm naming: An algorithm that accepts predicates to override default operators, or that does not accept additional parameters, is usually overloaded, and an algorithm that accepts predicates to replace element values has additional _if, such as find_if, and additional _copy, such as Replace_copy, that are copied to the extra space, and some algorithms provide Copy and _if, such as remove_copy_if
54. Linked list algorithm: List and forward_list have their own function members sort, merge, remove, reverse, unique, can change the underlying container, prefer to use them instead of the general algorithm
56. Splice Member: A list-specific algorithm that moves one section of a linked list to a specified position in another list, to ensure that the destination of the move is not within the range to be moved

Associative containers

2. Associative container classification: set or map, whether the keyword is duplicated, whether the keyword is ordered or not
4. Associative containers: List initialization, no support for location-related operations, no support for parameters for element values and corresponding number of constructs or inserts; Iterators are bidirectional
6. Ordered containers: The keyword type must define a comparison method, using the < operator by default, to customize a strict weak-order
8. Strict weak order: not at the same time "less than equals" the other side; "Less than equals" has transitivity; both sides are not "less than equals" the other party is called "equivalence", "equivalence" has transitivity
10. Pair type: An initializer surrounded by curly braces to return objects of type pair, older versions only allow explicit construction
12. Associative container iterator: Map Value_type is Pair<const key_type, mapped_type> So the map iterator can only change the value of the keyword map, cannot modify the keyword; set value_type equals Key_ Type, which is a const keyword and cannot be modified
14. Associative container insert: inserted only if the keyword does not exist, the function returns a pair that contains an iterator to the element, and a bool type that indicates whether the insert succeeded
16. Associative container erase: If an iterator is passed in, it must be guaranteed to point to the real element, and if the keyword is passed in, returns the number of all elements of that keyword that were deleted.
18. Map subscript Operation: Map subscript operation returns Mapped_type, dereference return value_type; If the keyword does not already exist, it will create a new element that has a corresponding keyword with a value of 0, which already exists to return the most recently assigned value; only for maps and UNORDERS_MAP
20. Find elements: Find (first equals iterator), count (number), Lower_bound (first iterator with less than equals), Upper_bound (first greater than iterator), Equal_range (returns an iterator pair, Represents all equal heads and trailing positions)
22. Unordered associative containers: Using the keyword's hash function and the = = operator, you cannot directly define an unordered container with a keyword type of custom class type, you must provide your own hash template version, or in another way, a default comparison operation similar to an ordered container overload keyword type
24. Manage buckets: Unordered containers are organized as a set of buckets on storage, each bucket holds several elements of the same hash value; the performance of unordered containers depends on the quality of the hash function and the number and size of the buckets; functions for managing buckets include bucket interfaces, bucket iterations, hash policies

Dynamic memory

2. Dynamic Memory: In addition to static memory and stack memory, each program has free space (heap) for storing dynamically allocated objects, objects allocated in free space are not destroyed until explicit release or program end
4. Smart pointer: Automatically releases the objects that are pointed to and the memory occupied by the object; shared_ptr can point to an object, Unique_ptr exclusive to the object; Smart pointers do not support pointer arithmetic operations
6. Reference count: shared_ptr associated counter, increment at copy shared_ptr, decrement at assignment or destroy, 0 automatically release Management object
8. Scenarios using dynamic Memory: No knowledge of the number of objects, exact types of objects, shared data between multiple objects
10. Direct Memory management: New allocates memory, delete release, cannot depend on the default definition of class object copy, assignment, destroy; built-in type is default initialized to undefined, it is recommended to initialize directly with parentheses, and auto can only be used if there is only a single initializer in parentheses
12. The dynamically allocated const:new assigns the const object to be legal, its value cannot be changed, but itself can be destroyed by the delete
14. Null-dangling pointer: A pointer to a piece of memory that once saved the data object but is now invalid, and the delete pointer becomes a null-dangling pointer, which is suggested to be assigned a value with nullptr
16. Initialize the smart pointer: cannot do the built-in pointer to the smart pointer implicit conversion, must use the direct initialization form; The smart pointer uses the delete release by default, so the normal pointer used to initialize the smart pointer must point to dynamic memory, and the managed resource is not the new allocated memory. You must pass in a filter instead of the delete
18. Mix smart pointers and normal pointers: shared_ptr binds a normal pointer and should not use a built-in pointer to access the memory; You can use get to pass access to code when you are sure that the code does not delete the pointer, do not use get to initialize or assign a value to another smart pointer
20. Modify the Shared_ptr Shared object: Call unique when changing the underlying object to determine if it is a user only, and if not, make a new copy with reset
22. Unique_ptr: Normal Copy or assignment is not supported, but can be copied or assigned to a unique_ptr that is about to be destroyed, such as a function return value; Call release or reset transfers the ownership of the pointer from one non-const unique_ptr to another Unique_ PTR, call reset () or assign a value with nullptr to release the object, release will only sever the management relationship
24. Unique_ptr: Unlike share_ptr, the removal device affects the type and construction process, and the overload-removing device must indicate the type of the delete in the angle brackets and specify a callable object (the delete) in the parameter list
26. WEAK_PTR: is a weak reference to a shared_ptr object, but does not change the reference count; Call lock returns a pointer to the SHARED_PTR object when the object counter is 0 o'clock returns null shared_ptr
28. Assign a dynamic array: Use new t[] to allocate a specified amount of memory, return an element type pointer instead of an array, use empty brackets or curly braces to initialize arrays, but you cannot have an initializer in parentheses, so you cannot use auto; You can allocate an array of 0 lengths, and the returned pointer resembles a trailing pointer
30. Releasing the dynamic array: delete [] release, empty square brackets are required, otherwise there will be no warning but the behavior is abnormal
32. Smart pointers to Dynamic arrays: Unique_ptr manages the array of new allocations, followed by an empty parenthesis after the object type in the angle brackets, and cannot use the dot or arrow operators to access the elements in the array using the subscript operator; shared_ptr cannot manage dynamic arrays directly, you must provide your own delete , and you can access the array element only by using the pointer arithmetic operation with the get built-in pointer
34. Allocator class: Allocate allocates the original, non-constructed memory of a certain size, and the deallocate parameter must be the pointer returned by allocate and the size of the allocate passed in, and Deallocate is called before destroy destructors each object created. Allocate call Cnostruct construct object, or call Uninitialized_copy[_n] Copy object, or Uninitialized_fill[_n] to populate uninitialized memory

Reprint please indicate the source

"C + + Primer" Part II: C + + standard library