blocks|key|1419066|text|如果你想成为真正的核心，你可以使用boost::tuple。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1419067|tuple<int,+int,+double>+add_multiply_divide(int+a,+int+b)+{
++return+make_tuple(a%2Bb,+a*b,+double(a)/double(b));
}|code-block|syntax|javascript|1419068|但是，由于您的所有对象似乎都是单一的、非多态类型，那么std::vector就很好了。如果您的类型是多态的(基类的继承类)，那么您将需要一个指针向量，并且需要记住在丢弃向量之前删除所有分配的对象。|1419069|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_37_0/libs/tuple/doc/tuple_users_guide.html^0|H|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

If you want to be really hardcore, you could use <a href="http://www.boost.org/doc/libs/1_37_0/libs/tuple/doc/tuple_users_guide.html" rel="nofollow noreferrer">boost::tuple</a>.

<pre><code>tuple&lt;int, int, double&gt; add_multiply_divide(int a, int b) {
 return make_tuple(a+b, a*b, double(a)/double(b));
}
</code></pre>

But since it seems all your objects are of a single, non-polymorphic type, then the std::vector is all well and fine.
If your types were polymorphic (inherited classes of a base class) then you'd need a vector of pointers, and you'd need to remember to delete all the allocated objects before throwing away your vector.

blocks|key|1419136|text|我能看到的唯一一件事就是你强行复制了你返回的列表。这样做会更有效率：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419137|++void+DoSomething(const+std::vector<SomeType>&+in,+std::vector<SomeType>&+out)
++{
++...
++//+no+need+to+return+anything,+just+modify+out
++}|code-block|syntax|javascript|1419138|因为您传入了想要返回的列表，所以避免了额外的副本。|1419139|编辑:这是一个旧回复。如果您可以使用具有move语义的现代C%2B%2B编译器，则不必担心这一点。当然，如果你要返回的对象没有移动语义，这个答案仍然适用。|1419140|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The only thing I can see is that your forcing a copy of the list you return. It would be more efficient to do something like:

<pre><code> void DoSomething(const std::vector&lt;SomeType&gt;&amp; in, std::vector&lt;SomeType&gt;&amp; out)
 {
 ...
 // no need to return anything, just modify out
 }
</code></pre>

Because you pass in the list you want to return, you avoid the extra copy.

Edit: This is an old reply. If you can use a modern C++ compiler with move semantics, you don't need to worry about this. Of course, this answer still applies if the object you are returning DOES NOT have move semantics.

blocks|key|1419193|text|在许多情况下，最好使用std::vector。它保证使用连续的内存，因此对L1缓存来说是令人愉快的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419194|你应该知道当你的返回类型是std::vector时会发生什么。在幕后发生的事情是std::vector是递归复制的，所以如果SomeType的复制构造函数开销很大，那么"return语句“可能是一个冗长且耗时的操作。|1419195|如果您正在搜索并在列表中插入大量内容，您可以查看std::set以获得对数时间复杂度，而不是线性时间复杂度。(std::vectors插入是常量，直到超出其容量为止)。|1419196|你是说你有很多“管道函数”...听起来std::transform是一个很好的场景。|1419197|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Using a std::vector is the preferably way in many situations. Its guaranteed to use consecutive memory and is therefor pleasant for the L1 cache. 

You should be aware of what happends when your return type is std::vector. What happens under the hood is that the std::vector is recursive copied, so if SomeType's copy constructor is expensive the "return statement" may be a lengthy and time consuming operation.

If you are searching and inserting a lot in your list you could look at std::set to get logarithmic time complexity instead of linear. (std::vectors insert is constant until its capacity is exceeded). 

You are saying that you have many "pipe functions"... sounds like an excellent scenario for std::transform.

blocks|key|1634064|text|返回一个对象列表的另一个问题(而不是像BigSandwich指出的那样在一个或两个列表中工作)是，如果您的对象有复杂的复制构造函数，这些构造函数将为容器中的每个元素调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634065|如果你有1000个对象，每个对象都引用了一大块内存，并且他们在对象a，b；a=b上复制了那个内存，那就是1000个内存副本，仅仅是为了返回包含在容器中的内存。如果你仍然想直接返回一个容器，考虑一下本例中的指针。|1634066|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Another problem with returning a list of objects (opposed to working on one or two lists in place, as BigSandwich pointed out), is if your objects have complex copy constructors, those will called for each element in the container. 

If you have 1000 objects each referencing a hunk of memory, and they copy that memory on Object a, b; a=b; that's 1000 memcopys for you, just for returning them contained in a container. If you still want to return a container directly, think about pointers in this case.

blocks|key|1634108|text|如果你真的需要一个新的列表，我会简单的返回它。在大多数情况下，返回值优化将不会处理不必要的副本，并且您的代码将保持非常清晰。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634109|也就是说，获取列表并返回其他列表确实是C%2B%2B中的python编程。|1634110|对于C%2B%2B来说，更合适的范例是创建接受一系列迭代器并改变底层集合的函数。|1634111|例如：|1634112|void+DoSomething(iterator+const+&+from,+iterator+const+&+to);|code-block|syntax|javascript|1634113|(迭代器可能是一个模板，这取决于你的需求)|1634114|然后，链接操作就是在begin()，end()上调用连续的方法。如果你不想改变输入，你可以先自己复制一份。|1634115|std::vector+theOutput(inputVector);|1634116|这一切都来自于C%2B%2B的“不要为你不需要的东西付费”的哲学，你只会在你真正想要保留原件的地方创建副本。|1634117|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|13|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

