Better. std::array - He does not have any overhead of the type of release/redeployment of memory, storage of the number of elements, etc.

If I understand the code correctly, you're checking whether there is. array[i] Total dqand if there is, "replace him at the end of the line, by removing and putting him to the end. If that's what you're saying: for (int j = 0; j < dq.size(); j++) { deque<int>::iterator ii = find(dq.begin(), dq.end(), array[i]); if ( ii != dq.end() ) { cout &lt;&lt; "Page: " &lt;&lt; array[i] &lt;&lt; " has in memory" &lt;&lt; endl; dq.erase(ii); dq.push_front(array[i]); break; } else { dq.push_front(array[i]); dq.pop_back(); break; } } You already have a terator to indicate where to remove why to reshape from. int del = dq.at(array[i]); dq.erase(dq.begin()+del); ? (I understand this place is falling)By the way, placing at the end of the queue through removal/supply is not optimal, it's easier to do. deque<int>::iterator ii = find(dq.begin(), dq.end(), array[i]); if ( ii != dq.end() ) { cout &lt;&lt; "Page: " &lt;&lt; array[i] &lt;&lt; " has in memory" &lt;&lt; endl; deque&lt;int&gt;::reverse_iterator temp = dq.rbegin(); // получить итератор на последний элемент std::swap(*ii, *temp); // обменять значения итераторов break; }

I had a little experiment here. ♪ ♪Randomly created vector from N Tyres with positive and negative values using different containers:size_t usingSet(const std::vector<int>& input) { std::set<unsigned> unique; for(int item : input) { unique.insert(abs(item)); } return unique.size(); } size_t usingHash(const std::vector<int>& input) { std::unordered_set<unsigned> unique; unique.reserve(input.size()); for(int item : input) { unique.insert(abs(item)); } return unique.size(); } size_t usingVec(const std::vector<int>& input) { std::vector<unsigned> uniq; uniq.reserve(input.size()); for(int item : input) { uniq.push_back(abs(item)); } sort(uniq.begin(),uniq.end()); return unique(uniq.begin(),uniq.end()) - uniq.begin(); } 1,000 times we'll find the number of unique elements. It's time in microseconds, it's clear that a plus-minus... but it's good for evaluation. I don't think it's hard for me to round it up in my mind in a few milliseconds. Set Hash Vector N = 10: 790 1256 253 N = 100: 8304 8243 1192 N = 1000: 130070 78354 27573 N = 10000: 1543452 757059 498093 N = 100000: 14545110 4232742 6182957 N = 1000000: 127603400 27039847 61045621 So the vector is starting to lose between 10 and 100,000 Hash. For small values, the hash loses even set'Uh, compared to 100 elements. Next. set I'm sure he's losing everything. O(N*ln N)but also because of the large number of redistributions of memory (member) reserve() He doesn't have a hex and a vector.As didn't come up with anything to say goodbye to the memory consumption, but it's clear that the vector will give it to everyone.Words, the saddest is setit doesn't make sense at all. With a small size of tens of thousands, it's best to take a vector, and then watch what's more important is speed or memory.All this on Visual C+ 2015, 32 bit. For Visual C++ 2010, 32 bit the advantages of the vector are still brighter: And the Hash is losing, Set Hash Vector N = 10: 813 1459 223 N = 100: 8688 10795 1448 N = 1000: 135905 102716 29086 N = 10000: 1623786 1068878 519483 N = 100000: 18334735 8822607 6316194 N = 1000000: 179540082 83667899 61899536 Who wants to repeat for other compilators - you are welcome. ♪ ♪By the way, the vector can still be optimised because we need to. Number unique elements - may not be used unique with his remembrance, but simply to go through and count the elements that neighbour doesn't have the same.Update♪ I assumed that the number of coincidences was small; I was corrected in the comments. I didn't do the number of unique elements in myser-- my hand's not lying, but I filled up the mass:for(int i = 0; i < N; ++i) src.push_back((rand()%(N/5))*(i%2 ? 1 : -1)); I mean, there's plenty of coincidences, but still unique elements-- O(N)The results for 2015 are as follows: Set Hash Vector N = 10: 279 760 229 N = 100: 2693 2785 1185 N = 1000: 53087 24940 26121 N = 10000: 806965 273205 472123 N = 100000: 12350458 3440321 6006227 The border was slightly downward, but the principle remained: set It's flying, but it's hitting the hesh up to 100, and it's starting to run around 1,000, not 10000.To the limit when all N Elements - units, results almost paradoxical: Set Hash Vector N = 10: 200 895 219 N = 100: 888 1840 493 N = 1000: 7676 10020 2778 N = 10000: 73524 102685 25881 N = 100000: 733058 1167238 259100 N = 1000000: 7396809 11645557 3561249 vector, and only vector! Hash loses even. setHuh.All right, there's no time for experiments; who wants to - go on:Update2 - In his "Optimized C++" Gunterot says, unordered_set Although it has an effect, it is not exactly the one to be expected to read how it is praised: The hash table std::unordered_map is faster than std::map, but not by the order-of-magnitude difference that its reputation suggests♪

It's a consequence of an old-fashioned conflict of interest between the Funkzims. std::list::size() and std::list::splice()♪ If partial splice() one std::list in other cases with the requirement of a constant time for such splice() (i.e. simply transcend the edges of the range from one list to another), then it would not be possible to know at once the new dimensions of the container originator and the recipient container, i.e., how many of the components have been removed. Therefore, the requirement Constant Time splice() leads to demand linear Time size() - The elements in both containers will have to be recalculated.If, on the contrary, demand a time constant size() (i.e., actually demand a stored size), then you have to accept a slower one. splice()which, in the above-mentioned situation, will calculate the new dimensions of containers in linear time.In C+98, the matter was left open. Implementation was allowed to choose where, in their view, time was more important - in the size() or splice()♪At C++11, we decided to make a left-hand decision: we make a stored size, guaranteed size() For the time at stake, and so to be, we agree to linear time. splice()♪ That is why the difference between C++98 and C++11 is explained.P.S. Implementation of the standard C++ library in GCC initially followed the fast track splice() and slow size()♪ After C++11 insisted otherwise, GCC adjusted its implementation std::list, but came to the binary incompatibility of library versions due to the addition of a new field std::list♪ The change was downloaded right now. std::list GCC does not meet C++11 requirements. std::list::size() There's a linen.

It's just an example. ♪ ♪struct Item { int a, b, c; Item(int a,int b,int c):a(a),b(b),c(c){} }; int main(int argc, const char * argv[]) { vector<Item> x; // x.push_back(1,2,3); <- не скомпилируется! x.emplace_back(1,2,3); } As you can see, push_back'I need an object of the type of element (or the input). Here. emplace'It's just the arguments, as a designer♪ P.S. Clearly, this designer could be a replicator: So...x.emplace_back(Item(0,1,2)); It works, too.

So there's a class table and a class Record. class Record{ public: Record(unsigned long dwDblNum, unsigned long dwStrNum){ if (dwDblNum) pDblTab=new double[dwDblNum]; if (dwStrNum) pStrTab=new string[dwStrNum]; } ~Record(){ if(pStrTab) delete[] pStrTab; if(pDblTab) delete[] pDblTab; } string *pStrTab; double *pDblTab; }; Class Table:class Table{ public: Table():dwRowsNum(0), dwColumnsNum(0){}; ~Table(){}; void InitTable(unsigned long dwRowsNumber, unsigned long dwColumnsNumber, unsigned short *pTypeFields); unsigned long dwRowsNum; unsigned long dwColumnsNum; vector <Record> vecRecord; }; InitTable serves to initiate the table, parameters:dwRowsNumber - Количество строк dwColumnsNumber - Количество столбцов pTypeFields - Массив соответсвия столбца конкретному типу (double-1, string-2)

Problem is, you need to identify a whole series of functions. Init♪ That's what you're supposed to use.Got the code in a compilable species, but there's still time errors (NULL redesign), make it right.#include <cstddef> template <typename T, typename ... Args> class MyVec { public: struct element { T cell; element* next; }; element* head; MyVec(T first, Args ... arg) { element *list = new element(); list-&gt;cell = first; list-&gt;next = NULL; head = list; Init(arg ...); } template &lt;typename TInner, typename ... ArgsInner&gt; void Init(TInner now, ArgsInner ... arg) { element *list = new element(); list-&gt;cell = now; element* next = head; while (!next-&gt;next) next = next-&gt;next; next = list; list-&gt;next = NULL; Init(arg ...); } void Init(T now) { element *list = new element(); list-&gt;cell = now; element* next = head; while (!next-&gt;next) { next = next-&gt;next; } next = list; list-&gt;next = NULL; } }; int main() { MyVec<int, int, int> p2(4, 5, 6); }

I thought first, faster than one cycle, or ready algorithm, to find the maximum element and then another cycle of position. But I think your algorithm is the best option. He works one way through the mass cycle. The grading option falls off at once, the grading works longer than one passage through the cycle, and it's gonna have to keep the items... I don't think so.

Well, that makes sense. What does the function want? Okay, he got it. But as a function find_first_not_of Find out where the end of this body is? That's right, zero symol. Where's in your body? cc No sign? And what happens when it's found is unknown. If you don't believe me, put it in after. cc[6] = (char)13; challenge strlen(cc) and look at the size of the line. He's definitely not gonna be 7. What do we do? Write right!char *cc = new char[8]; cc[0]= ' '; cc[1] = (char)8; cc[2] = (char)9; cc[3] = (char)10; cc[4] = (char)11; cc[5] = (char)12; cc[6] = (char)13; cc[7] = (char)0; TrimLeft(s, сс); Of course, it's better to create a static memory, not to create every time.

http://www.cplusplus.com/reference/string/string/substr/ Help you:string source = "maybe"; string result = source.substr(source.size() - 2, 2); cout << result << "\n"; // output: be UPD. With the vector:// вектор исходных слов vector<string> words; words.push_back("maybe"); words.push_back("go"); words.push_back("to be"); words.push_back("banana"); // вектор для окончаний vector<string> ends; // добавление окончаний слов for (auto it = words.begin(); it != words.end(); it++) { string &s = *it; // можно добавить ещё проверку на достаточную длину слова ends.push_back(s.substr(s.size() - 2, 2)); } // вывод for (auto it = ends.begin(); it != ends.end(); it++) { cout << *it << " "; } cout << "\n"; // output: be go be na

Let's start with what free It's categorically counter-propelled. It's a s-shot function that only works in pairs with malloc♪erase is a function that removes elements from the vector. But since you have a vector indicatorsthe memory they're pointing out will not be released.So I have to go before. erase Run and free the objects themselves. If you want everything to be done safely and simple, use it. unique_ptr (if the vector is sole:) owns objects; if not, shared_ptr<>)

