C++；基于调用方的函数内容 < >可以编译两个或多个C++函数内容的变体，其中一些关键字根据函数调用方指示执行什么，而不需要为每个调用方复制完整函数的多个副本？

到目前为止，解决方案是根据调用方使用函数和语句的参数来执行

V sol::compare(uchar start_lev, V *a , V *b){
solMutex.lock(); // not needed by all callers 
for(auto lev:solVec){ 
switch (lev.group){ 
case a: 
dontRemove=0;
val++; // not used by all callers
return something; 
case b: 
val++; //not used by all callers
return something; 
case c: 
      etc... 
} 
#ifdef QT_DEBUG // not needed by all callers

---

如果可以编写单个函数并添加一些关键字，那么它可以编译一些变体，而不会根据不同的调用者而增加函数未使用部分的开销。

我不确定宏的最终处理方式，但您可以这样做：

template <bool do_lock, bool do_increment>
V sol::compare(uchar start_lev, V *a , V *b){
  if (do_lock) solMutex.lock(); // not needed by all callers 
  for(auto lev:solVec){ 
    switch (lev.group){ 
    case a: 
      dontRemove=0;
      if (do_increment) val++; // not used by all callers
      return something; 
    case b: 
      if (do_increment) val++; //not used by all callers
      return something; 
    case c: 
      etc... 
}

模板
V sol：：比较（uchar start_lev，V*a，V*b）{
if（do_lock）solMutex.lock（）；//并非所有调用者都需要
对于（auto-lev:solVec）{
开关（级别组）{
案例a：
dontRemove=0；
if（do_increment）val++；//未被所有调用者使用
归还某物；
案例b：
if（do_increment）val++；//未被所有调用者使用
归还某物；
案例c：
等
}

若要称之为这一点，您可以这样做

auto v = sol::compare<false, false>(....);

auto v=sol:：compare（…）；

---

并根据特定调用方是否需要更改这些布尔值。请注意，您必须知道在编译时输入的布尔值，因为编译器正在为每个布尔值组合生成不同的函数。因为布尔值在编译时已知，所以这些分支将（如果布尔值为false）只要被任何编译器作为死代码删掉就行了。

您随后在注释中给出了几个想法的草图

V sol::compare(uchar start_lev, V *a , V *b) {
    solMutex.lock(); // not needed by all callers
    for(auto lev:solVec){
       switch (lev.group){
           case a:
               dontRemove=0;
               val++; // not used by all callers 
               return something;
           case b:
               val++; //not used by all callers
               return something;
           case c: 
               ///etc...
      } 
      #ifdef QT_DEBUG // not needed by all callers
}

对于预处理器，代码方面你做不了多少

除此之外，你还可以用布尔语，还有其他选择

对于其他模式，您可以区分共性和差异。 例如，如果

solMutex

是某个虚构的

sol

调用的成员变量，我们可以使用

lockingSol

class sol
{
public:
    V sol::compare(uchar start_lev, V *a , V *b);
        for(auto lev:solVec){
            //etc
        } 
    }
 };


class lockingSol
{
public:
    V compare(uchar start_lev, V *a , V *b)
    {
        solMutex.lock();
        return sol_.compare(start_lev, a, b);
    }

private:
    mutex solMutex;
    sol sol_;
};

这允许

nonlockingSol

调用

solMutex.lock（）；

，然后调用

sol

的方法

模板和stragey设计模式为您提供了切换行为的方法

P>可选的，你可以发送一个函子或lambda来说明算法中间发生的事情。标准库本身给出了很多例子。

例如考虑

template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );

template
无效排序（RandomIt first，RandomIt last，comp比较）；

---

这会对某个对象进行迭代，调用方发送

Compare

函数来改变迭代中发生的情况。

这就是参数的用途：函数根据函数调用执行不同的操作。否则，函数无法神奇地确定调用它的人。您是否在寻找模板s？给我们一个您希望能够编写的代码的简明示例。它用于程序的性能密集型部分，并将根据调用方的不同使用4个修改过的函数版本。@Flow有多少代码是相同的（与调用方无关）再次：请在你的问题中给出一个简洁的示例代码！谢谢你提供的信息，模板看起来是一个很好的方法，可以使代码更容易维护。