If you really need a new list, I would simply return it. Return value optimization will take care of no needless copies in most cases, and your code stays very clear. 
That being said, taking lists and returning other lists is indeed python programming in C++.

A, for C++, more suitable paradigm would be to create functions that take a range of iterators and alter the underlying collection.

e.g.

<pre><code>void DoSomething(iterator const &amp; from, iterator const &amp; to);
</code></pre>

(with iterator possibly being a template, depending on your needs)

Chaining operations is then a matter of calling consecutive methods on begin(), end().
If you don't want to alter the input, you'd make a copy yourself first.

<pre><code>std::vector theOutput(inputVector);
</code></pre>

This all comes from the C++ "don't pay for what you don't need" philosophy, you'd only create copies where you actually want to keep the originals.

blocks|key|1634162|text|我会使用通用的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634163|template+<typename+InIt,+typename+OutIt>
void+DoMagic(InIt+first,+InIt+last,+OutIt+out)
{
++for(;+first+!=+last;+%2B%2Bfirst)+{
++++if(IsCorrectIngredient(*first))+{
++++++*out+=+DoMoreMagic(*first);
++++++%2B%2Bout;
++++}
++}
}|code-block|syntax|javascript|1634164|现在你可以调用它了|1634165|std::vector<MagicIngredients>+ingredients;
std::vector<MagicResults>+result;

DoMagic(ingredients.begin(),+ingredients.end(),+std::back_inserter(results));|1634166|您可以轻松地更改使用的容器，而无需更改使用的算法，而且返回容器也不会产生任何开销。|1634167|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I'd use the generic approach:

<pre><code>template &lt;typename InIt, typename OutIt&gt;
void DoMagic(InIt first, InIt last, OutIt out)
{
 for(; first != last; ++first) {
 if(IsCorrectIngredient(*first)) {
 *out = DoMoreMagic(*first);
 ++out;
 }
 }
}
</code></pre>

Now you can call it

<pre><code>std::vector&lt;MagicIngredients&gt; ingredients;
std::vector&lt;MagicResults&gt; result;

DoMagic(ingredients.begin(), ingredients.end(), std::back_inserter(results));
</code></pre>

You can easily change containers used without changing the algorithm used, also it is efficient there's no overhead in returning containers.

blocks|key|1419385|text|它的工作原理非常简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419386|list<int>+foo(void)
{
++++list<int>+l;+
++++//+do+something
++++return+l;
}|code-block|syntax|javascript|1419387|现在正在接收数据：|1419388|list<int>+lst=foo();|1419389|是完全优化的，因为编译器知道如何优化lst的构造函数。并且不会造成副本。|1419390|其他方法，可移植性更好：|1419391|list<int>+lst;
//+do+anything+you+want+with+list
lst.swap(foo());|1419392|结果:+foo已经过优化，所以返回值是没有问题的。当您调用swap时，您将lst的值设置为new，因此不复制它。现在，lst的旧值被“交换”并销毁。|1419393|这是做这项工作的有效方法。|1419394|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

It works very simple. 

<pre><code>list&lt;int&gt; foo(void)
{
 list&lt;int&gt; l; 
 // do something
 return l;
}
</code></pre>

Now receiving data:

<pre><code>list&lt;int&gt; lst=foo();
</code></pre>

Is fully optimal because compiler know to optimize constructor of lst well. and 
would not cause copies.

Other method, more portable:

<pre><code>list&lt;int&gt; lst;
// do anything you want with list
lst.swap(foo());
</code></pre>

What happens: foo already optimized so there is no problem to return the value. When
you call swap you set value of lst to new, and thus do not copy it. Now old value
of lst is "swapped" and destructed.

This is the efficient way to do the job.

It's been a while since I programmed in C++, and after coming from python, I feel soooo in a straight jacket, ok I'm not gonna rant.

I have a couple of functions that act as "pipes", accepting a list as input, returning another list as output (based on the input), 

this is in concept, but in practice, I'm using <code>std::vector</code> to represent the list, is that acceptable?

further more, I'm not using any pointers, so I'm using <code>std::vector&lt;SomeType&gt; the_list(some_size);</code> as the variable, and returning it directly, i.e. <code>return the_list;</code>

P.S. So far it's all ok, the project size is small and this doesn't seem to affect performance, but I still want to get some input/advice on this, because I feel like I'm writing python in C++.

Best way to return list of objects in C++?

编译器

容器

自从我用C++编程以来已经有一段时间了，从python回来后，我感觉自己穿着一件笔挺的夹克，好吧，我不会咆哮。我有几个函数充当“管道”，接受一个列表作为输入，返回另一个列表作为输出(基于输入)，这在概念上是这样的，但实际上，我使用std::vector来表示列表，这可以接受吗？此外，我没有使用任何指针，所以我使用std...

问在C++中返回对象列表的最佳方式是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中返回对象列表的最佳方式是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中返回对象列表的最佳方式是什么？
EN