blocks|key|19987|text|使用额外的代码，您可能仍然拥有常量向量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|19988|std::vector<std::string>+make_c99_type()
{
++++auto+res+=+c90_types;
++++const+std::vector<std::string>+extra_c99_types+=+{
++++++++"long+long",
++++++++"unsigned+long+long",
++++++++"intmax_t",
++++++++"uintmax_t"
++++};
++++res.insert(res.end(),+extra_c99_types.begin(),+extra_c99_types.end());
++++return+res;
}

const+std::vector<std::string>+c99_types+=+make_c99_type();|code-block|syntax|javascript|19989|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|$]]

With extra code, you may still have const vector:

<pre><code>std::vector&lt;std::string&gt; make_c99_type()
{
 auto res = c90_types;
 const std::vector&lt;std::string&gt; extra_c99_types = {
 "long long",
 "unsigned long long",
 "intmax_t",
 "uintmax_t"
 };
 res.insert(res.end(), extra_c99_types.begin(), extra_c99_types.end());
 return res;
}

const std::vector&lt;std::string&gt; c99_types = make_c99_type();
</code></pre>

blocks|key|4527586|text|您可以首先定义最大的向量(这里是c99_types)，然后用最大的一个迭代器构造其他的向量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4527587|下面是一个示例：|4527588|const+vector<int>+a{1,2,3,4};
const+vector<int>+b{begin(a),+begin(a)%2B2};+//+b+is+{1,2}|code-block|syntax|javascript|4527589|所以你可以这样写：|4527590|const+std::vector<std::string>+c99_types+=+{
++++"char",
++++"signed+char",
++++"unsigned+char",
++++"short",
++++"unsigned+short",
++++"int",
++++"unsigned+int",
++++"long",
++++"unsigned+long",
++++"float",
++++"double",
++++"long+double",
++++"long+long",
++++"unsigned+long+long",
++++"intmax_t",
++++"uintmax_t"
};

const+std::vector<std::string>+c90_types{begin(c99_types),+begin(c99_types)%2B12};|4527591|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You could define the biggest vector (here that would be c99_types) first, and then construct the others with iterators from the largest one.

Here is an example :

<pre><code>const vector&lt;int&gt; a{1,2,3,4};
const vector&lt;int&gt; b{begin(a), begin(a)+2}; // b is {1,2}
</code></pre>

So you could write:

<pre><code>const std::vector&lt;std::string&gt; c99_types = {
 "char",
 "signed char",
 "unsigned char",
 "short",
 "unsigned short",
 "int",
 "unsigned int",
 "long",
 "unsigned long",
 "float",
 "double",
 "long double",
 "long long",
 "unsigned long long",
 "intmax_t",
 "uintmax_t"
};

const std::vector&lt;std::string&gt; c90_types{begin(c99_types), begin(c99_types)+12};
</code></pre>

