内容简介:So in ye olde days, before C++11 and move semantics, it was common for functions to use mutable references to pass container-content to the caller, like this:and you would often use it like this:Basically trading expressiveness and convenience for speed/ef
So in ye olde days, before C++11 and move semantics, it was common for functions to use mutable references to pass container-content to the caller, like this:
void random_between(std::vector<int>& out, int left, int right, std::size_t N) { std::uniform_int_distribution<> distribution(left, right); for (std::size_t i = 0; i < N; ++i) out.push_back(distribution(rng)); }
and you would often use it like this:
std::vector<int> numbers; random_between(numbers, 7, 42, 10);
Basically trading expressiveness and convenience for speed/efficiency.
Convenience is king
Now obviously, those days are over. With move-semantics and guaranteed copy-elision backing us up, it is usually fine to just return the filled container, like this:
std::vector<int> random_between(int left, int right, std::size_t N) { std::vector<int> out; std::uniform_int_distribution<> distribution(left, right); for (std::size_t i = 0; i < N; ++i) out.push_back(distribution(rng)); return out; }
Now you no longer have to initialize the container to use this function and the function also became pure, clearly differentiating between its inputs and outputs.
Mostly better?
However, there is a downside: Before, the function could be used to append multiple runs into the same container, like this:
std::vector<int> numbers; for (int i = 0; i < 5; ++i) random_between(numbers, 50*i + 7, 50*i + 42, 10);
That use case suddenly became a lot harder. Also, what if you want to keep your vector around and just .clear()
it before calling the function again later, to save allocations? That’s also no longer possible. I am not saying that these two use cases should make you prefer the old variant, as they tend not to happen very often. But when they do, it’s all the more annoying. So what if we could have your cake and eat it, too?
A Compromise
How about this:
std::vector<int> random_between(int left, int right, std::size_t N, std::vector<int> out = {}) { std::uniform_int_distribution<> distribution(left, right); for (std::size_t i = 0; i < N; ++i) out.push_back(distribution(rng)); return out; }
Now you can use it to just append again:
std::vector<int> numbers; for (int i = 0; i < 5; ++i) numbers = random_between( 50*i + 7, 50*i + 42, 10, std::move(numbers));
But you can also use it in the straightforward way, for the hopefully more common case:
auto numbers = random_between( 50*i + 7, 50*i + 42, 10);
Now you should definitely not do this with all your functions returning a container. But it is a nice pattern to have up your sleeve when the need arises. It should be noted that passing a mutable reference can still be faster in some cases, as that will save you two moves. And you can also add a container-returning facade variant as an overload, but I think this pattern is a very nice compromise that can be implemented by moving a single variable to the parameter list and defaulting it. It keeps 99% of the use cases identically to the original container-returning variant, while making the “append” use slightly more verbose, but also more expressive.
以上就是本文的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,也希望大家多多支持 码农网
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
Data Structures and Algorithms in Java
Michael T. Goodrich、Roberto Tamassia / Wiley / 2010-01-26 / USD 177.41
* This newest edition examines fundamental data structures by following a consistent object-oriented framework that builds intuition and analysis skills of data structures and algorithms * Presents ne......一起来看看 《Data Structures and Algorithms in Java》 这本书的介绍吧!