TheC++StandardLibraryATutorialandReference(2ndEdition)_c++11标准库

STL

1星需积分: 9 106 浏览量更新于2023-05-25 评论收藏 7.54MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源评论

资源推荐

ptg7913098

7.3 Ve c t o r s 271

Ve c t o r s provide the usual size operations size(), empty(), and max_size() (see Section 7.1.2,

page 254). An additional “size” operation is the capacity() function, which returns the number of

elements a vector could contain in its actual memory. If you exceed the capacity(), the vector has

to reallocate its internal memory.

The capacity of a vector is important for two reasons:

1. Reallocation invalidates all references, pointers, and iterators for elements of the vector.

2. Reallocation takes time.

Thus, if a program manages pointers, references, or iterators into a vector , or if speed is a goal, it is

important to take the capacity into account.

To avoid reallocation, you can use reserve() to ensure a certain capacity before you really need

it. In this way , you can ensure that references remain valid as long as the capacity is not exceeded:

std::vector<int> v; // create an empty vector

v.reserve(80); // reserve memory for 80 elements

Another way to avoid reallocation is to initialize a vector with enough elements by passing additional

arguments to the constructor. For example, if you pass a numeric value as parameter, it is taken as

the starting size of the vector:

std::vector<T> v(5); // creates a vector and initializes it with ﬁve values

// (calls ﬁve times the default constructor of type T)

Of course, the type of the elements must provide a default constructor for this ability. For fundamen-

tal types, zero initialization (see Section 3.2.1, page 37) is guaranteed. But note that for complex

types, even if a default constructor is provided, the initialization takes time. If the only reason for

initialization is to reserve memory, you should use reserve().

The concept of capacity for vectors is similar to that for strings (see Section 13.2.5, page 669),

with one big difference: Unlike for strings, it is not possible to call reserve() for vectors to shrink

the capacity. Calling reserve() with an argument that is less than the current capacity is a no-op.

Furthermore, how to reach an optimal performance regarding speed and memory use is implementa-

tion deﬁned. Thus, implementations might increase capacity in larger steps. In fact, to avoid internal

fragmentation, many implementations allocate a whole block of memory (such as 2K) the ﬁrst time

you insert anything if you don’t call reserve() ﬁrst yourself. This can waste a lot of memory if

you have many vectors with only a few small elements.

Because the capacity of vectors never shrinks, it is guaranteed that references, pointers, and

iterators remain valid even when elements are deleted, provided that they refer to a position before

the manipulated elements. However, insertions invalidate all references, pointers, and iterators when

the capacity gets exceeded.

C++11 introduced a new member function for vectors: a nonbinding request to shrink the capac-

ity to ﬁt the current number of elements:

v.shrink_to_fit(); // request to shrink memory (since C++11)

This request is nonbinding to allow latitude for implementation-speciﬁc optimizations. Thus, you

cannot expect that afterward v.capacity==v.size() yields true.

Before C++11, there you could shrink the capacity only indirectly: Swapping the contents with

another vector swaps the capacity. The following function shrinks the capacity while preserving the

elements:

将vector所有元素拷贝到新的内存空间

ptg7913098

274 Chapter 7: STL Containers

Operation Effect

c = c2 Assigns all elements of c2 to c

c = rv

Move assigns all elements of the rvalue rv to c (since C++11)

c = initlist

Assigns all elements of the initializer list initlist to c (since

C++11)

c.assign(n,elem)

Assigns n copies of element elem

c.assign(beg,end)

Assigns the elements of the range [beg,end)

c.assign(initlist)

Assigns all the elements of the initializer list initlist

c1.swap(c2)

Swaps the data of c1 and c2

swap(c1,c2)

Swaps the data of c1 and c2

Table 7.11. Assignment Operations of Vect o r s

(containers, arrays, standard input) similar to those described for constructors (see Section 7.1.2,

page 254). All assignment operations call the default const ructo r, copy constructor, assignment

operator, and/or destructor of the element type, depending on how the number of elements changes.

For example:

std::list<Elem> l;

std::vector<Elem> coll;

...

// make coll be a copy of the contents of l

coll.assign(l.begin(),l.end());

Element Access

To access all elements of a vector , you must use range-based for loops (see Section 3.1.4, page 17),

speciﬁc operations, or iterators. Table 7.12 shows all vector operations for direct element access. As

usual in C and C++, the ﬁrst element has index 0, and the last element has index size()-1. Thus,

