STL introduction, standard template library (reposted)
About STL, the Standard Template Library Author: Scott Field This article is a new extension on the C language - Standard Template Library (Standard Template Library), also known as STL. When I first intended to write an article about STL, I had to admit that I went to underestimate the depth and breadth of this topic. There are a lot of content to be covered, and there are a lot of books that describe STL. So I re-consider my original idea. Why do I have to write this article, why do you want to contribute? What will this use? Is there any need to come back about STL? When I opened the Musser and Saini page, I saw the programming era ablation in front of me. I can see that the night has disappeared, and the target software project has appeared. I saw the maintenance code. One year has passed, I use STL written software still easy to maintain. It is a very surprised that others can have a good maintenance! However, I also remember that it is difficult to understand those technical terms when they start. Once, I bought Musser & Saini, and everything appeared in turn, but there were some good examples who were most eager to get there. When I started, Stroustrup as part of C has not come yet, it covers STL. So I would like to write an article about a real life of a STL programmer. If I have some good examples in my hand, especially the new topic like this, I will learn faster. Another thing is that STL should be very easy to use. Therefore, in theory, we should start using STL immediately. What is STL? STL is Standard Template Library, standard template library. This may be the most boring term for the most exciting tool in history. Fundamentally, STL is a collection of "containers", these "containers" include List, Vector, SET, MAP, etc., STL is also a collection of algorithms and other components. The collection of "containers" and algorithms here refers to a masterpiece of many smart people in the world. The purpose of STL is to standardize components so you don't have to revoke them. You can only use these ready-made components. STL is now part of C , so there is no additional installation. It is built within your compiler. Because STL's list is a simple container, I intend to introduce STL how to use it from it. If you know this concept, there is no problem in other things. In addition, the List container is quite simple, we will see this. In this article we will see how to define and initialize a list, calculate the number of elements, find elements, delete elements, and some other operations from a list. To do this, we will discuss two different algorithms, and the STL general algorithm can operate more than one container, and the member function of the List is a proprietary operation of the LIST container. This is a simplicity of three primary STL components. The STL container can save objects, built-in objects, and class objects. They safely save objects and define the interface we can operate. Eggs put on the egg rack will not roll to the table. They are safe. Therefore, the objects in the STL container are also very secure. I know this metaphor is very old soil, but it is correct. The STL algorithm is a standard algorithm that we can apply them on those containers. These algorithms have very famous execution characteristics.
They can sort objects, delete them, give them a record, compare, find special objects, merge them into another container, and perform other useful operations. STL Iterator is like a pointer to the object in the container. The algorithm of STL uses Iterator on the container on the container. Iterator sets the boundary of the algorithm, the length of the container, and some things. For example, some Iterator only allows algorithm reading elements, some let algorithm write elements, and there are some of them. Iterator also determines the direction processed in the container. You can get a Iterator that pointing to a container start position by calling a member function becom () of the container. You can call a container's END () function to get the last value of the past (that is, the value of the value stops). This is the other thing of STL, the container, algorithm, and the Iterator that allows algorithms to work on the elements in the container. The algorithm operates objects in a suitable, standard approach, and can get the exact length of the container via Iterator. Once these do this, they will not "run out the boundary." There are also other components that have functional enhanced functions of these core components, such as function objects. We will see examples about these, now let's take a look at the List of STL. -------------------------------------------------- ------------------------------ Define a list We can define a STL List: #include # Include int main (void) {list Milkshakes;} This is OK, you have defined a list. Is it simple? List Milkshakes This sentence is that you declare an instance of the list template class, and then an object of instantiation this class. But don't worry about this. In this step in this, you only need to know that you define a string LIST. You need to include the header file that provides the STL List class. I use GCC 2.7.2 to compile this test program on my Linux, for example: g test1.cpp -otest1 Note that iostream.h This header file has been abandoned by the STL's header file. This is why there is no reason in this example. Now we have a list, we can use it to use it. We will add a string to this list. There is a very important thing called List value type. The value type is the type of object in the List. In this example, this List's value type is a string, string because this list is used to make strings.
-------------------------------------------------- ----------------------------- i Using the members of the list Push_back and push_front Insert an element into the list #include #include # int main (void) {list Milkshakes; Milkshakes.push_back ( "Chocolate"); Milkshakes.push_back ( "Strawberry"); Milkshakes.push_front ( "Lime"); Milkshakes.push_front ( " Vanilla ");} We now have a list with four strings in it The list member function push_back () places an object onto the back of the list The list member function push_front () puts one on the front I often push_back (... Some Error Messages Onto A List, And the Push_Front () A Title on The List So It Prints Before The Error Messages. We now have a 4 string in LIST. The member function of the List puts an object behind a list, while push_front () puts the object in front. I usually put some error information push_back () into a list, then push_front () a title to list so that it will print it before this error message. -------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Very important. If the list is empty, the member function of Empty () is true. I usually use it like this. I use push_back () to put the error message in the list. Then, by calling EMPTY (), I can say that this program reports an error. If I define a list to put information, a warning, a serious error, I can easily say that the type of error occurs easily by using Empty (). I can organize these LISTs and then use the title to organize them before printing them, or sort them into classes.
This is my meaning: / * || Using a list to track and report program messages and status * / #include #include #include # int main (void) {#define OK 0 #define INFO 1 #define WARNING 2 # int return_code; # list InfoMessages; list <: string> WarningMessages; # // during a program these messages are loaded at various points InfoMessages.push_back ( "Info: Program started" ); // Do Work ... WarningMessages.push_back ("Warning: No Customer Records Have Been Found"); // Do Work ... # Return_code = OK; # if (! InfMessages.empty ()) {//// There were info messagein infMessages.push_front ("INFORMATIONAL MESSAGES:"); // ... print the info messages list, we'll see how late return_code = info;} # i (! WarningMESSAGES.EMPTY ()) {// There WERE WARNING Messages WarningMessages.push_front ("Warning Messages:"); // ... print the warning message list, we'll see how laturn_code = warning; } # // if there. F (infMessages.empty () && warningMPTY () {cout << "there"} # Return Return_code;} ---- -------------------------------------------------- -------------------------- Use the for loop to handle the elements in the list. We want to traverse a list, such as printing all objects. Look at the results of different operations on the list.
To traverse a list of an element, we can do this: / * || How to print the contents of a simple st.whew! * / #Include #include #include # int main (void) {list Milkshakes; list :: iterator MilkshakeIterator; # Milkshakes.push_back ( "Chocolate"); Milkshakes.push_back ( "Strawberry"); Milkshakes.push_front ( "Lime") ; Milkshakes.push_front ( "Vanilla"); # // print the milkshakes Milkshakes.push_front ( "The Milkshake Menu"); Milkshakes.push_back ( "*** Thats the end ***"); for (MilkshakeIterator = Milkshakes. Begin (); Milkshakeiterator! = Milkshakes.eerator) {// dereference The itrator to get the element cout << * Milkshakeiterator << Endl;}} This program defines an Iterator, Milkshakeiterator. We point it to the first element of this List. This can call MilkShakes.Begin () to do it, it will return a Iterator pointing to the List. Then we compare it and the return value of Milkshakes.end (). When we arrived there, stopped. The end () function of the container returns an item of Iterator to the last position of the container. When we arrive there, stop the operation. We cannot ignore the return value of the END () function of the container. We only know that it means that the end of this container has been processed, should stop processing. All STL containers must do this. In the above example, each time the FOR cycle is executed, we repeatedly refer to Iterator to get our printed string. In STL programming, we use one or more items in each algorithm. We use them to access objects in the container. To access a given object, let's point to it, then indirectly quote this item. This List container is like what you think, it does not support a number of objects to point to one number in Iterator. That is, we can't use Milkshakes.Begin () 2 to point to the third object in the list, because the STL's list is implemented with a double-stranded list, which does not support random access. Vector and Deque (vector and dual queues) and some other STL containers can support random access. The above program prints out the contents in the list. Anyone read it, you can figure out how it works. It uses standard Iterator and standard LIST containers. There is not much programmer relying on what it put in it, just standard C . This is an important step. This example uses STL to make our software more standard.
-------------------------------------------------- ------------------------------ Use STL's general algorithm for_each to handle elements in the list use STL LIST and ITERATOR, we want Initialization, compare and give iterator increments to traverse this container. STL - common for_each algorithms can alleviate our work. / * || How to print a Simple Stl list mkii * / #include #include #include #include #printiT (string & stringtoprint) {cout << StringToprint << Endl ;} # int main (void) {list FruitAndVegetables; FruitAndVegetables.push_back ( "carrot"); FruitAndVegetables.push_back ( "pumpkin"); FruitAndVegetables.push_back ( "potato"); FruitAndVegetables.push_front ( "apple") FruitandVegetables.push_front ("pinepple"); # for_each (fruitandvegetables.begin (), fruitandvegetables.end (), printit);} In this program we use STL's general algorithm for_each () to traverse a range of Iterator, then Call printit () to handle each object. We don't need to initialize, compare and give Iterator increments. FOR_EACH () has completed these work for us. We execute the operation on the object being packed in this function, we don't have to do that loop, our code is clearer. The FOR_EACH algorithm references the concept of the Iterator range, which is the range pointed out by the starting iterator and one end Iterator. The starting item indicates where the operation is started, the end Iterator indicates where the end, but it is not included in this range. -------------------------------------------------- ------------------------------ Use STL's general algorithm count () to count the number of elements in List. The general algorithm of STL count () and count_it () are used to record objects in the container. Just like for_each (), count () and count_if () algorithms are also done in the iTerator range. Let us have a number of people in the LIST of a student test. This is a integer list.
/ * || How to count Objects in an stlist * / #include #include # int main (void) {list score; # scores.push_back (100); score.push_back (80 ); Score.push_back (45); score.push_back (75); score.push_back (99); scores.push_back (100); # int numberof100scores (0); count (scores.begin (), scorend () , 100, Numberof100Scores); # cout << "there" << Numberof100scores << "scorers of 100" << Endl;} The count () Algorithm Counts The number of objects equal to a ceertain value. In the Above Example IT CHECKS EACH INTEGER OBJECT IN A List Against 100. IT Increments The Variable Numberof100scores Each Time A Container Object Equals 100. The Output of The Program Is Count () Algorithm Statistics Obtained by an object of a certain value. The above example exams each of the integer objects in the List. Objects in each container is equal to 100, it gives Numberof100Scores plus 1. This is the output of the program: There Were 2 Scores of 100 -------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------ Use STL's general algorithm count_if () The number of elements in the statistics of the statistics count_if () is a more interesting version of count (). He used STL's new component, function object. Count_if () Belts a parameter of a function object. Function object is a class with at least one Operator () method. Some STL algorithms are used as a parameter to receive function objects and call the Operator () method of this function object. The function object returns TRUE or FALSE when the STL algorithm calls Operator. They determine this function based on this. It is more clear to give an example. Count_if () makes a more complex assessment than Count () by passing a function object to determine if an object should be recorded. In this example we will sell the number of toothbrush. We will submit sales records containing four characters and product descriptions.
/ * || Using a function Object to help count things * / #include #include #include # const string toothbrushcode ("0003"); # class isatoothbrush {public: BOOL Operator () () string & SalesRecord) {return SalesRecord.substr (0,4) == ToothbrushCode;}}; # int main (void) {list SalesRecords; # SalesRecords.push_back ( "0001 Soap"); SalesRecords.push_back ( "0002 Shampoo "); SalesRecords.push_back (" 0003 Toothbrush "); SalesRecords.push_back (" 0004 Toothpaste "); SalesRecords.push_back (" 0003 Toothbrush "); # int NumberOfToothbrushes (0); count_if (SalesRecords.begin (), SalesRecords .end (), isatoothbrushes; # cout << "there" << Numberoftoothbrushes << "TOTHBRUSHES SOLD" << Endl;} This is the output of this program: there is a total of Selling Two toothbrush) This program works this way: Define a function object class isatoothbrush, which can determine if the sale is a toothbrush. If this record is a record of selling a toothbrush, the function calls Operator () returns a true, otherwise returns false. The count_if () algorithm handles the container object by the range of first and second two Iterator parameters. It will increase the value of NumberoftOothbrushes to the objects in the container that returns True in TRUE. The final result is that NumberoftOothbrushes saves the number of records of the product code domain "0003", which is the number of toothbrush. Note that the third parameter ISATOTHBRUSH () of count_if () is an object that is temporarily constructed by its constructor. You can pass a temporary object of the ISATOTHBRUSH class to a count_if () function. Count_if () will call each object of the container to call this function. -------------------------------------------------- ------------------------------ uses count_if () a more complex function object. We can further study the function object. Suppose we need to pass more information to a function object. We can't do this by calling Operator because it must be defined as the type of object in a list. However, we can use any of the information we need to initialize it with any information we need for isatoothbrush.
For example, we may need to have an uncertain code for each toothbrush. We can add this information to the following function object: / * || Using a more complex function object * / #include #include #include #include # Class isatoothbrush {public: IsAToothbrush (string & InToothbrushCode): ToothbrushCode (InToothbrushCode) {} bool operator () (string & SalesRecord) {return SalesRecord.substr (0,4) == ToothbrushCode;} private: string ToothbrushCode;}; # int main (void ) {list SalesRecords; # SalesRecords.push_back ( "0001 Soap"); SalesRecords.push_back ( "0002 Shampoo"); SalesRecords.push_back ( "0003 Toothbrush"); SalesRecords.push_back ( "0004 Toothpaste"); SalesRecords .push_back ( "0003 Toothbrush"); # string VariableToothbrushCode ( "0003"); # int NumberOfToothbrushes (0); count_if (SalesRecords.begin (), SalesRecords.end (), IsAToothbrush (VariableToothbrushCode), NumberOfToothbrushes); cout << "There" << Numberoftoothbrushes << "TOTHBRUSHES MATCHING "<< variabletoothbrushcode <<" "SOLD" << Endl;} The output of the program is: There WERE 2 TOTHBRUSHES MATCHING CODE 0003 Sold This example demonstrates how to pass information to the function object. You can define any constructor you want, you can do anything you want to do again, you can legally compile. You can see that the function object really expands the basic count algorithm. So far, we have learned: Define a list to add elements to list how to know if the List is empty how to use the for loop to traverse how List uses STL's general algorithm for_each to traverse the list list member function begin () and END ) And their meaning Iterator range concept and a range of last positions do not be handled this fact how this is how to use the STL general algorithm count () and count_if () how to define a function in a list of objects. Object I use these examples to demonstrate the general operation of the List.