blocks|key|20074|text|选项1：std::array|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|20075|这可能可以清理和改进很多，但它至少是一个起点(它使用Jonathan+Wakely's+redi::index_tuple|20076|template<typename+T,+std::size_t+N,+unsigned...+I,+typename+...U>
inline+auto
append_array_helper(const+std::array<T,+N>&+array,+redi::index_tuple<I...>,+U&&...+elements)+->+std::array<T,+N+%2B+sizeof...(elements)>
{
++++return+std::array<T,+N+%2B+sizeof...(elements)>{+std::get(array)...,+std::forward(elements)...+};
}

template<typename+T,+std::size_t+N,+typename+...U>
inline+auto
append_array(const+std::array<T,+N>&+array,+U&&...+elements)+->+std::array<T,+N+%2B+sizeof...(elements)>
{
++++return+append_array_helper(array,+typename+redi::make_index_tuple<N>::type(),+std::forward(elements)...);
}

const+std::array<std::string,+12>+c90_types+=+{
++++"char",
++++"signed+char",
++++"unsigned+char",
++++"short",
++++"unsigned+short",
++++"int",
++++"unsigned+int",
++++"long",
++++"unsigned+long",
++++"float",
++++"double",
++++"long+double"
};

const+std::array<std::string,+16>+c99_types+=+append_array(
++++c90_types,
++++"long+long",
++++"unsigned+long+long",
++++"intmax_t",
++++"uintmax_t"
);|code-block|syntax|javascript|20077|如果您不想指定数组大小，可以使用以下方法：|20078|template<typename+T,+typename...+U>
constexpr+auto+make_array(U&&...+elements)+->+std::array<T,+sizeof...(elements)>
{
++++return+{+std::forward(elements)...+};
}

const+auto+c90_types+=+make_array<std::string>(
++++"char",
++++"signed+char",
++++"unsigned+char",
++++"short",
++++"unsigned+short",
++++"int",
++++"unsigned+int",
++++"long",
++++"unsigned+long",
++++"float",
++++"double",
++++"long+double"
);

...|20079|选项2:宏|20080|不是我的最爱，但它很简单，易于理解和编辑：|20081|#define+C90_TYPES+++++++++\
++++"char",+++++++++++++++\
++++"signed+char",++++++++\
++++"unsigned+char",++++++\
++++"short",++++++++++++++\
++++"unsigned+short",+++++\
++++"int",++++++++++++++++\
++++"unsigned+int",+++++++\
++++"long",+++++++++++++++\
++++"unsigned+long",++++++\
++++"float",++++++++++++++\
++++"double",+++++++++++++\
++++"long+double"

#define+C99_TYPES+++++++++\
++++C90_TYPES,++++++++++++\
++++"long+long",++++++++++\
++++"unsigned+long+long",+\
++++"intmax_t",+++++++++++\
++++"uintmax_t"

const+std::vector<std::string>+c90_types+=+{
++++C90_TYPES
};

const+std::vector<std::string>+c99_types+=+{
++++C99_TYPES
};|20082|entityMap|0|LINK|mutability|MUTABLE|url|https://gitorious.org/redistd/redistd/blobs/master/include/redi/index_tuple.h^0|4|A|0|18|H|Q|Z|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1E|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1G|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1H|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|W|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

<h1>Option 1: <code>std::array</code></h1>

This can probably be cleaned up and improved a lot, but it's at least a starting point (it uses <a href="https://gitorious.org/redistd/redistd/blobs/master/include/redi/index_tuple.h">Jonathan Wakely's <code>redi::index_tuple</code></a>:

<pre><code>template&lt;typename T, std::size_t N, unsigned... I, typename ...U&gt;
inline auto
append_array_helper(const std::array&lt;T, N&gt;&amp; array, redi::index_tuple&lt;I...&gt;, U&amp;&amp;... elements) -&gt; std::array&lt;T, N + sizeof...(elements)&gt;
{
 return std::array&lt;T, N + sizeof...(elements)&gt;{ std::get&lt;I&gt;(array)..., std::forward&lt;U&gt;(elements)... };
}

template&lt;typename T, std::size_t N, typename ...U&gt;
inline auto
append_array(const std::array&lt;T, N&gt;&amp; array, U&amp;&amp;... elements) -&gt; std::array&lt;T, N + sizeof...(elements)&gt;
{
 return append_array_helper(array, typename redi::make_index_tuple&lt;N&gt;::type(), std::forward&lt;U&gt;(elements)...);
}

const std::array&lt;std::string, 12&gt; c90_types = {
 "char",
 "signed char",
 "unsigned char",
 "short",
 "unsigned short",
 "int",
 "unsigned int",
 "long",
 "unsigned long",
 "float",
 "double",
 "long double"
};

const std::array&lt;std::string, 16&gt; c99_types = append_array(
 c90_types,
 "long long",
 "unsigned long long",
 "intmax_t",
 "uintmax_t"
);
</code></pre>

If you don't want to specify the array size, you can use the following method:

<pre><code>template&lt;typename T, typename... U&gt;
constexpr auto make_array(U&amp;&amp;... elements) -&gt; std::array&lt;T, sizeof...(elements)&gt;
{
 return { std::forward&lt;U&gt;(elements)... };
}

const auto c90_types = make_array&lt;std::string&gt;(
 "char",
 "signed char",
 "unsigned char",
 "short",
 "unsigned short",
 "int",
 "unsigned int",
 "long",
 "unsigned long",
 "float",
 "double",
 "long double"
);

...
</code></pre>

<h1>Option 2: Macros</h1>

Not my favorite, but it's simple and easy to understand and edit:

<pre><code>#define C90_TYPES \
 "char", \
 "signed char", \
 "unsigned char", \
 "short", \
 "unsigned short", \
 "int", \
 "unsigned int", \
 "long", \
 "unsigned long", \
 "float", \
 "double", \
 "long double"

#define C99_TYPES \
 C90_TYPES, \
 "long long", \
 "unsigned long long", \
 "intmax_t", \
 "uintmax_t"

const std::vector&lt;std::string&gt; c90_types = {
 C90_TYPES
};

const std::vector&lt;std::string&gt; c99_types = {
 C99_TYPES
};
</code></pre>

blocks|key|20086|text|您可以使用boost::join|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|20087|#include+<vector>
#include+<boost/range/join.hpp>

const+std::vector<std::string>+c90_types+=+{
++"char",
++"signed+char",
++"unsigned+char",
++"short",
++"unsigned+short",
++"int",
++"unsigned+int",
++"long",
++"unsigned+long",
++"float",
++"double",
++"long+double"
};


auto+range+=+boost::join(c90_types,+std::vector<std::string>{
++++"long+long",
++++"unsigned+long+long",
++++"intmax_t",
++++"uintmax_t"
});

const+std::vector<std::string>+c99_types(range.begin(),+range.end());|code-block|syntax|javascript|20088|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_57_0/libs/range/doc/html/range/reference/utilities/join.html^0|5|B|5|B|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

You can use <a href="http://www.boost.org/doc/libs/1_57_0/libs/range/doc/html/range/reference/utilities/join.html" rel="nofollow"><code>boost::join</code></a>:

<pre><code>#include &lt;vector&gt;
#include &lt;boost/range/join.hpp&gt;

const std::vector&lt;std::string&gt; c90_types = {
 "char",
 "signed char",
 "unsigned char",
 "short",
 "unsigned short",
 "int",
 "unsigned int",
 "long",
 "unsigned long",
 "float",
 "double",
 "long double"
};


auto range = boost::join(c90_types, std::vector&lt;std::string&gt;{
 "long long",
 "unsigned long long",
 "intmax_t",
 "uintmax_t"
});

const std::vector&lt;std::string&gt; c99_types(range.begin(), range.end());
</code></pre>

blocks|key|4527677|text|有一个技巧叫做“我想用一些复杂的东西初始化一个常量变量”。这在C%2B%2B11中成为可能，它是从Javascript中无耻地窃取的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4527678|const+std::vector<std::string>+c90_types+=+{
++++"char",
++++//+and+so+on,+and+so+forth....
};

const+std::vector<std::string>+c99_types+=+([&](){
++++const+auto+additional_types+=+{+//+initializer_list<const+char+*>,+but+it+does+not+matter.
++++++++"long+long",
++++++++"unsigned+long+long",
++++++++"intmax_t",
++++++++"uintmax_t"
++++};

++++std::vector<std::string>+vec{c90_types};

++++vec.insert(vec.end(),+additional_types.begin(),+additional_types.end());

++++return+vec;
})();|code-block|syntax|javascript|4527679|将您的初始化逻辑打包到一个未命名的lambda中，并立即调用它，复制初始化您的常量变量。|4527680|vec被移动，而不是复制。|offset|length|style|CODE|4527681|entityMap^0|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

There is a trick called "I want to initialize a const variable with something elaborate." that became possible with C++11, shamelessly stolen from Javascript.

<pre><code>const std::vector&lt;std::string&gt; c90_types = {
 "char",
 // and so on, and so forth....
};

const std::vector&lt;std::string&gt; c99_types = ([&amp;](){
 const auto additional_types = { // initializer_list&lt;const char *&gt;, but it does not matter.
 "long long",
 "unsigned long long",
 "intmax_t",
 "uintmax_t"
 };

 std::vector&lt;std::string&gt; vec{c90_types};

 vec.insert(vec.end(), additional_types.begin(), additional_types.end());

 return vec;
})();
</code></pre>

Pack your initialization logic into an unnamed lambda, and call it right away, copy-initializing your const variable.

<code>vec</code> is moved, not copied.

I need an "elegant" way of initializing a vector in the declaration phase with the content of another one and a few extra elements. 

What I want to solve is:

Let's consider the following (example) declaration with initialization:

<pre><code>const std::vector&lt;std::string&gt; c90_types = {
 "char",
 "signed char",
 "unsigned char",
 "short",
 "unsigned short",
 "int",
 "unsigned int",
 "long",
 "unsigned long",
 "float",
 "double",
 "long double"
};

const std::vector&lt;std::string&gt; c99_types = {
 "char",
 "signed char",
 "unsigned char",
 "short",
 "unsigned short",
 "int",
 "unsigned int",
 "long",
 "unsigned long",
 "float",
 "double",
 "long double",
 "long long",
 "unsigned long long",
 "intmax_t",
 "uintmax_t"
};
</code></pre>

as you can see <code>c99_types</code> has a subset which is exactly <code>c90_types</code>. I want to avoid the situation where I need to change the subset and then change manually the "superset" too, just to avoid the extra step that might introduce bugs :)

As a side note, I don't want to write code like:

<pre><code>second.insert(second.begin(), first.begin(), first.end());
second.push_back(something);
</code></pre>

Any good and clean solutions to this?

Initialize a C++ (11) std::vector with the content of another one and extra elements

我需要一种“优雅”的方式，在声明阶段用另一个向量的内容和一些额外的元素来初始化一个向量。我想解决的是：让我们考虑以下(示例)带有初始化的声明：const std::vector<std::string> c90_types = { "char", "signed char", "unsigned ch...

问用另一个的内容和额外的元素初始化一个C++ (11) std::vector
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用另一个的内容和额外的元素初始化一个C++ (11) std::vectorEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用另一个的内容和额外的元素初始化一个C++ (11) std::vector
EN