blocks|key|3111154|text|使用迭代器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3111155|std::vector<int>+lines;
//+fill
std::size_t+const+half_size+=+lines.size()+/+2;
std::vector<int>+split_lo(lines.begin(),+lines.begin()+%2B+half_size);
std::vector<int>+split_hi(lines.begin()+%2B+half_size,+lines.end());|code-block|syntax|javascript|3111156|由于迭代器范围表示半个开放范围向量，因此不需要向第二个开始迭代器添加1：lines.begin()+%2B+half_size不会复制到第一个[begin,+end)。|offset|length|style|CODE|3111157|3111158|注意，像这样的东西|3111159|int+split+=+lines.size()+/+2;
int+arrayA[split];
int+arrayB[split];|3111160|不是标准的C%2B%2B+(因此不是可移植的)。这些是所谓的可变长度数组(简称VLA)，并且是C99的东西。一些编译器在编译C%2B%2B代码时将它们作为扩展(GCC，Clang)。请始终使用-pedantic进行编译，以获得警告。这些VLA对于非POD类型很奇怪，通常没有什么用处，因为您甚至不能返回它们。|3111161|entityMap^0|0|0|10|P|1X|C|0|0|0|0|2G|9|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@$I|Y|J|Z|K|L]|$I|10|J|11|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|R|3|S|5|6|7|15|8|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|U|$]]

Use iterators.

<pre><code>std::vector&lt;int&gt; lines;
// fill
std::size_t const half_size = lines.size() / 2;
std::vector&lt;int&gt; split_lo(lines.begin(), lines.begin() + half_size);
std::vector&lt;int&gt; split_hi(lines.begin() + half_size, lines.end());
</code></pre>

Since iterator ranges represent half open ranges <code>[begin, end)</code>, you don't need to add 1 to the second begin iterator: <code>lines.begin() + half_size</code> isn't copied to the first vector.

<hr>

Note that things like 

<pre><code>int split = lines.size() / 2;
int arrayA[split];
int arrayB[split];
</code></pre>

Are not standard C++ (and as such not portable). These are so-called variable-length arrays (VLAs for short) and are a C99 thing. Some compilers have them as an extension while compiling C++ code (GCC, Clang). Always compile with <code>-pedantic</code> to get a warning. These VLAs act funky for non-POD types and aren't generally useful, since you can't even return them.

blocks|key|2897085|text|如果您只需要引用数字，而不需要对它们进行操作，那么您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2897086|int+*array_1+=+&lines[0];
int+*array_2+=+&lines[lines.size()+/+2];|code-block|syntax|javascript|2897087|array_1和array_2实际上是指向向量的开始和中间的指针。这是因为STL保证向量将它们的元素存储在连续的内存中。请注意，引用lines.begin()不能用于此目的。|2897088|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you only need a reference to the numbers without manipulating them, then you can do:

<pre><code>int *array_1 = &amp;lines[0];
int *array_2 = &amp;lines[lines.size() / 2];
</code></pre>

array_1 and array_2 are, actually, pointers to the start and middle of the vector. This works since STL guarantees that vectors store their elements within a continuous memory. 
Note that referring to lines.begin() can't be used for this.

blocks|key|234255|text|如果由于严格编译器规则而不能使用Xeo+answer中的代码，或者您希望使用更通用的方式，请尝试使用std::advance|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|234256|#include+<vector>
#include+<iterator>

size_t+middle+=+input.size()/2;
std::vector<int>::const_iterator+middleIter(input.cbegin());
std::advance(middleIter,+middle);

std::vector<int>+leftHalf(input.begin(),+middleIter);
std::vector<int>+rightHalf(middleIter,+input.end());|code-block|syntax|javascript|234257|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/500104/xeo|1|http://www.cplusplus.com/reference/iterator/advance/^0|1E|C|G|3|0|1E|C|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

If you can't use code from <a href="https://stackoverflow.com/users/500104/xeo">Xeo</a> answer due to strict compiler rules or you want more generic way, try <a href="http://www.cplusplus.com/reference/iterator/advance/" rel="nofollow noreferrer"><code>std::advance</code></a>:

<pre><code>#include &lt;vector&gt;
#include &lt;iterator&gt;

size_t middle = input.size()/2;
std::vector&lt;int&gt;::const_iterator middleIter(input.cbegin());
std::advance(middleIter, middle);

std::vector&lt;int&gt; leftHalf(input.begin(), middleIter);
std::vector&lt;int&gt; rightHalf(middleIter, input.end());
</code></pre>

blocks|key|234259|text|使用迭代器将向量拆分为变量计数部分的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|234260|#include+<iostream>
#include+<vector>

int+main()
{
+++//+Original+vector+of+data
+++std::vector<double>+mainVec{1.2,+2.3,+3.4,+4.5,+5.6,+6.7,+7.8,+8.9,+9.0};
+++//+Result+vectors
+++std::vector<std::vector<double>>+subVecs{};
+++//+Start+iterator
+++auto+itr+=+mainVec.begin();
+++//+Variable+to+control+size+of+non+divided+elements
+++unsigned+fullSize+=+mainVec.size();
+++//+To+regulate+count+of+parts
+++unsigned+partsCount+=+4U;
+++for(unsigned+i+=+0;+i+<+partsCount;+%2B%2Bi)
+++{
+++++++//+Variable+controls+the+size+of+a+part
+++++++auto+partSize+=+fullSize+/+(partsCount+-+i);
+++++++fullSize+-=+partSize;
+++++++//+
+++++++subVecs.emplace_back(std::vector<double>{itr,+itr%2BpartSize});
+++++++itr+%2B=+partSize;
+++}
+++//+Print+out+result
+++for+(const+auto&+elemOuter+:+subVecs)
+++{
+++++++std::cout+<<+std::fixed;
+++++++for+(const+auto&+elemInner+:+elemOuter)
+++++++{
+++++++++++std::cout+<<+elemInner+<<+"+";
+++++++}
+++++++std::cout+<<+"\n";
+++}
}|code-block|syntax|javascript|234261|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|$]]

Solution to split vector to variable count parts using iterator.

<pre><code>#include &lt;iostream&gt;
#include &lt;vector&gt;

int main()
{
 // Original vector of data
 std::vector&lt;double&gt; mainVec{1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0};
 // Result vectors
 std::vector&lt;std::vector&lt;double&gt;&gt; subVecs{};
 // Start iterator
 auto itr = mainVec.begin();
 // Variable to control size of non divided elements
 unsigned fullSize = mainVec.size();
 // To regulate count of parts
 unsigned partsCount = 4U;
 for(unsigned i = 0; i &lt; partsCount; ++i)
 {
 // Variable controls the size of a part
 auto partSize = fullSize / (partsCount - i);
 fullSize -= partSize;
 // 
 subVecs.emplace_back(std::vector&lt;double&gt;{itr, itr+partSize});
 itr += partSize;
 }
 // Print out result
 for (const auto&amp; elemOuter : subVecs)
 {
 std::cout &lt;&lt; std::fixed;
 for (const auto&amp; elemInner : elemOuter)
 {
 std::cout &lt;&lt; elemInner &lt;&lt; " ";
 }
 std::cout &lt;&lt; "\n";
 }
}
</code></pre>

What I'm trying to do:

I am trying to split a vector into two separate arrays. The current int vector contains an element per line in a text file. The text file is a list of random integers. 

How I'm planning to do it:

My current idea is to create two regular int arrays, then iterate over the entire vector and copy n/2 elements to each of the arrays.

What I would like to know:

What is the most elegant way of accomplishing my task? I have a feeling that I can do this without iterating over the vector multiple times.

Code:

<pre><code>#include &lt;vector&gt;
#include &lt;fstream&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;
using namespace std;

vector&lt;int&gt; ifstream_lines(ifstream&amp; fs)
{
 vector&lt;int&gt; out;
 int temp;
 while(fs &gt;&gt; temp)
 {
 out.push_back(temp);
 }
 return out;
}

vector&lt;int&gt; MergeSort(vector&lt;int&gt;&amp; lines)
{
 int split = lines.size() / 2;
 int arrayA[split];
 int arrayB[split];
}

int main(void) 
{
 ifstream fs("textfile.txt");
 vector&lt;int&gt; lines;
 lines = ifstream_lines(fs);

 return 0;
}
</code></pre>

Thank you :)

Best way to split a vector into two smaller arrays?

编译器

我正在尝试做什么：我正在尝试将一个向量拆分为两个独立的数组。当前的int向量在文本文件中每行包含一个元素。文本文件是一个随机整数列表。我打算怎么做：我现在的想法是创建两个常规的int数组，然后迭代整个向量，并将n/2个元素复制到每个数组中。我想知道的是：完成任务最优雅的方式是什么？我有一种感觉，我可以在不多次迭代向量的...

问将向量拆分为两个较小数组的最佳方法？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将向量拆分为两个较小数组的最佳方法？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将向量拆分为两个较小数组的最佳方法？
EN