The current std::vector doesn’t provide any capability or interface to take ownership of previously allocated storage. Presumably it would be too easy to pass a stack address in by accident, allowing more problems than it solved. If you want to avoid copying into a vector, you’ll either need to use vectors through your entire call … Read more
If you know what you’re doing, you can make a vector of references using std::reference_wrapper: #include <functional> #include <vector> int main() { std::vector<std::reference_wrapper<int>> iv; int a = 12; iv.push_back(a); // or std::ref(a) // now iv = { 12 }; a = 13; // now iv = { 13 }; } Note of course that any … Read more
Retrieving an element by index is an O(n) operation for linked list, which is what std::list is. So it was decided that providing operator[] would be deceptive, since people would be tempted to actively use it, and then you’d see code like: std::list<int> xs; for (int i = 0; i < xs.size(); ++i) { int … Read more
No, you cannot put it into decltype because A lambda-expression shall not appear in an unevaluated operand You can do the following though auto n = [](int l, int r) { return l > r; }; std::set<int, decltype(n)> s(n); But that is really ugly. Note that each lambda expression creates a new unique type. If … Read more
Well, in C++0x you can… In C++03, there is a paragraph 23.1[lib.containers.requirements]/3, which says The type of objects stored in these components must meet the requirements of CopyConstructible types (20.1.3), and the additional requirements of Assignable types. This is what’s currently preventing you from using const int as a type argument to std::vector. However, in … Read more
A short list might be: Avoid memory leaks through use shared pointers to manage memory allocation and cleanup Use the Resource Acquisition Is Initialization (RAII) idiom to manage resource cleanup – especially in the presence of exceptions Avoid calling virtual functions in constructors Employ minimalist coding techniques where possible – for example, declaring variables only … Read more
First define the lambda object, then pass it to the template’s type using decltype and also pass it directly to the constructor. auto comp = []( adjist a, adjlist b ) { return a.second > b.second; }; priority_queue< adjlist_edge , vector<adjlist_edge>, decltype( comp ) > adjlist_pq( comp );
As a first remark, I wouldn’t call it ObjectArray if it is a map and not an array. Anyway, you can insert objects this way: ObjectArray myMap; myMap.insert(std::make_pair(0, std::unique_ptr<Class1>(new Class1()))); Or this way: ObjectArray myMap; myMap[0] = std::unique_ptr<Class1>(new Class1()); The difference between the two forms is that the former will fail if the key 0 … Read more
If all you want to do is remove trailing zeros, well, that’s easy. std::string str = std::to_string (f); str.erase ( str.find_last_not_of(‘0’) + 1, std::string::npos ); str.erase ( str.find_last_not_of(‘.’) + 1, std::string::npos );
You can specify a custom sort predicate. In C++11 this is best done with a lambda: typedef std::pair<int, int> ipair; std::list<ipair> thelist; thelist.sort([](const ipair & a, const ipair & b) { return a.first < b.first; }); In older versions of C++ you have to write an appropriate function: bool compFirst(const ipair & a, const ipair … Read more