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 that you can use ready-made components without re-development. 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 one 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. Defining a list we can define a STL List as this:
#include #include int main (void) {list Milkshakes; return 0;}
This is, you have defined a list. Is it simple? List Milkshakes This sentence is that you declare an instance of the list template class, then an object of instantiation of the 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 -o test1 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.
Insert an element into the List using the member function of the list_back and push_front:
#include #include int main (void) {list Milkshakes; Milkshakes.push_back ( "Chocolate"); Milkshakes.push_back ( "Strawberry"); Milkshakes.push_front ( "Lime"); Milkshakes .push_front ("vanilla"); return 0;}
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.
THE LIST MEMBER FUNCTION EMPTY () List member function EMPTY ()
It is important to know if a List is empty. 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.
/ * || Using a list to TRATITUS * / # include #include #include int main (void) {#define ok 0 #define info 1 #define WARNING 2 int return_code; list InfoMessages; list 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 messages infMessages.push_front ("INFORMATIONAL MESSAGES:" ); // ... print the info message, we'll see how late return_code = info;} {// there ,,, ("Warning Messages.push_front (" WARNING Messages: ") ; // ... Print The Warning Messages List, We'll See How Later Return_code = WERNING;} //iffate (Infubus.empty () && WarningMES.EMPTY ()) {COUT < <"There e no message "<< Endl;} Return Return_code;} With the for loop to handle the elements in the list we want to traverse a list, such as printing all objects to see 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 < string> :: 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.end (); MilkshakeIterator) { // dereference the iterator 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. Using STL's general algorithm for_each to handle elements in LIST using STL LIST and ITERATOR, we want to initialize, 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 << } int main (void) {list FruitAndVegetables; FruitAndVegetables.push_back ( "carrot"); FruitAndVegetables.push_back ( "pumpkin"); FruitAndVegetables.push_back ( "potato"); FruitAndVegetables.push_front ( "apple"); FruitAndVegetables .push_front ("PineApple"); for_each (FruitandVegetables.begin (), FruitandVegetables.end (), frintit);} In this program we use STL's general algorithm for_each () to traverse the 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 general algorithm of the number of elements in the list () and count_it () used to record the 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;} count () algorithm statistics is equal to the number of objects 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 uses STL's general algorithm count_if () to count the number of elements in the list, 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) == TOTHBRUSHCODE;}}; 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 (), ISATOTHBRUSH (), Numberoftoothbrushes; cout << "there" << NumberoftOothbrushes << "TOTHBRUSHES SOLD" << Endl;} This is the output of this program: There WERE 2 TOTHBRUSHES SOLD This program works this: Define a function Object class isatoothbrush, this class object can determine if the sold 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. One more complex function object using count_if () 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 functions of the following:
