The claim that unique_ptr performs as well as a raw pointer after optimization mostly applies only to the basic operations on a single pointer, such as creation, dereferencing, assignment of a single pointer and deletion. Those operations are defined simply enough that an optimizing compiler can usually make the required transformations such that the resulting … Read more
Use the 2-argument overload: many_things.resize(20, something(5));
As for the question as asked: It depends on the implementation. With MSVC 7.1 this: std:: cout << sizeof(std::vector<int>) << std::endl; gives me 16 (bytes). (3 pointers: begin, end, and end of capacity, plus an allocator) However it should be noted that the pointer-to-vector gives it a larger overhead: in both time and space in … Read more
std::vector<bool> is not directly at fault here. The performance difference is ultimately caused by your use of the signed 32-bit int type in your loops and some rather poor register allocation by the compiler. Consider, for example, your innermost loop: for (int j = i*i; j <= n; j += i) isPrime[j] = false; Here, … Read more
vector<T>::size() returns a value of type size_t, which is an unsigned type. Let’s say the vector passed in is empty and therefore the vector’s length is 0. nums.size() – 1 will cause integer underflow and you will actually be comparing 0 with a very large positive number. This will evaluate to true causing the loop … Read more
You can write your function like this: fn take<T>(mut vec: Vec<T>, index: usize) -> Option<T> { if vec.get(index).is_none() { None } else { Some(vec.swap_remove(index)) } } The code you see here (get and swap_remove) is guaranteed O(1). However, kind of hidden, vec is dropped at the end of the function and this drop operation is … Read more
std::remove_if comes to the rescue! 99 would be replaced by UnaryPredicate that would filter your delays, which I am going to use a lambda function for. And here’s the example: v.erase(std::remove_if( v.begin(), v.end(), [](const int& x) { return x > 10; // put your condition here }), v.end());
you have two copies of shared_ptr<A> in this case, one is the sharedptr variable and the other as an element in the vector. do this instead test.push_back(std::move(sharedptr)); note now the original sharedptr has it’s internal moved and no longer usable. The other thing is don’t do anything at all, this is a perfectly valid usage … Read more