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
The right way for a template function to accept any std::vector by const& is: template<typename T, typename A> void some_func( std::vector<T,A> const& vec ) { } the second argument is the “allocator”, and in some advanced usage of std::vector it will not be the default one. If you just accept std::vector<T>, your some_func will reject … Read more
If we look at the cppreference.com entry for std::vector::~vector it says: Destructs the container. The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed. so no you don’t have to call clear. If we want to go to the … Read more
The short answer is that I think @BenVoigt is basically correct. In the description of reserve (§23.3.6.3/2), it says: If an exception is thrown other than by the move constructor of a non-CopyInsertable type, there are no effects. [And the description of resize in §23.3.6.3/12 requires the same.] This means that if T is CopyInsertable, … Read more
Your question is based on a false premise, namely that a default-constructed std::vector<T> will perform a [zero-length] allocation. There is literally no reason for it to do so. A fresh vector should have capacity zero (though this is required by sanity, not by the standard). As such, your goal is already inherently satisfied. To be … Read more
No. The elements of a vector are stored in a dynamically allocated block of memory; otherwise, the capacity of the vector could not increase. The vector object just holds a pointer to that block. The requirement that the elements be stored sequentially applies only to the elements themselves, and not to any dynamically allocated members … Read more
Your code has undefined behavior. In void set(){ X = 3; cout << “Before, X = ” << X << endl; nodes.push_back(Node()); cout << “After, X = ” << X << endl; } The access to X is really this->X and this is a pointer to the member of the vector. When you do nodes.push_back(Node()); … Read more
Yes, this is perfectly safe to swap vectors of the same type. Vector under the hood is just a few pointers pointing to the data the vector uses and “end” of the sequence. When you call swap you just exchange those pointers between the vectors. You don’t need to worry that the vectors are the … Read more
std::vector performs bounds checking when the at() member function is used, but it does not perform any checks with operator[]. When out of bounds operator[] produces undefined results.
You have no right to get a segmentation fault. For that matter, a segmentation fault isn’t even part of C++. Your program is removing all elements from the vector, and you’re illegally accessing the container out of bounds. This is undefined behaviour, which means anything can happen. And indeed, something happened.