在专用和非专用模板结构之间共享代码 我如何在C++类的专业化和非专业化版本之间共享代码？< /P>

下面是我试图实现的一个人为的例子：

#include <iostream>
using namespace std;

template <size_t n> struct Y {
    int one() { return 1; }
    int two();
};

template <> struct Y<1> {
    int one() { return 11; }
    int two();
};

template <size_t n> int Y<n>::two() { return one() * 2; }

int main() {
    Y<1> X;
    cout << X.one();
    cout << X.two();
    return 0;
}

但我认为，每次调用

Y.two（）

，都会导致不必要的v表查找，对吗

---

有没有办法在专用和非专用版本之间共享代码而不滥用继承并引发v表查找调用？

您根本不需要向

mixin添加
一个
方法。只需使用非虚拟的
two
方法将
mixin
与派生类
Y
共享其实现，并使用CRTP即可

#include <iostream>
using namespace std;

template <class Derive>
struct mixin {
    int two() { return ((Derive *)this)->one() * 2; }
};

template <size_t n> struct Y : public mixin <Y<n>> {
    int one() { return 1; }
};

template <> struct Y<1> : public mixin <Y<1>> {
    int one() { return 11; }
};

int main() {
    Y<1> X;
    cout << X.one();
    cout << X.two();
    return 0;
}

#包括
使用名称空间std；
模板
结构混合{
int two（）{返回（（派生*）this）->one（）*2；}
};
模板结构Y:公共混合{
int one（）{return 1；}
};
模板结构Y:公共混合{
int one（）{return 11；}
};
int main（）{
yx；
cout您可以指定一个方法，而不是类专门化：

template <size_t n> struct Y {
  int one() { return 1; }
  int two() { return one() * 2;  }
  int theird(); // declare only for Y<N>
};

template <>
int Y<1>::one() { return 11; }

// only for Y<1>
template <>
int Y<1>::theird() { return one()*two();}

模板结构{
int one（）{return 1；}
int two（）{return one（）*2；}
int theird（）；//仅为Y声明
};
模板
int Y:：one（）{return 11；}
//只为Y
模板
int Y:：theird（）{return one（）*two（）；}
您也可以用另一种方法代替CRTP：

#include <iostream>
using namespace std;

template <size_t n> struct Y {
    int one() { return 1; }
};

template <> struct Y<1> {
    int one() { return 11; }
};

template <size_t n>
struct mixin : Y<n> {
    int two() { return Y<n>::one() * 2; }
};

int main() {
    mixin<1> X;
    cout << X.one();
    cout << X.two();
    return 0;
} 

#包括
使用名称空间std；
模板结构{
int one（）{return 1；}
};
模板结构{
int one（）{return 11；}
};
模板
结构mixin:Y{
int two（）{返回Y:：one（）*2；}
};
int main（）{
mixinx；
可以啊，是的。这在这个场景中是可行的，但是我想在
Y
上定义一些在
Y
上根本不存在的方法。如果你只声明这些方法并专门针对Y，你就可以这样做。为了澄清你的评论，你的意思是我可以根据Y的定义定义我只想为Y存在的方法，但是然后只实现它专门用于Y？定义滥用继承。@SergeyA在我看来，这类问题应该完全不使用继承就可以解决，尽管如果有一些解决方案使用继承但避免v表查找，那也没关系。@SergeyA:好的，我误解了。哦，有人已经做过CRTP。什么都没有我想通过继承来定义代码共享的方式不适合很多实际情况。它是不完整的。CRTP稍微改进了一点。这可能是对纯继承的滥用，但在很多情况下，它是思考设计的一种简洁方式。
template <size_t n> struct Y {
  int one() { return 1; }
  int two() { return one() * 2;  }
  int theird(); // declare only for Y<N>
};

template <>
int Y<1>::one() { return 11; }

// only for Y<1>
template <>
int Y<1>::theird() { return one()*two();}

#include <iostream>
using namespace std;

template <size_t n> struct Y {
    int one() { return 1; }
};

template <> struct Y<1> {
    int one() { return 11; }
};

template <size_t n>
struct mixin : Y<n> {
    int two() { return Y<n>::one() * 2; }
};

int main() {
    mixin<1> X;
    cout << X.one();
    cout << X.two();
    return 0;
} 

template <class P>
struct mixin : P {
    int two() { return P::one() * 2; }
};

mixin<Y<1>> X;