the nth element has index n-1. For nonconstant vectors, these operations return a reference to the

element. Thus, you could modify an element by using one of these operations, provided it is not

forbidden for other reasons.

Operation Effect

c[idx] Returns the element with index idx (no range checking)

c.at(idx)

Returns the element with index idx (throws range-error exception

if idx is out of range)

c.front()

Returns the ﬁrst element (no check whether a ﬁrst element exists)

c.back()

Returns the last element (no check whether a last element exists)

Table 7.12. Direct Element Access of Ve c tor s

The most important issue for the caller is whether these operations perform range checking.

Only at() performs range checking. If the index is out of range, at() throws an out_of_range

ptg7913098

7.3 Ve c t o r s 275

exception (see Section 4.3, page 41). All other functions do not check. A range error results in

undeﬁned behavior. Calling operator [ ], front(), and back() for an empty container always

results in undeﬁned behavior:

std::vector<Elem> coll; // empty!

coll[5] = elem; // RUNTIME ERROR ⇒ undeﬁned behavior

std::cout << coll.front(); // RUNTIME ERROR ⇒ undeﬁned behavior

So, you must ensure that the index for operator [ ] is valid and that the container is not empty when

either front() or back() is called:

std::vector<Elem> coll; // empty!

if (coll.size() > 5) {

coll[5] = elem; // OK

}

if (!coll.empty()) {

cout << coll.front(); // OK

}

coll.at(5) = elem; // throws out_of_range exception

Note that this code is OK only in single-threaded environments. In multithreaded contexts, you need

synchronization mechanisms to ensure that coll is not modiﬁed between the chec k for its size and

the access to the element (see Section 18.4.3, page 984, for details).

Iterator Functions

Ve c t o r s provide the usual operations to get iterators (Table 7.13). Vector iterators are random-access

iterators (see Section 9.2, page 433, for a discussion of iterator categories). Thus, in principle you

could use all algorithms of the STL.

The exact type of these iterators is implementation deﬁned. For vectors, however, the iterators

returned by begin(), cbegin(), end(), and cend() are often ordinary pointers, which is ﬁne

because vectors usually use a C-style array for the elements and ordinary pointers provide the inter-

face of random-access iterators. However, you can’t count on the fact that the iterators are ordinary

pointers. For example, if a safe version of the STL that checks range errors and other potential prob-

lems is used, the iterator type is usually an auxiliary class. See Section 9.2.6, page 440, for a nasty

difference between iterators implemen ted as pointers and iterators implemented as classes.

Iterators remain valid until an element with a smaller index gets inserted or removed or until

reallocation occurs and capacity changes (see Section 7.3.1, page 270).

Inserting and Removing Elements

Table 7.14 shows the operations provided for vectors to insert or to remove elements. As usual when

using the STL, you must ensure that the arguments are valid. Iterators must refer to valid positions,

and the beginning of a range must have a position that is not behind the end.

剩余1189页未读，继续阅读

chyx555

2018-10-12

差评！！不全，从第7.3节开始，还到处是标注！

xuhaoee

粉丝: 0
资源: 4

会员权益专享

The C++ Standard Library A Tutorial and Reference (2nd Edition)

评论1

会员权益专享

最新资源

The C++ Standard Library A Tutorial and Reference (2nd Edition)

评论1

C++11标准发布文档

The C++ Standard Library 2nd Edition(高清)pdf

The C++ Standard Library A Tutorial and Reference 2nd Edition

c++ standard library, the: a tutorial and reference pdf 下载

给我一些学习c++stl的教程

metal.programming.guide.tutorial.and.reference.via.swift

基于JSP动态网页开发近七年的参考文献

tutorial and manual汉化

information theory and statistics: a tutorial csdn

6-dof robot abb irb 1200 - a tutorial in matlab and simulink

161204_mastering_the_freertos_real_time_kernel-a_hands- on_tutorial_guide

object has no attribute 'execute_script'

opengl weiler-atherton code

[4]Shlens J. A Tutorial on Principal Component Analysis[J]. arXiv preprint arXiv:1404.1100, 2014.的标准文献参考名

STA Basic Tutorial

opencv c++ 教程 中文

Hooks¶ Tutorial: Writing plugins Reference to all hooks which can be implemented by conftest.py files and plugins. 翻译

哪本书适合学习Cpp的STL库呢

会员权益专享

最新资源

opencv c++ 教程中文