STL Introduction [This article is easy to understand, especially suitable for beginners who have never used STL. ]

zhaozj2021-02-08 215

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. Defining a list we can define a STL List as this:

#include

INT main (void) {

List Milkshakes;

} This is OK, you have already 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 Insert an element into the List using the member function of the list_back and push_front

#include

INT main (void) {

List Milkshakes;

Milkshakes.push_back ("chocolate");

Milkshakes.push_back ("strawberry");

Milkshakes.push_front ("limited");

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 then push_front () a title 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. The member function EMPTY () of the list member function Empty () List knows if a list is 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 what I mean:

/ *

|| Using a list to TRACK AND Report Program Messages and Status

* /

#include

INT main (void) {

#define ok 0

#define info 1

#define Warning 2

Int retURN_CODE;

List infMessages;

List <: string> warningmessages;

// During a Program these Messages Are Loaded At Various Points

Infomessages.push_back ("info: program start");

// Do Work ...

WARNINGMESSAGES.PUSH_BACK ("Warning: No Customer Records Have Been Found");

// Do Work ...

Return_code = OK;

IF (! infMessages.empty ()) {// there is info message

Infomessages.push_front ("INFORMATIONAL MESSAGES:");

// ... Print The Info Messages List, WE'LL See How Later

RETURN_CODE = INFO;

}

IF (! warningmessages.empty ()) {// there

WARNINGMESSAGES.PUSH_FRONT ("WARNING Messages:"); // ... print the warning message list, we'll see how late

Return_code = warning;

}

// if there.............

IF (Infomessages.empty () && WarningMessages.empty ()) {

COUT << "there" there "tre no message" << Endl;

}

Return return_code;

}

Use the for loop to handle 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 one element of an element, we can do this: / *

|| How to Print The Contents of a Simple Stl List. Whew!

* /

#include

INT main (void) {

List Milkshakes;

List :: item Milkshakeiterator;

Milkshakes.push_back ("chocolate");

Milkshakes.push_back ("strawberry");

Milkshakes.push_front ("limited");

Milkshakes.push_front ("vanilla");

// print the milkshakes

Milkshakes.push_front ("The Milkshake Menu");

Milkshakes.push_back ("*** Thats the End ***");

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

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 ("pineapple");

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. Statify the number of elements in the List using STL's general algorithm count (). 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 Stl List

* /

#include

INT main (void) {

List score;

Scores.push_back (100); scorers.push_back (80);

Scores.push_back (45); score.push_back (75);

Scores.push_back (99); scores.push_back (100);

INT NUMBEROF100SCORES (0);

Count (Scores.Begin (), ScoreS.end (), 100, Numberof100scores);

Cout << "there" << numberof100scores << "scorers of 100" << ENDL;

} The count () algorithm counts the number of objects equal to a certain 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 statistically 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 Scorers of 100

Using STL's general algorithm count_if () to count the number of elements in 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

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 (), NUMBEROTHBRUSHES

Cout << "there" "

<< Numberoftoothbrushes

<< "TOTHBRUSHES SOLD" << Endl;

} This is the output of this program: There WERE 2 TOTHBRUSHES SOLD (a total of two toothbrush) This program works this way: Define a function object class isatoothbrush, this class's object can determine whether the sold is 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. A 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:

/ *

|| Using A More Complex Function Object

* /

#include

Class isatoothbrush {

PUBLIC:

ISATOTHBRUSH (String & IntoothBrushcode):

TOTHBRUSHCODE (INTOTHBRUSHCODE) {}

Bool Operator () (String & SalesRecord) {

Return SalesRecord.substr (0,4) == TOTHBRUSHCODE;

}

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 (),

ISATOTHBRUSH (Variabletoothbrushcode),

Numberoftoothbrushes);

Cout << "there" "

<< Numberoftoothbrushes << "TOTHBRUSHES MATCHING CODE"

<< Variabletoothbrushcode

<< "SOLD"

<< ENDL;

} The output of the program is: There WERE 2 TOTHBRUSHES MATCHCHING 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 the list to learn how List is empty how to use for loops to traverse how List uses STL's general algorithm for_each to traverse List List member functions Begin () and end () and their meaning Iterator range concept And a range of last position is actually not handled how this is how to use the STL general algorithm count () and count_if () how to count the object in a list, how to define a function object I use these examples to demonstrate List General operation. If you understand these basic principles, you can use STL without doubt that you do some exercises. We now use some more complex operations to expand our knowledge, including List member functions and STL general algorithms.