Use a comparator to compare lines without registering:auto cmp = [](const std::string& a, const std::string& b) { return boost::ilexicographical_compare(a, b); }; std::sort(begin(strList), end(strList), cmp);

In this case, you, after the entry of the form line ключ-значениеpass it and put it in the map. I mean, you only have one pair on the map. For this couple, you create a terator. it1♪ After which you start over the cycle to retract all the map values by the heterator it♪ But you have everything on your map. One meaning. And it It will always be equal. it1♪ That's why. Always. The block will be executed. elsewhich results in the removal of the vapour ключ-значение From your map. You remove the only thing that your terator refers to, which is your cycle. Iterator it becomes invalid. What's he gonna take and how long the cycle lasts, nobody's gonna guess. Also, different C+++ versions return different values using the method erase in cards.If you need to keep the card with the highest value, first of all, you don't need multimap. That and the difference between map and multimap is only one couple with one key. Second, to find the key in the map (see). parseYou don't need a cycle. There's a ready. find♪ Also, if you're using C++ and his standard libraries, please draw attention to stoi (e.g.) instead atoi♪I don't know what role your sorting function should play. But if she has to remove the couples from the map, which is classified in reverse, she's doing it.In general, the adjusted code looks http://ideone.com/Sf4CMI :#include<iostream> #include<string> #include<map> #include<set> void parse(std::string str, std::map<int, int> &myMap) { size_t pos = str.find('-'); std::string str1 = str.substr(0, pos); str = str.substr(pos + 1, (str.size() - 1)); if(myMap.find(std::stoi(str1))!=myMap.end() || myMap[std::stoi(str1)] < std::stoi(str)) myMap[std::stoi(str1)] = std::stoi(str); } void sort(std::map<int, int> &myMap) { std::set<int>mySet; for(auto&it_map:myMap)mySet.insert(it_map.second); for (auto it_set = mySet.crbegin(); it_set != mySet.crend(); ++it_set) for(auto&it_map:myMap) if (*it_set == it_map.second) std::cout << it_map.first << "-" << *it_set << "\n"; } int main() { std::map<int, int>myMap; std::set<int>myset; for (int i = 0; i < 5; ++i) { std::string str; std::cin >> str; parse(str, myMap); } sort(myMap); return 0; }

