For the start, std::mutex can not be copied or moved, therefore you are forced to use some kind of indirection. Since you want to store mutex in a vector, and not copy it, I would use std::unique_ptr. vector<unique_ptr<T>> does not allow certain vector operations (such as for_each) I am not sure I understand that sentence. … Read more
24.2.1/7 Most of the library’s algorithmic templates that operate on data structures have interfaces that use ranges. A range is a pair of iterators that designate the beginning and end of the computation. A range [i,i) is an empty range; in general, a range [i,j) refers to the elements in the data structure starting with … Read more
Not only is x + y + z = 0, but the absolute values of x, y and z are equal to twice the radius of the ring. This should be sufficient to identify every hexagon on each successive ring: var radius = 4; for(var i = 0; i < radius; i++) { for(var j … Read more
There’s a swap method on slices: data.swap(i, j). The original code doesn’t work because the language requires that &muts do not alias, that is, if a piece of data is accessible via an &mut, then there must be no other way to use that data. In general, for successive indexes data[i], data[j], the compiler cannot … Read more
Some of the generic algorithms that also work on lists use it. This is an example of a general principle: if you provide accessors for all the semantics you support, not just the implementation you support, it is easier to write generically and therefore easier to reuse code.
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
You need to use something like readerThreads.push_back(move(th)); This will make th an rvalue, and cause the move ctor to be called. The copy ctor of thread was disabled by design (see Anthony Williams’ C++ Concurrency In Action).
In terms of sizing, there are two values of interest for a std::vector: size, and capacity (accessed via .size() and .capacity()). .size() is the number of elements that are contained in the vector, whereas .capacity() is the number of elements that can be added to the vector, before memory will be re-allocated. If you .push_back() … Read more
Maybe someone is searching for an answer, like me for two days now: // Draw a path and hide it: var root = paper.path(‘M0 50L30 50Q100 100 50 50’).hide(); var length = root.getTotalLength(); // Setup your animation (in my case jQuery): element.animate({ ‘to’: 1 }, { duration: 500, step: function(pos, fx) { var offset = … Read more
Something on these lines: template<class Y> struct s { enum {dims = 0}; }; template<class Y> struct s<std::vector<Y>> { enum {dims = s<Y>::dims + 1}; }; Then for example, std::vector<std::vector<double> > x; int n = s<decltype(x)>::dims; /*n will be 2 in this case*/ Has the attractive property that all the evaluations are at compile time.