Using STL Universal Algorithm Find () Find objects in list How do we find things in LIST? STL's general algorithm Find () and FIND_IF () can do this. Like for_each (), count (), count_if (), these algorithms also use the Iterator range, which indicates a list or any other container to process. Usually the first Iterator refers to the position of the beginning, and the Iterator pointed to stop processing. The elements pointed out by times Iterator are not processed. This is find () how to work: / * || How to find things in an set list * / #include #include #include # int main (void) {list fruit; List :: Iterator Fruititerator; # fruit.push_back ("apple"); Fruit.push_Back ("PineApple"); Fruit.push_Back ("star apple"); # fruititerator = find (fruit.begin (), Fruit .end (), "pineapple"); # if (fruititerator == fruit.end ()) {cout << "fruit not found in list" << Endl;} else {cout << * fruititerator << endl;} } The output is: PineApple If the object does not find, it will return Fruit.end () value. If you find it, return a point to Iterator that pointing to the object found.

Searching for objects in List This is a more powerful version of Find () using the STL general algorithm. This example demonstrates find_if (), which receives the parameters of a function object as a parameter and uses it to do more complex evaluation objects and give the lookup criteria. Suppose there are some records containing events and dates in our List. We want to find an event that happened in 1997. / *

|| How to find things in an Stl List Mkii

* /

#include