The standard defines range-based for loop equivalent to the following code:{ auto && __range = range - init; for(auto __begin = begin - expr, __end = end - expr; __begin != __end; ++__begin) { for-range-declaration = *__begin; statement } } As you can see, iterators are used inside, so inside the cycle, No. Use a code that can make iterators invalid. In answering your question, no, it is not possible to remove elements from the C++ of containers where the operation results in invalid heterators.

The mistakes are coming because you're using a constant terator.

It can be done about:#include <unordered_map> #include <iostream> #include <unordered_set> int main() { std::unordered_map<size_t, size_t> map; for(size_t i = 0; i < 500; ++i) map.emplace(i, i); for(size_t i = 0; i < map.bucket_count(); i++) { if(map.cbegin(i) == map.cend(i)) continue; std::cout << "Bucket for keys {"; std::unordered_set<size_t> processedKeys; for(auto it = map.cbegin(i); it != map.cend(i); ++it) { auto key = it->first; if(processedKeys.emplace(key).second) std::cout << key << ","; } std::cout << "\b}: "; for(auto it = map.cbegin(i); it != map.cend(i); ++it) std::cout << it->second << " "; std::cout << "\n"; } }

You put six elements in the container. The vector's capacity-building strategy is quite complex. One of the strategies is to increase the container &apos; s capacity in double stages.Specific strategy https://stackoverflow.com/questions/11560904/vector-memory-allocation-strategy ♪The purpose of such behaviour is to reduce the number of redistribution operations as they are very time-consuming.

