blocks|key|4442914|text|两个分支都可以定义setData，false条件为空：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4442915|template<typename+T,+bool>+class+ConditionalData+{
};

template+<typename+T>+class+ConditionalData<T,+false>+{
++++void+setData(T+_data)+{}
};

template+<typename+T>+class+ConditionalData<T,+true>+{
private:
++++T+data;
public:
++++void+setData(T+_data)+{+data+=+_data;+}
};

template<bool+hasdata>+class+A+{
public:
++++A()+{
++++++++ConditionalData<int,hasdata>+data;
++++++++data.setData(3);
++++}
};|code-block|syntax|javascript|4442916|entityMap^0|9|7|H|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

you can define <code>setData</code> for both branches, empty one for <code>false</code> condition:

<pre><code>template&lt;typename T, bool&gt; class ConditionalData {
};

template &lt;typename T&gt; class ConditionalData&lt;T, false&gt; {
 void setData(T _data) {}
};

template &lt;typename T&gt; class ConditionalData&lt;T, true&gt; {
private:
 T data;
public:
 void setData(T _data) { data = _data; }
};

template&lt;bool hasdata&gt; class A {
public:
 A() {
 ConditionalData&lt;int,hasdata&gt; data;
 data.setData(3);
 }
};
</code></pre>

blocks|key|4443199|text|如果你不能(/不想)改变ConditionalData，你可以创建两个方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4443200|template<typename+T>
void+SetData(ConditionalData<T,+false>&+,+const+T&+)+{/*+Nothing+*/}

template<typename+T>
void+SetData(ConditionalData<T,+true>&+c,+const+T&+value)+{+c.setData(value);+}|code-block|syntax|javascript|4443201|然后|4443202|A()+{
++++ConditionalData<int,+hasdata>+data;
++++SetData(data,+3);
}|4443203|对于更复杂的情况|4443204|template<typename+T>
void+A_impl_part1(ConditionalData<T,+false>&)+{/*+Nothing+*/}

template<typename+T>
void+A_impl_part1(ConditionalData<T,+true>&+c)+{+c.setData(3);+}|4443205|4443206|A()+{
++++ConditionalData<int,+hasdata>+data;
++++A_impl_part1(data);
++++//+common+part
++++//+A_impl_part2(data);+//+and+so+on
}|4443207|entityMap^0|C|F|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|13|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|S|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|T|3|U|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|V|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|W|$]]