Class Eventisin1997 {

PUBLIC:

BOOL Operator () (String & EventRecord) {

// Year Field Is At Position 12 for 4 Characters in EventRecord

Return EventRecord.substr (12, 4) == "1997";

}

INT main (void) {

List Events;

// String positions 0123456789012345678901234567890123456789012345

Events.push_back ("07 January 1995 Draft Plan of House Prepared");

Events.push_back ("07 February 1996 Detailed Plan Of House Prepared");

Events.push_back ("10 January 1997 Client Agrees To Job");

Events.push_back ("15 January 1997 Builder Starts Work On Bedroom");

Events.push_back ("30 April 1997 Builder Finishes Work");

List :: item Eventiterator =

Find_if (Events.begin (), Eventisin1997 ());

// Find_if Completes the first time eventisin1997 () Returns true

// for any Object. it Returns an iterator to That Object Which WE

// can dereference to get the object, or if Eventisin1997 () () NEVER

// returned true, find_if returns end ()

IF (Eventiterator == Events.end ()) {

Cout << "Event not found in list" << Endl;

}

Else {

Cout << * Eventiterator << Endl;

}

} This is the output of the program:

10 January 1997 Client Agrees To Job

Using the STL General Algorithm Search to find a sequence in list, some characters are well processed in the STL container, let us see a difficult character sequence. We will define a list to place characters. List characters; Now we have a character sequence, it does not use any help, you will know and manage the memory. It knows where it starts, where is it ended. It is very useful. I don't know if I said the character array ended with NULL. Let's join some of the characters we like to this list: characters.push_back ('/ 0'); characters.push_back ('/ 0'); characters.push_back ('1'); characters.push_back ('2') How many empty characters we will get? INT Numberofnullcharacters (0);

Count (Characters.Begin (), Characters.end (), '/ 0', Numberofnullcharacters;

COUT << "We Have" << Numberofnullcharacters << Endl; Let's find characters '1'

List :: iterator it;

Iter = find (characters.begin (), characters.end (), '1');

COUT << "We found" << * iter << Endl; this example demonstrates that the STL container allows you to process empty characters in a more standard approach. Now let's use STL's Search algorithm to search for two NULLs in the container. Just like you guess, STL general algorithm search () is used to search for a container, but search for an element string, not like Find () and FIND_IF () Search only for individual elements.

/ *

|| How to use the Search Algorithm in An Stl List

* /

#include

INT main (void) {

List targetcharacters;

List listofcharacters;

Targetcharacters.push_back ('/ 0');

Listofcharacters.push_back ('1');

ListOfcharacters.push_back ('2');

Listofcharacters.push_back ('/ 0');

List :: item PositionOfnulls =

Search (ListOfcharacters.begin (), ListOfcharacters.end (),

Targetcharacters.begin (), targetcharacters.end ());

IF (positionofnulls! = ListOfcharacters.end ())

Cout << "We Found The Nulls" << Endl;

} The output of the program will be this is the output of the program: We found the Nulls Search algorithm to find another sequence in a sequence. In this example we found a first appearance of TargetCharacters in ListOfcharacters, TargetCharacters is a sequence containing two NULL characters. The parameters of Search are two Iterators that point to find the target and two Iterators that point to the search range. So we look for the entire sequence of TargetCharacters in the range of the entire ListOfchacTers. If TargetCharacters are found, Search returns an item of iTerator that pointing to the sequence in ListOfcharacters. If a match is not found, Search returns the value of ListOfcharacters.end ().

Sort a list using a member function sort () of the list. To sort a list, we want to function sort () instead of the general algorithm sort (). All we have used algorithms are general algorithms. However, sometimes the container supports its own implementation of a special algorithm in STL, which is usually in order to improve performance. In this example, the List container has its own Sort algorithm because the general algorithm can only sort the container that provides random access elements, and because the List is implemented as a connected list, it does not support it The element is randomly accessed. So you need a special sort () member function to sort the list. For various reasons, the container supports external functions in applications that require high or special effects demand, which can be made by using the structural characteristics of the constructor.

/ *

|| How to Sort An Stl List

* /

#include

Printit (string & stringtoprint) {cout << StringToprint << endl;}

INT main (void) {

List Staff;

List :: Iterator PEopleITerator;

STAFF.PUSH_BACK ("john");

Staff.push_back ("bill");

Staff.push_back ("tony");

Staff.push_back ("fidel");

Staff.push_back ("Nelson");

COUT << "The unsorted list" << endl;

FOR_EACH (staff.begin (), staff.end (), printit;

Staff.sort ();

Cout << "The sorted list" << Endl;

FOR_EACH (staff.begin (), staff.end (), printit;

} The output is:

The unsorted list

John

Bill

Tony

FiDel

Nelson

The Sorted List

Bill

FiDel

John

Nelson

Tony

Insert the member function of the List of the List to add the elements to the front and back of the LIST. You can use INSERT () to insert the object anywhere in the list. INSERT () can join an object, a copy of an object, or an object within a range. Here is an example in which some insertion objects to LIST: / *

|| Using INSERT to INSERT Elements INTO A LIST.

* /

#include

INT main (void) {

List list1;

/ *

|| Put Integers 0 to 9 in the list

* /

For (int i = 0; i <10; i) List1.push_back (i);

/ *

|| INSERT -1 Using The INSERT MEMBER FUNCTION

|| Our List Will Contain -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

* /

List1.insert (list1.begin (), -1);

/ *

|| INSERT AN Element At the End Using INSERT

|| Our List Will Contain -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

* /

List1.insert (list1.end (), 10);

/ *

|| INSERTING A RANGE from another container

|| Our List Will Contain -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

* /

INT INTARRAY [2] = {11,12};

List1.insert (List1.end (), & INTARRAY [0], & INTARRAY [2]);

/ *

|| AS An EXERCISE PUT The Code in here to print the lists!

|| Hint: use printit and accept an interger

* /

} Note that the insert () function inserts one or several elements into the location of the Iterator you point out. Your elements will appear before the location pointed out in Iterator.

List constructor we have defined List: list fred; you can also define a list like this, and initialize its element: // define a list of 10 elements and initialise them all to 0

List fred (10, 0);

// list now Contains 0, 0, 0, 0, 0, 0, 0, 0, 0 or you can define a list and initialize it with a range of another STL container, this STL container is not necessarily a list. However, it is only necessary to be the same container having the same element type.

Vector Harry;

Harry.push_back (1);

Harry.push_back (2);

// define a list and initialise it with the elements in harry

List Bill (Harry.Begin (), Harry.end ());

// Bill Now Contains 1, 2

Use the List member function to remove the element List member function pop_front () delete the first element in the list, Pop_BACK () deletes the last element. The function ERASE () deletes the elements pointed out by an item. There is another erase () function to delete a range of elements. / * || ERASING Objects from a list

* /

#include

INT main (void) {

List list1; // define a list of integers

/ *

|| Put Some Numbers in the List

|| IT now Contains 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

* /

For (int i = 0; i <10; i) List1.push_back (i);

List1.pop_front (); // Erase The First Element 0

List1.pop_back (); // Erase The Last Element 9

List1.ras (list1.begin ()); // Erase the first element (1) Using An Iterator

List1.ras (list1.begin (), list1.end ()); // Erase All The Remaining Elements

Cout << "List contains" << list1.size () << "elements" << Endl;

} Output is: List Contains 0 Elements

Use the List member function remove () to remove the element from the list. The members of the List is used to delete elements from the list.

/ *

|| USING THE LIST MEMBER FUNCTION REMOVE TO Remove Elements

* /

#include

Printit (const string & stringtoprint) {

Cout << StringToprint << endl;

}

INT main (void) {

List Birds;

Birds.push_back ("cockatoo");

Birds.push_back ("galah");

Birds.push_back ("cockatoo");

Birds.push_back ("rosella");

Birds.push_back ("Corella");

Cout << "Original List with cockatoos" << Endl;

FOR_EACH (Birds.begin (), Birds.end (), Printit;

Birds.Remove ("cockatoo");

Cout << "now no cockatoos" << endl;

FOR_EACH (Birds.begin (), Birds.end (), Printit;

} The output is:

Original List with cockatoos

Cockatoo

galah

Cockatoo

Rosella

Corella

Now no cockatoosgalah

Rosella

Corella

Use STL General Algorithm Remove () to remove element universal algorithm remote () using and List's member functions from list. In general, do not change the size of the container.

/ *

|| Using The Generic Remove Algorithm To Remove List Elements

* /

#include

Printit (String & Astring) {cout << astring << endl;}

INT main (void) {

List Birds;

List :: item newnd;

Birds.push_back ("cockatoo");

Birds.push_back ("galah");

Birds.push_back ("cockatoo");

Birds.push_back ("rosella");

Birds.push_back ("King Parrot");

Cout << "Original List" << Endl;

FOR_EACH (Birds.begin (), Birds.end (), Printit;

NEWEND = Remove (Birds.begin (), Birds.end (), "cockatoo");

Cout << Endl << "List accounting to new past the end itrator" << end1

For_each (birds.begin (), newnd, printit;

Cout << Endl << "Original List Now. Care Required!" << endl;

FOR_EACH (Birds.begin (), Birds.end (), Printit;

} The output will be Original List

Cockatoo

galah

Cockatoo

Rosella

King Parrot

List accounting to new paste the end ipaterator

galah

Rosella

King Parrot

Original List now. Care Required!

galah

Rosella

King Parrot

Rosella

King Parrot Universal Remove () Algorithm returns a Iterator that pointing to the end of the new list. From the beginning to this new end (excluding new end elements), all elements are left after removing. You can use the List member function ERASE function to delete the part of the new end to the old end.

Use the STL General Algorithm Stable_Partition () and List member function splice () to divide a list we will complete a slightly a bit complicated example. It demonstrates the changes of the STL general algorithm stable_paartition () algorithm and a List member function splice (). Note that the use of function objects and does not use loops. Call the STL algorithm by a simple statement to control. Stable_paTition () is an interesting function. It rears elements such that the elements that meet the specified conditions are ranked in front of the elements that do not satisfy the conditions. It maintains the order relationship of two groups of elements. Splice combines elements in another list into a list. It removes elements from source list. In this example, we want to receive some logos and four file names from the command line. The file name must "appear in order. By using Stable_Partition () we can receive and file names to any location, and put them together without chaos. Due to the ratio and lookup algorithms are easy to use, we call these algorithms to decide which flag is set and which flag is not set. I found that the container is used to manage a small amount of dynamic data. / *

|| Using the STL Stable_Partition Algorithm

|| takes any number of flags on the command line and

|| Four FileNames in Order.

* /

#include

Printit (String & Astring) {cout << astring << endl;}

Class isaflag {

PUBLIC:

BOOL Operator () (String & Possibleflag) {

Return Possibleflag.substr (0,1) == "-"

}

Class isafilename {

PUBLIC:

Bool Operator () (String & StringToCheck) {

Return! isaflag () (StringToCheck);

}

Class ishelpflag {

PUBLIC:

Bool Operator () (String & Possiblehelpflag) {

Return PossibleHelpflag == "- h";

}

INT Main (int Argc, char * argv []) {

List cmdlineParameters; // The Command Line Parameters

List :: item startoffiles; // start of filenames

List Flags; // List of Flags

List Filenames; // List of FileNames

For (int i = 0; i

CmdlineParameters.pop_front (); // We don't want the program name

// Make Sure We Have The Four Mandatory File Names

INT NUMBEROFFILES (0);

Count_if (cmdlineParameters.begin (), cmdlineparameters.end (), isafilename (), Numberoffiles;

Cout << "the"

<< (Numberoffiles == 4? "Correct": "WRONG")

<< "Number ("

<< Numberoffiles

<< ") of File Names Were Specified" << Endl;

//move any flags to the beginning

Startoffiles =

Stable_partition (cmdlineParameters.begin (), cmdlineparameters.end (),

Isaflag ());

Cout << "Command Line Parameters After Stable Partition" << Endl;

For_each (cmdlineParameters.begin (), cmdlineparameters.end (), printit;

// splice any flags from the Original CmdlineParameters List Into Flags List.

Flags.SPLICE (Flags.begin (), CmdlineParameters,

CmdlineParameters.Begin (), startoffiles;

IF (! Flags.empty ()) {

Cout << "Flags Specified WERE:" << Endl;

FOR_EACH (Flags.Begin (), Flags.end (), Printit;

}

Else {

Cout << "NO Flags Were Specified" << Endl;

}

// Parameters List now Contains Only FileNames. Splice The Into FileNames List.

Filenames.SPLICE (filenames.begin (), cmdlineparameters,

CmdlineParameters.begin (), cmdlineParameters.end ());

IF (! filenames.empty ()) {

COUT << "Files Specified (in Order) WERE:" << ENDL;

FOR_EACH (filenames.begin (), filenames.end (), printit;

}

Else {

COUT << "no files were specified" << endl;

}

// Check if the help flag ws specified

IF (Flags.Begin (), Flags.end (), ishelpflag ())! = flags.end ()) {

COUT << "The Help Flag Was Specified" << endl;

}

// Open the files and do wherever you do

} Gives this command line:

TEST17 -W Linux -o is -w great output is:

The Wrong Number (3) of File Names WERE SpecifiedCommand Line Parameters After Stable Partition

-w

-o

-w

linux

Great

Flags Specified WERE:

-w

-o

-w

Files Specified (in Order) WERE:

linux

Great

Conclusion We just talk about what you can do with LIST. We did not explain the user-defined class of an object, although this is not difficult. If you understand the concept behind these algorithms just said, then the rest of the algorithms should have no problem. The most important thing to use STL is the basic theory. The key to STL is actually Iterator. The STL algorithm uses Iterator as a parameter, which points out a range, sometimes a range, sometimes two. The STL container supports Iterator, which is why we say list :: item, or list :: item, or list :: item. Iterator has a good inheritance. They are very useful. Some Itelator only supports read only a container, some only support, and some can only refer to, some are two-way. There are some iTerator support random access to a container. The STL algorithm requires an item as "power" if a container does not provide Iterator as "power", then this algorithm will not be able to compile. For example, the List container provides only two-way Iterator. The usual Sort () algorithm requires a random access to Iterator. That's why we need a special List member function sort (). To actually use STL, you need to carefully learn a variety of different items. You need to know that each container supports that type of Iterator. You still need to know that the algorithm requires that Iterator, you certainly need to know that you can have that Iterator.

转载请注明原文地址:https://www.9cbs.com/read-2245.html

9cbs

New Post(0)