Perhaps you are already using C++ as your main programming language to solve TopCoder problems. This means that you have already used STL in a simple way, because arrays and strings are passed to your function as STL objects. You may have noticed, though, that many coders manage to write their code much more quickly and concisely than you.
Or perhaps you are not a C++ programmer, but want to become one because of the great functionality of this language and its libraries (and, maybe, because of the very short solutions you've read in TopCoder practice rooms and competitions).
Regardless of where you're coming from, this article can help. In it, we will review some of the powerful features of the Standard Template Library (STL) – a great tool that, sometimes, can save you a lot of time in an algorithm competition.
The simplest way to get familiar with STL is to begin from its containers.
Containers
Any time you need to operate with many elements you require some kind of container. In native C (not C++) there was only one type of container: the array.
The problem is not that arrays are limited (though, for example, it’s impossible to determine the size of array at runtime). Instead, the main problem is that many problems require a container with greater functionality.
For example, we may need one or more of the following operations:
If not, we can develop the interface for such a container once, and then use everywhere for data of any type. That, in short, is the idea of STL containers.
Before we begin
When the program is using STL, it should #include the appropriate standard headers. For most containers the title of standard header matches the name of the container, and no extension is required. For example, if you are going to use stack, just add the following line at the beginning of your program:
The simplest STL container is vector. Vector is just an array with extended functionality. By the way, vector is the only container that is backward-compatible to native C code – this means that vector actually IS the array, but with some additional features.
Another very popular function to use in vector is push_back. Push_back adds an element to the end of vector, increasing its size by one. Consider the following example:
When you need to resize vector, use the resize() function:
Note that if you use push_back() after resize(), it will add elements AFTER the newly allocated size, but not INTO it. In the example above the size of the resulting vector is 25, while if we use push_back() in a second loop, it would be 30.
vector
<
int
>
v(
20
);
for
(
int
i
=
0
; i
<
20
; i
++
) ...
{
v[i] = i+1;
}
v.resize(
25
);
for
(
int
i
=
20
; i
<
25
; i
++
) ...
{
v.push_back(i*2); // Writes to elements with indices [25..30), not [20..25) !
}
To clear a vector use clear() member function. This function makes vector to contain 0 elements. It does not make elements zeroes -- watch out -- it completely erases the container.
There are many ways to initialize vector. You may create vector from another vector:
If you want to create a vector of specific size, use the following constructor:
Multidimensional arrays are very important. The simplest way to create the two-dimensional array via vector is to create a vector of vectors.
The simplest way to add data to vector is to use push_back(). But what if we want to add data somewhere other than the end? There is the insert() member function for this purpose. And there is also the erase() member function to erase elements, as well. But first we need to say a few words about iterators.
You should remember one more very important thing: When vector is passed as a parameter to some function, a copy of vector is actually created. It may take a lot of time and memory to create new vectors when they are not really needed. Actually, it’s hard to find a task where the copying of vector is REALLY needed when passing it as a parameter. So, you should never write:
void
some_function(vector
<
int
>
v) ...
{ // Never do it unless you’re sure what you do!
// ...
}
Instead, use the following construction:
Before we come to iterators, let me say a few words about pairs. Pairs are widely used in STL. Simple problems, like TopCoder SRM 250 and easy 500-point problems, usually require some simple data structure that fits well with pair. STL std::pair is just a pair of elements. The simplest form would be the following:
For example, if you want to sort the array of integer points so that they form a polygon, it’s a good idea to put them to the vector< pair<double, pair<int,int> >, where each element of vector is { polar angle, { x, y } }. One call to the STL sorting function will give you the desired order of points.
Pairs are also widely used in associative containers, which we will speak about later in this article.
Iterators
What are iterators? In STL iterators are the most general way to access data in containers. Consider the simple problem: Reverse the array A of N int’s. Let’s begin from a C-like solution:
But look: the second code can work for ANY pointer-like object. The only restriction is that that object can perform the operations described above: take value (unary *), comparison (<), and increment/decrement (++/--). Objects with these properties that are associated with containers are called iterators. Any STL container may be traversed by means of an iterator. Although not often needed for vector, it’s very important for other container types.
So, what do we have? An object with syntax very much like a pointer. The following operations are defined for iterators:
And the main advantage of iterators, of course, is that they greatly increase the reuse of code: your own algorithms, based on iterators, will work on a wide range of containers, and your own containers, which provide iterators, may be passed to a wide range of standard functions.
Not all types of iterators provide all the potential functionality. In fact, there are so-called "normal iterators" and "random access iterators". Simply put, normal iterators may be compared with ‘==’ and ‘!=’, and they may also be incremented and decremented. They may not be subtracted and we can not add a value to the normal iterator. Basically, it’s impossible to implement the described operations in O(1) for all container types. In spite of this, the function that reverses array should look like this:
Let's return to the STL. STL algorithms always use two iterators, called "begin" and "end." The end iterator is pointing not to the last object, however, but to the first invalid object, or the object directly following the last one. It’s often very convenient.
Each STL container has member functions begin() and end() that return the begin and end iterators for that container.
Based on these principles, c.begin() == c.end() if and only if c is empty, and c.end() – c.begin() will always be equal to c.size(). (The last sentence is valid in cases when iterators can be subtracted, i.e. begin() and end() return random access iterators, which is not true for all kinds of containers. See the prior example of the double-linked list.)
The STL-compliant reverse function should be written as follows:
In addition, any object with enough functionality can be passed as an iterator to STL algorithms and functions. That is where the power of templates comes in! See the following examples:
Furthermore, we can even use the following constructions:
Here is an example of reverse() function:
To create an iterator object, we must specify its type. The type of iterator can be constructed by a type of container by appending “::iterator”, “::const_iterator”, “::reverse_iterator” or “::const_reverse_iterator” to it. Thus, vector can be traversed in the following way:
Now you know of STL algorithm reverse(). Many STL algorithms are declared in the same way: they get a pair of iterators – the beginning and end of a range – and return an iterator.
The find() algorithm looks for appropriate elements in an interval. If the element is found, the iterator pointing to the first occurrence of the element is returned. Otherwise, the return value equals the end of interval. See the code:
The min_element and max_element algorithms return an iterator to the respective element. To get the value of min/max element, like in find(), use *min_element(...) or *max_element(...), to get index in array subtract the begin iterator of a container or range:
int
data[
5
]
=
{ 1, 5, 2, 4, 3 }
;
vector
<
int
>
X(data, data
+
5
);
int
v1
=
*
max_element(X.begin(), X.end());
//
Returns value of max element in vector
int
i1
=
min_element(X.begin(), X.end()) – X.begin;
//
Returns index of min element in vector
int
v2
=
*
max_element(data, data
+
5
);
//
Returns value of max element in array
int
i3
=
min_element(data, data
+
5
) – data;
//
Returns index of min element in array
Now you may see that the useful macros would be:
Another good algorithm is sort(). It's very easy to use. Consider the following examples:
vector
<
int
>
X;
//
...
sort(X.begin(), X.end());
//
Sort array in ascending order
sort(all(X));
//
Sort array in ascending order, use our #define
sort(X.rbegin(), X.rend());
// Sort array in descending order using with reverse iterators
Compiling STL Programs
One thing worth pointing out here is STL error messages. As the STL is distributed in sources, and it becomes necessary for compilers to build efficient executables, one of STL's habits is unreadable error messages.
For example, if you pass a vector<int> as a const reference parameter (as you should do) to some function:
Traversing macros is not really necessary for vectors, but it’s very convenient for more complex data types, where indexing is not supported and iterators are the only way to access data. We will speak about this later in this article.
Data manipulation in vector
One can insert an element to vector by using the insert() function:
vector
<
int
>
v;
vector
<
int
>
v2;
//
..
//
Shift all elements from second to last to the appropriate number of elements.
//
Then copy the contents of v2 into v.
v.insert(
1
, all(v2));
Vector also has a member function erase, which has two forms. Guess what they are:
The insert/erase technique is common, but not identical for all STL containers.
See next: Power up C++ with STL: Part II (string, set, map)
width="728" scrolling="no" height="90" frameborder="0" align="middle" src="http://download1.csdn.net/down3/20070601/01184120111.htm" marginheight="0" marginwidth="0">
Or perhaps you are not a C++ programmer, but want to become one because of the great functionality of this language and its libraries (and, maybe, because of the very short solutions you've read in TopCoder practice rooms and competitions).
Regardless of where you're coming from, this article can help. In it, we will review some of the powerful features of the Standard Template Library (STL) – a great tool that, sometimes, can save you a lot of time in an algorithm competition.
The simplest way to get familiar with STL is to begin from its containers.
Containers
Any time you need to operate with many elements you require some kind of container. In native C (not C++) there was only one type of container: the array.
The problem is not that arrays are limited (though, for example, it’s impossible to determine the size of array at runtime). Instead, the main problem is that many problems require a container with greater functionality.
For example, we may need one or more of the following operations:
- Add some string to a container.
- Remove a string from a container.
- Determine whether a string is present in the container.
- Return a number of distinct elements in a container.
- Iterate through a container and get a list of added strings in some order.
If not, we can develop the interface for such a container once, and then use everywhere for data of any type. That, in short, is the idea of STL containers.
Before we begin
When the program is using STL, it should #include the appropriate standard headers. For most containers the title of standard header matches the name of the container, and no extension is required. For example, if you are going to use stack, just add the following line at the beginning of your program:
Container types (and algorithms, functors and all STL as well) are defined not in global namespace, but in special namespace called “std." Add the following line after your includes and before the code begin:
Another important thing to remember is that the type of a container is the template parameter. Template parameters are specified with the ‘<’/’>’ "brackets" in code. For example:
When making nested constructions, make sure that the "brackets" are not directly following one another – leave a blank between them.
Vector
The simplest STL container is vector. Vector is just an array with extended functionality. By the way, vector is the only container that is backward-compatible to native C code – this means that vector actually IS the array, but with some additional features.
Actually, when you type
the empty vector is created. Be careful with constructions like this:
Here we declare 'v' as an array of 10 vector<int>’s, which are initially empty. In most cases, this is not that we want. Use parentheses instead of brackets here. The most frequently used feature of vector is that it can report its size.
Two remarks: first, size() is unsigned, which may sometimes cause problems. Accordingly, I usually define macros, something like sz(C) that returns size of C as ordinal signed int. Second, it’s not a good practice to compare v.size() to zero if you want to know whether the container is empty. You're better off using empty() function:
This is because not all the containers can report their size in O(1), and you definitely should not require counting all elements in a double-linked list just to ensure that it contains at least one.
Another very popular function to use in vector is push_back. Push_back adds an element to the end of vector, increasing its size by one. Consider the following example:
Don’t worry about memory allocation -- vector will not allocate just one element each time. Instead, vector allocates more memory then it actually needs when adding new elements with push_back. The only thing you should worry about is memory usage, but at TopCoder this may not matter. (More on vector’s memory policy later.)
When you need to resize vector, use the resize() function:
The resize() function makes vector contain the required number of elements. If you require less elements than vector already contain, the last ones will be deleted. If you ask vector to grow, it will enlarge its size and fill the newly created elements with zeroes.
Note that if you use push_back() after resize(), it will add elements AFTER the newly allocated size, but not INTO it. In the example above the size of the resulting vector is 25, while if we use push_back() in a second loop, it would be 30.
vector
<
int
>
v(
20
);
for
(
int
i
=
0
; i
<
20
; i
++
) ...
{ v[i] = i+1; }
v.resize(
25
);
for
(
int
i
=
20
; i
<
25
; i
++
) ...
{ v.push_back(i*2); // Writes to elements with indices [25..30), not [20..25) ! }
To clear a vector use clear() member function. This function makes vector to contain 0 elements. It does not make elements zeroes -- watch out -- it completely erases the container.
There are many ways to initialize vector. You may create vector from another vector:
The initialization of v2 and v3 in the example above are exactly the same.
If you want to create a vector of specific size, use the following constructor:
In the example above, the data will contain 1,000 zeroes after creation. Remember to use parentheses, not brackets. If you want vector to be initialized with something else, write it in such manner:
Remember that you can create vectors of any type.
Multidimensional arrays are very important. The simplest way to create the two-dimensional array via vector is to create a vector of vectors.
It should be clear to you now how to create the two-dimensional vector of given size:
Here we create a matrix of size N*M and fill it with -1.
The simplest way to add data to vector is to use push_back(). But what if we want to add data somewhere other than the end? There is the insert() member function for this purpose. And there is also the erase() member function to erase elements, as well. But first we need to say a few words about iterators.
You should remember one more very important thing: When vector is passed as a parameter to some function, a copy of vector is actually created. It may take a lot of time and memory to create new vectors when they are not really needed. Actually, it’s hard to find a task where the copying of vector is REALLY needed when passing it as a parameter. So, you should never write:
void
some_function(vector
<
int
>
v) ...
{ // Never do it unless you’re sure what you do! // ... }
Instead, use the following construction:
void some_function(const vector<int>& v) { // OK
// ...
} If you are going to change the contents of vector in the function, just omit the ‘const’ modifier.
Pairs
Before we come to iterators, let me say a few words about pairs. Pairs are widely used in STL. Simple problems, like TopCoder SRM 250 and easy 500-point problems, usually require some simple data structure that fits well with pair. STL std::pair is just a pair of elements. The simplest form would be the following:
In general pair<int,int> is a pair of integer values. At a more complex level, pair<string, pair<int, int> > is a pair of string and two integers. In the second case, the usage may be like this:
The great advantage of pairs is that they have built-in operations to compare themselves. Pairs are compared first-to-second element. If the first elements are not equal, the result will be based on the comparison of the first elements only; the second elements will be compared only if the first ones are equal. The array (or vector) of pairs can easily be sorted by STL internal functions.
For example, if you want to sort the array of integer points so that they form a polygon, it’s a good idea to put them to the vector< pair<double, pair<int,int> >, where each element of vector is { polar angle, { x, y } }. One call to the STL sorting function will give you the desired order of points.
Pairs are also widely used in associative containers, which we will speak about later in this article.
Iterators
What are iterators? In STL iterators are the most general way to access data in containers. Consider the simple problem: Reverse the array A of N int’s. Let’s begin from a C-like solution:
This code should be clear to you. It’s pretty easy to rewrite it in terms of pointers:While(first < last) { // Loop while there is something to swap
}
Look at this code, at its main loop. It uses only four distinct operations on pointers 'first' and 'last':
- compare pointers (first < last),
- get value by pointer (*first, *last),
- increment pointer, and
- decrement pointer
But look: the second code can work for ANY pointer-like object. The only restriction is that that object can perform the operations described above: take value (unary *), comparison (<), and increment/decrement (++/--). Objects with these properties that are associated with containers are called iterators. Any STL container may be traversed by means of an iterator. Although not often needed for vector, it’s very important for other container types.
So, what do we have? An object with syntax very much like a pointer. The following operations are defined for iterators:
- get value of an iterator, int x = *it;
- increment and decrement iterators it1++, it2--;
- compare iterators by '!=' and by '<'
- add an immediate to iterator it += 20; <=> shift 20 elements forward
- get the distance between iterators, int n = it2-it1;
And the main advantage of iterators, of course, is that they greatly increase the reuse of code: your own algorithms, based on iterators, will work on a wide range of containers, and your own containers, which provide iterators, may be passed to a wide range of standard functions.
Not all types of iterators provide all the potential functionality. In fact, there are so-called "normal iterators" and "random access iterators". Simply put, normal iterators may be compared with ‘==’ and ‘!=’, and they may also be incremented and decremented. They may not be subtracted and we can not add a value to the normal iterator. Basically, it’s impossible to implement the described operations in O(1) for all container types. In spite of this, the function that reverses array should look like this:
The main difference between this code and the previous one is that we don’t use the "<" comparison on iterators, just the "==" one. Again, don’t panic if you are surprised by the function prototype: template is just a way to declare a function, which works on any appropriate parameter types. This function should work perfectly on pointers to any object types and with all normal iterators.
Let's return to the STL. STL algorithms always use two iterators, called "begin" and "end." The end iterator is pointing not to the last object, however, but to the first invalid object, or the object directly following the last one. It’s often very convenient.
Each STL container has member functions begin() and end() that return the begin and end iterators for that container.
Based on these principles, c.begin() == c.end() if and only if c is empty, and c.end() – c.begin() will always be equal to c.size(). (The last sentence is valid in cases when iterators can be subtracted, i.e. begin() and end() return random access iterators, which is not true for all kinds of containers. See the prior example of the double-linked list.)
The STL-compliant reverse function should be written as follows:
Note that this function does the same thing as the standard function std::reverse(T begin, T end) that can be found in algorithms module (#include <algorithm>).
In addition, any object with enough functionality can be passed as an iterator to STL algorithms and functions. That is where the power of templates comes in! See the following examples:
The last line performs a construction of vector from an ordinal C array. The term 'data' without index is treated as a pointer to the beginning of the array. The term 'data + N' points to N-th element, so, when N if the size of array, 'data + N' points to first element not in array, so 'data + length of data' can be treated as end iterator for array 'data'. The expression 'sizeof(data)/sizeof(data[0])' returns the size of the array data, but only in a few cases, so don’t use it anywhere except in such constructions. (C programmers will agree with me!)
Furthermore, we can even use the following constructions:
It creates the vector v2 that is equal to the first half of vector v.
Here is an example of reverse() function:
Each container also has the rbegin()/rend() functions, which return reverse iterators. Reverse iterators are used to traverse the container in backward order. Thus:
will create v2 with first half of v, ordered back-to-front.
To create an iterator object, we must specify its type. The type of iterator can be constructed by a type of container by appending “::iterator”, “::const_iterator”, “::reverse_iterator” or “::const_reverse_iterator” to it. Thus, vector can be traversed in the following way:
I recommend you use '!=' instead of '<', and 'empty()' instead of 'size() != 0' -- for some container types, it’s just very inefficient to determine which of the iterators precedes another.
Now you know of STL algorithm reverse(). Many STL algorithms are declared in the same way: they get a pair of iterators – the beginning and end of a range – and return an iterator.
The find() algorithm looks for appropriate elements in an interval. If the element is found, the iterator pointing to the first occurrence of the element is returned. Otherwise, the return value equals the end of interval. See the code:
To get the index of element found, one should subtract the beginning iterator from the result of find():
Remember to #include <algorithm> in your source when using STL algorithms.
The min_element and max_element algorithms return an iterator to the respective element. To get the value of min/max element, like in find(), use *min_element(...) or *max_element(...), to get index in array subtract the begin iterator of a container or range:
int
data[
5
]
=
{ 1, 5, 2, 4, 3 }
; vector
<
int
>
X(data, data
+
5
);
int
v1
=
*
max_element(X.begin(), X.end());
//
Returns value of max element in vector
int
i1
=
min_element(X.begin(), X.end()) – X.begin;
//
Returns index of min element in vector
int
v2
=
*
max_element(data, data
+
5
);
//
Returns value of max element in array
int
i3
=
min_element(data, data
+
5
) – data;
//
Returns index of min element in array
Now you may see that the useful macros would be:
Don’t put the whole right-hand side of these macros into parentheses -- that would be wrong!
Another good algorithm is sort(). It's very easy to use. Consider the following examples:
vector
<
int
>
X;
//
...
sort(X.begin(), X.end());
//
Sort array in ascending order
sort(all(X));
//
Sort array in ascending order, use our #define
sort(X.rbegin(), X.rend());
// Sort array in descending order using with reverse iterators
Compiling STL Programs
One thing worth pointing out here is STL error messages. As the STL is distributed in sources, and it becomes necessary for compilers to build efficient executables, one of STL's habits is unreadable error messages.
For example, if you pass a vector<int> as a const reference parameter (as you should do) to some function:
The error here is that you are trying to create the non-const iterator from a const object with the begin() member function (though identifying that error can be harder than actually correcting it). The right code looks like this:
In spite of this, let me tell about very important feature of GNU C++ called ' typeof'. This operator is replaced to the type of an expression during the compilation. Consider the following example:
This will create the variable x of type matching the type of (a+b) expression. Beware that typeof(v.size()) is unsigned for any STL container type. But the most important application of typeof for TopCoder is traversing a container. Consider the following macros:
By using these macros we can traverse every kind of container, not only vector. This will produce const_iterator for const object and normal iterator for non-const object, and you will never get an error here.
Note: I did not put additional parentheses on the #define line in order to improve its readability. See this article below for more correct #define statements that you can experiment with in practice rooms.
Traversing macros is not really necessary for vectors, but it’s very convenient for more complex data types, where indexing is not supported and iterators are the only way to access data. We will speak about this later in this article.
Data manipulation in vector
One can insert an element to vector by using the insert() function:
All elements from second (index 1) to the last will be shifted right one element to leave a place for a new element. If you are planning to add many elements, it's not good to do many shifts – you're better off calling insert() one time. So, insert() has an interval form:
vector
<
int
>
v; vector
<
int
>
v2;
//
..
//
Shift all elements from second to last to the appropriate number of elements.
//
Then copy the contents of v2 into v.
v.insert(
1
, all(v2));
Vector also has a member function erase, which has two forms. Guess what they are:
At first case, single element of vector is deleted. At second case, the interval, specified by two iterators, is erased from vector.
The insert/erase technique is common, but not identical for all STL containers.
See next: Power up C++ with STL: Part II (string, set, map)
width="728" scrolling="no" height="90" frameborder="0" align="middle" src="http://download1.csdn.net/down3/20070601/01184120111.htm" marginheight="0" marginwidth="0">
扫一扫
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