std::sort The third parameter accepts something that can be caused as a function with two parameters. http://en.cppreference.com/w/cpp/concept/Compare ) Not three, not one, exactly 2. Why 2? Because for the sorting, for one operation, you need to compare two elements.Now with regard to the type of parameters: in order to correctly compare the two elements of the body, the type of function parameters shall be compatible with the type of cell. That's why you're in code and used. int♪ But you can use it. long and any other type that will give the correct result of the comparison. But if you do the parameters of the function, for example, std::stringYou'll get a mistake in the compilation.For a better understanding, I suggest that the following example be considered:#include <iostream> void myFunc(int x, int y) { std::cout << "x: " << x << ", y:" << y << "\n"; } template<typename Fun> void superFunction(Fun fun) { fun(156, 11); } int main(int argc, char* argv[]) { superFunction(myFunc); } Here, superFunction Something like that. std::sortshe accepts something that can be caused with two parameters, and each parameter is int♪ It's called something inside. Transferring functions main ours. myFunc We're getting a challenge, indirectly through superFunc♪ That's how things go in. std::sort, only where the transferred function is used to compare the two elements and two members of the mass are transferred to this function instead of the constant as in my code.

Algorithm std::merge Demands that the reference components ranges be quashed. The result is also a separate sequence of elements.Here's the demonstration program.#include <iostream> #include <vector> #include <algorithm> using namespace std; int main () { vector<int> va, vb, vc(6); va.push_back(10); va.push_back(100); va.push_back(2); for ( int x : va ) std::cout &lt;&lt; x &lt;&lt; ' '; std::cout &lt;&lt; std::endl; std::cout &lt;&lt; std::endl; vb.push_back(2); vb.push_back(50); vb.push_back(30); for ( int x : vb ) std::cout &lt;&lt; x &lt;&lt; ' '; std::cout &lt;&lt; std::endl; std::cout &lt;&lt; std::endl; std::sort( va.begin(), va.end() ); std::sort( vb.begin(), vb.end() ); merge(va.begin(), va.end(), vb.begin(), vb.end(), vc.begin()); // здесь ошибка выполнения for ( int x : vc ) std::cout &lt;&lt; x &lt;&lt; ' '; std::cout &lt;&lt; std::endl; std::cout &lt;&lt; std::endl; return 0; } Its conclusion to the console:10 100 2 2 50 30 2 2 10 30 50 100 Standard C++ (25.4 Sorting and related operations)3 For all algorithms that take Compare, there is a version that uses operator instead. That is, comp(*i,*j)!= false defaults to *i PER *j ! For algorithms other than those described in 25.4.3 to work correctly, comp has to induce a strict weak ordering on the values♪

The categories of iterators determine the actions that can be done with the heterator.If iterators used virtual functions, the categories of iterators would be abstract interfaces that would inherit from each other:интерфейс InputIterator { ... }; интерфейс OutputIterator { ... }; интерфейс ForwardIterator : InputIterator, OutputIterator { ... }; интерфейс BidirectionalIterator : ForwardIterator { ... }; интерфейс RandomAccessIterator : BidirectionalIterator { ... }; InputIterator (input)Copying, appropriation.Equity comparisons == and !=♪Increments: ++iter and iter++♪Reading name: *iter and iter->mwhich prohibits the recording: *iter = value;♪An example of the inlet heater is the reading terator from the flow: std::istream_iterator♪OutputIterator (exit)Copying, appropriation.Increments: ++iter and iter++♪Name for recording: *iter = value and *iter++ = valueand it's forbidden to read.An example of the heterator output is the flow terator: std::ostream_iterator♪ForwardIterator (direct)All operations InputIterator and OutputIterator♪Requirement Multidisciplinaryif: i1 == i2♪ ++i1 == ++i2, i.e. the terator can be copied, and they'll have the sequence many times.Direct iterators are single-linkeders, for example, std::forward_list♪BidirectionalIterator (bilateral)All operations ForwardIterator♪Decrement: --iter♪ iter--♪ *iter--♪Example: terers of bi-linked listsstd::listtreesstd::set)RandomAccessIterator (voluntary access)All operations BidirectionalIterator♪Comparison operations: i1 < i2♪ i1 > i2♪ i1 <= i2♪ i1 >= i2♪Accumulation/exhaustion with number: iter + n♪ iter += n♪ iter - n♪ iter -= n♪Heterogeneity: i2 - i1♪Indication: iter[n]♪Example: terators of massesstd::vectorthe signs.