X-Git-Url: https://oss.titaniummirror.com/gitweb/?a=blobdiff_plain;f=libstdc%2B%2B-v3%2Fdoc%2Fxml%2Fmanual%2Falgorithms.xml;fp=libstdc%2B%2B-v3%2Fdoc%2Fxml%2Fmanual%2Falgorithms.xml;h=ead0b8bbea7fea49ba69579aac11a0cbcb17ee5c;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=0000000000000000000000000000000000000000;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git diff --git a/libstdc++-v3/doc/xml/manual/algorithms.xml b/libstdc++-v3/doc/xml/manual/algorithms.xml new file mode 100644 index 00000000..ead0b8bb --- /dev/null +++ b/libstdc++-v3/doc/xml/manual/algorithms.xml @@ -0,0 +1,107 @@ + + + + + + + + + + ISO C++ + + + library + + + algorithm + + + + + + Algorithms + <indexterm><primary>Algorithms</primary></indexterm> + + + + + + The neatest accomplishment of the algorithms chapter is that all the + work is done via iterators, not containers directly. This means two + important things: + + + + + Anything that behaves like an iterator can be used in one of + these algorithms. Raw pointers make great candidates, thus + built-in arrays are fine containers, as well as your own iterators. + + + + + The algorithms do not (and cannot) affect the container as a + whole; only the things between the two iterator endpoints. If + you pass a range of iterators only enclosing the middle third of + a container, then anything outside that range is inviolate. + + + + + Even strings can be fed through the algorithms here, although the + string class has specialized versions of many of these functions + (for example, string::find()). Most of the examples + on this page will use simple arrays of integers as a playground + for algorithms, just to keep things simple. The use of + N as a size in the examples is to keep + things easy to read but probably won't be valid code. You can + use wrappers such as those described in the containers chapter to + keep real code readable. + + + The single thing that trips people up the most is the definition + of range used with iterators; the famous + "past-the-end" rule that everybody loves to hate. The + iterators + chapter of this document has a complete explanation of + this simple rule that seems to cause so much confusion. Once you + get range into your head (it's not that + hard, honest!), then the algorithms are a cakewalk. + + + + + + + + Mutating + + + <function>swap</function> + + + Specializations + + If you call std::swap(x,y); where x and y are standard + containers, then the call will automatically be replaced by a call to + x.swap(y); instead. + + This allows member functions of each container class to take over, and + containers' swap functions should have O(1) complexity according to + the standard. (And while "should" allows implementations to + behave otherwise and remain compliant, this implementation does in + fact use constant-time swaps.) This should not be surprising, since + for two containers of the same type to swap contents, only some + internal pointers to storage need to be exchanged. + + + + + + + + +