If you cannot(/don't want to) change <code>ConditionalData</code>, you may create 2 methods instead:

<pre><code>template&lt;typename T&gt;
void SetData(ConditionalData&lt;T, false&gt;&amp; , const T&amp; ) {/* Nothing */}

template&lt;typename T&gt;
void SetData(ConditionalData&lt;T, true&gt;&amp; c, const T&amp; value) { c.setData(value); }
</code></pre>

and then

<pre><code>A() {
 ConditionalData&lt;int, hasdata&gt; data;
 SetData(data, 3);
}
</code></pre>

For more complex cases

<pre><code>template&lt;typename T&gt;
void A_impl_part1(ConditionalData&lt;T, false&gt;&amp;) {/* Nothing */}

template&lt;typename T&gt;
void A_impl_part1(ConditionalData&lt;T, true&gt;&amp; c) { c.setData(3); }
</code></pre>

and then

<pre><code>A() {
 ConditionalData&lt;int, hasdata&gt; data;
 A_impl_part1(data);
 // common part
 // A_impl_part2(data); // and so on
}
</code></pre>

blocks|key|4443255|text|首先，您不需要3个版本的class+ConditionalData，因为bool可以是true或false。因此，让我将其简化为：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4443256|template<typename+T,+bool+=+false>+class+ConditionalData+{
};+++++++++++++++++//%5E%5E%5E%5E%5E%5E%5E%5E%5E%5E%5E%5E

template+<typename+T>+class+ConditionalData<T,+true>+{
private:
++++T+data;
public:
++++void+setData(T+_data)+{+data+=+_data;+}
};|code-block|syntax|javascript|4443257|其次，为了回答您的问题:无论哪个成员属于false类别，只需在class主体之外重载它们，如下所示：|4443258|template<bool+hasdata>+class+A+{+
public:
++++A()+{
++++++++ConditionalData<int,hasdata>+data;
++++++++if+(hasdata)+{
++++++++++++data.setData(3);
++++++++}
++++}+++
};

template<>+A<false>::A()+{}++//+Does+nothing+for+`false`+condition|4443259|entityMap^0|C|L|10|4|17|4|1C|5|0|0|K|5|V|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

First of all, you don't require 3 versions of <code>class ConditionalData</code>, because <code>bool</code> can be either <code>true</code> or <code>false</code>. So let me simplify it as following:

<pre><code>template&lt;typename T, bool = false&gt; class ConditionalData {
}; //^^^^^^^^^^^^

template &lt;typename T&gt; class ConditionalData&lt;T, true&gt; {
private:
 T data;
public:
 void setData(T _data) { data = _data; }
};
</code></pre>

Secondly, to answer your question: Whichever members are falling for <code>false</code> category, just overload them outside the <code>class</code> body as following:

<pre><code>template&lt;bool hasdata&gt; class A { 
public:
 A() {
 ConditionalData&lt;int,hasdata&gt; data;
 if (hasdata) {
 data.setData(3);
 }
 } 
};

template&lt;&gt; A&lt;false&gt;::A() {} // Does nothing for `false` condition
</code></pre>

blocks|key|4443077|text|您可以使用预处理器来“生成”您的类的每个变体作为模板专门化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4443078|首先，我们将从“template”头中生成专门化：|4443079|ATemplate.h
//no+include+guards+to+allow+multiple+inclusion
template<>
class+A<A_HAS_DATA>
{
public:
++++A()
++++{
#if+A_HAS_DATA
++++++++double+data;
++++++++if+(hasdata)+{
++++++++++++data+=+sin(cos(123.4));
++++++++}
#endif
++++}
}|code-block|syntax|javascript|4443080|然后，我们实际生成每个特殊化，以获得在您的代码中使用的普通头：|4443081|A.h
#pragma+once

template<bool+hasdata>
class+A;

//Generate+specialization+for+hasdata+=+true
#define+A_HAS_DATA+1
#include+"ATemplate.h"
#undef+A_HAS_DATA
//(undef+avoids+redefinition+warning)
//Generate+specialization+for+hasdata+=+false
#define+A_HAS_DATA+0
#include+"ATemplate.h"
#undef+A_HAS_DATA|4443082|本质上，我们不是为每种可能的情况手动编写每个特殊化(假设您可能有多个这样的设置来包括/排除内容)，而是使用预处理器多次包含一个头来生成每个变体，每次预处理器定义的值都不同，以获得不同的结果。|4443083|当它们工作时，我更喜欢使用普通的模板方法，但是如果手动代码复制的数量(定义所有可能的变体)变得太多，这种方法可以工作(因为你可以指定所有的东西‘内联’，就像我们有一个静态if所做的那样)|4443084|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can use the preprocessor to 'generate' each variation of your class as template specializations.

First, the 'template' header we will generate the specializations from:

<pre><code>ATemplate.h
//no include guards to allow multiple inclusion
template&lt;&gt;
class A&lt;A_HAS_DATA&gt;
{
public:
 A()
 {
#if A_HAS_DATA
 double data;
 if (hasdata) {
 data = sin(cos(123.4));
 }
#endif
 }
}
</code></pre>

Then we actually generate each specialization to obtain a normal header to use in your code:

<pre><code>A.h
#pragma once

template&lt;bool hasdata&gt;
class A;

//Generate specialization for hasdata = true
#define A_HAS_DATA 1
#include "ATemplate.h"
#undef A_HAS_DATA
//(undef avoids redefinition warning)
//Generate specialization for hasdata = false
#define A_HAS_DATA 0
#include "ATemplate.h"
#undef A_HAS_DATA
</code></pre>

Essentially, instead of manually writing each specialization for each possible case (given that you might have multiple such settings to include/exclude stuff), we use preprocessor to generate each variant by including a header multiple times, each time with a different value for preprocessor define(s) to get different result.

Prefer to use normal template approaches when they work, but if the amount of manual code duplication (to define all the possible variants) grows too high, this approach can work (as you can specify everything 'inline' akin what static if would do if we had one)

I'm trying to get the following C++ code running:

<pre><code>#include &lt;cmath&gt;

template&lt;typename T, bool&gt; class ConditionalData {
};

template &lt;typename T&gt; class ConditionalData&lt;T, false&gt; {
};

template &lt;typename T&gt; class ConditionalData&lt;T, true&gt; {
private:
 T data;
public:
 void setData(T _data) { data = _data; }
};


template&lt;bool hasdata&gt; class A {
public:
 A() {
 ConditionalData&lt;double,hasdata&gt; data;
 if (hasdata) {
 data.setData(sin(cos(123.4)));
 }
 }
};


int main(int argNum, const char**argData) {
 A&lt;false&gt; test1;
 A&lt;true&gt; test2;
 return 0;
}
</code></pre>

Essentially, I want to implement a templated class A in which certain operations are executed depending on the template parameter. These operations need local variables, which I only want to be allocated if needed. The problem that I'm having here is that the body of the 

<pre><code>if (hasdata) {
 data.setData(3);
}
</code></pre>

condition is also instantiated for hasdata=false, which does not compile (using g++ 5.2). Any ideas how to get this done in the cleanest way without splitting the body of A::A() into pieces? 

The source code above is a minimal non-working example. The real implementation for A::A() is relatively long, with the parts dependent on "hasdata" being distributed evenly over the code. Also, the "typename T" for which the class A will be used is a relatively complex class with heavy-weight constructors/destructors, so I want the instances of T to only be allocated when hasdata=true. Finally, in the data.setData(...) calls, there can be complex computations in the "...", which should only be performed if needed.

Cleanest way for conditional code instantiation in C++ template

我正在尝试运行以下C++代码：#include <cmath>template<typename T, bool> class ConditionalData {};template <typename T> class ConditionalData<T, false> {};template <typename T...

问在C++模板中实现条件代码实例化的最简洁方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++模板中实现条件代码实例化的最简洁方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++模板中实现条件代码实例化的最简洁方法
EN