blocks|key|5585607|text|通过引用或指针推送元素。您正在推送副本，因此复制元素是C%2B%2B所能做的全部工作。我个人建议您使用这样的指针向量：std::vector<Row*>|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5585608|实际上，一种更安全、更干净的方法是存储shared_ptr-s，而不是裸指针，这样您就不必处理太多内存管理问题。类似于：|5585609|std::vector<std::shared_ptr<Row>+>|5585610|entityMap^0|1J|H|0|0|0|Y|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

Push elements by reference or pointer. You are pushing copies so copying the element is all C++ can do. I would personally advice you to use a vector of pointers like so: <code>std::vector&lt;Row*&gt;</code>

Actually a safer and cleaner way would be to store shared_ptr-s instead of bare pointers so that you don't have to deal with memory management that much. Something like:

<code>std::vector&lt;std::shared_ptr&lt;Row&gt; &gt;</code>

blocks|key|878656|text|不是在std::vector中存储Row，而是存储std::unique_ptr<Row>或std::shared_ptr<Row>。对于这类事情，这些往往就足够了(还有更复杂的方法可以实现这一点，比如存储原始指针(维护起来很复杂)，或者滚动您自己的基于pImpl的类，或者编写您自己的带有自定义语义的智能指针)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|878657|unique_ptr只支持移动，因此可以避免复制问题。相反，shared_ptr支持共享所有权，这可能是您不需要的。我建议使用unique_ptr。|878658|entityMap^0|3|B|H|3|P|K|1A|K|3J|5|0|0|A|U|A|1R|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|I|$]]

Instead of storing <code>Row</code> in your <code>std::vector</code>, store <code>std::unique_ptr&lt;Row&gt;</code> or <code>std::shared_ptr&lt;Row&gt;</code>. These tend to be sufficient for this kind of thing (there are more complex ways you can approach this, such as storing raw pointers (complex to maintain) or rolling your own <code>pImpl</code> based class, or writing your own smart pointer with custom semantics).

<code>unique_ptr</code> only supports moving, and as such avoids your copy problem. <code>shared_ptr</code> instead supports shared ownership, which is probably something you don't need. I'd advise using <code>unique_ptr</code>.

blocks|key|878703|text|在这种情况下，最简单的解决方案可能是将迭代器存储到表中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|878704|class+Row
{
++++std:vector<Table>::iterator+parent_table;
++++Row(std:vector<Table>::iterator+construct);
}|code-block|syntax|javascript|878705|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The easiest solution in this case would probably be to store an iterator to your table:

<pre><code>class Row
{
 std:vector&lt;Table&gt;::iterator parent_table;
 Row(std:vector&lt;Table&gt;::iterator construct);
}
</code></pre>

blocks|key|881760|text|你在问两个不相关的问题。请不要在一篇文章中这样做。一个帖子-一个问题。这使得回答问题变得非常容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|881761|第二：|881762|881763|有没有办法强制std::vector在对象被推回时不复制它们？|blockquote|881764|881765|881766|已经被其他人回答了。|881767|首先：|881768|881769|我创建了一个std::vector测试；，然后在一个循环中创建表对象并将它们推回到test+vector。问题是我丢失了Table*+I+I。我需要指针，这样当我遍历我的行时，我就知道它们属于哪个表。|881770|881771|881772|很可能您的行不包含对包含它的表的任何反向引用。这样，当您传递行向量或行本身时，就会丢失有关谁拥有它的信息。您必须将行向量与table*+owner一起传递，或者将行与table*+owner一起传递，或者必须使行更智能并强制所有行都包含table*+owner+(即，使行包含对所有者的反向引用)。|offset|length|style|CODE|881773|当然，反向引用可以是任意形状的。它不需要是一个指针。您可以传递Table&、shared_ptr<Table>、string+tablename或任何可以帮助您直接或通过某个管理器访问表的内容。重要的是，Row必须包含它，或者它必须单独传递，但必须与行一起传递。|881774|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|1P|C|2B|C|3A|C|0|V|6|12|H|1K|G|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|15|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|18|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|19|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|G|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1E|8|@$U|1F|V|1G|W|X]|$U|1H|V|1I|W|X]|$U|1J|V|1K|W|X]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1L|8|@$U|1M|V|1N|W|X]|$U|1O|V|1P|W|X]|$U|1Q|V|1R|W|X]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|11|$]]

You are asking two unrelated questions. Please don't do that in one post. One post - one question. That makes answering really easier.

SECOND: 

<blockquote>
 Is there a way to force std::vector, not to copy objects when they are pushed back?
</blockquote>

Is already answered by others.

FIRST:

<blockquote>
 I create an std::vector test;, and in a loop I create Table objects and push them back to test vector. The problem is I lose Table* inside Row inside Table. I need the pointer so when I iterate through the my Rows, I know which table they belong to.
</blockquote>

Most probably your ROW does not contain any backreference to the Table that contains it. That way, when you pass around the vector-of-rows or the row itself, you lose the information about who owns it. You must either pass a-vector-of-rows along with <code>table* owner</code>, or a row along with <code>table* owner</code>, OR you must make your Row more intelligent and force all Rows to contain a <code>table* owner</code> (that is, have the Rows contain a backreference to owner)

Of course the backreference may be of any shape. It does not need to be a pointer. You may pass <code>Table&amp;</code>, a <code>shared_ptr&lt;Table&gt;</code>, a <code>string tablename</code> or whatever that will help you access the table either directly or through some manager. The important thing is, that either the Row must contain it, or it must be passed separately but along with the rows.

I have the following class.

<pre><code>class Row
{
 Table* parent_table;
 Row(Table* construct);
}
class Table
{
 std::vector&lt;Row&gt;;
}
</code></pre>

I create an <code>std::vector&lt;Table&gt; test;</code>, and in a loop I create Table objects and push them back to test vector. The problem is I lose Table* inside each Row. I need the pointer so when I iterate through the my Rows, I know which table they belong to.

Is there a way to force std::vector, not to copy objects when they are pushed back?

std vector, copying data structure

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有下面的课程。class Row{ Table* parent_table; Row(Table* construct);}class Table{ std::vector<Row>;}我创建了一个std::vector<Table> test;，然后在一个循环中创建了表对象，并将它们推回到测试向量。问...

问标准向量，复制数据结构
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问标准向量，复制数据结构EN