C++ 如何调用类模板的静态方法而不指定实例化？

有没有办法在类模板中定义一个静态方法，然后在不指定实例化的情况下调用它

---

我认为，如果您有一些辅助静态函数，这些函数在逻辑上属于一个类（碰巧是一个模板类），但不依赖于模板参数，那么这可能会很有用

我也不介意：

具有相同的静态方法（包括address和all） 实例化，或

每个实例化都有一个单独的静态方法，但是能够调用静态方法而无需 指定在其中调用方法的实例化（某些默认值） 将被称为）

e、 g

模板类C{
公众：
静态int func（）{return 0；}
};
int main（）
{
//这很有效。
返回C:：func（）；
//这些不起作用。
//返回C:：func（）；
//返回C:：func（）；
}

最简单的解决方案可能是让静态函数属于基类，然后模板从基类派生：

struct CBase {
    static int func() { return 0; }
};

template<typename T> class C : public CBase {
public:
};

int main()
{
    // This works.
    return C<int>::func();

    // This will work too:
    return CBase::func();
}

structcbase{
静态int func（）{return 0；}
};
模板类C：公共CBase{
公众：
};
int main（）
{
//这很有效。
返回C:：func（）；
//这也会起作用：
返回CBase:：func（）；
}

最简单的解决方案可能是让静态函数属于基类，然后模板从基类派生：

struct CBase {
    static int func() { return 0; }
};

template<typename T> class C : public CBase {
public:
};

int main()
{
    // This works.
    return C<int>::func();

    // This will work too:
    return CBase::func();
}

structcbase{
静态int func（）{return 0；}
};
模板类C：公共CBase{
公众：
};
int main（）
{
//这很有效。
返回C:：func（）；
//这也会起作用：
返回CBase:：func（）；
}

这是怎么回事？您通常也依赖于静态函数中的类型

template<typename T> class C {
public:
    static int func() { return sizeof(T); }
};

模板类C{
公众：
静态int func（）{return sizeof（T）；}
};

---

如果它们不依赖于它，您可能应该让它们成为自由函数或此类基类的静态成员。

这将如何工作？您通常也依赖于静态函数中的类型

template<typename T> class C {
public:
    static int func() { return sizeof(T); }
};

模板类C{
公众：
静态int func（）{return sizeof（T）；}
};

---

如果它们不依赖于它，您可能应该使它们成为自由函数，或者使其成为该类基类的静态成员。

您可以使用继承，这也将删除二进制文件中任何非静态函数（也不关心模板类型）的重复，即：

class A {
public:
    static int func() { return 0; }
};

template<typename T> 
class B : A {

};

A类{
公众：
静态int func（）{return 0；}
};
样板
B类：A{
};

您可以使用继承，这也将删除二进制文件中任何非静态函数（也不关心模板类型）的重复，即：

class A {
public:
    static int func() { return 0; }
};

template<typename T> 
class B : A {

};

A类{
公众：
静态int func（）{return 0；}
};
样板
B类：A{
};

如果您想让

C

或

C

工作，您可以依赖包含给定函数的基本非模板类，也可以使用模板专门化，如下所示：

template<typename...>
struct C;

template<>
struct C<> {
    static int func() { return 0; }
};

template<typename T>
struct C<T>: C<> {
    // all the other things around...
};

int main() {
    C<int>::func();   
    C<>::func();   
}

模板
结构C；
样板
结构C{
静态int func（）{return 0；}
};
样板
结构C:C{
//周围的所有其他事情。。。
};
int main（）{
C：：func（）；
C：：func（）；
}

由于您没有提供主模板的定义，接受的专门化包括：

• 仅包含给定函数的

  C

• C

  只接受原始示例中的参数

在电视上看

---

如果不能使用可变模板，您仍然可以对自定义类型执行类似操作。
例如：

struct func_only {};

template<typename T = func_only>
struct C;

template<>
struct C<func_only> {
    static int func() { return 0; }
};

template<typename T>
struct C: C<func_only> {
    // all the other things around...
};

int main() {
    C<int>::func();   
    C<>::func();   
}

struct func_only{}；
样板
结构C；
样板
结构C{
静态int func（）{return 0；}
};
样板
结构C:C{
//周围的所有其他事情。。。
};
int main（）{
C：：func（）；
C：：func（）；
}

---

---

也就是说，让它成为一个自由函数在我看来是最好的解决方案。

如果您想让

C

或

C

工作，您可以依赖包含给定函数的基本非模板类，也可以使用模板专门化，如下所示：

template<typename...>
struct C;

template<>
struct C<> {
    static int func() { return 0; }
};

template<typename T>
struct C<T>: C<> {
    // all the other things around...
};

int main() {
    C<int>::func();   
    C<>::func();   
}

模板
结构C；
样板
结构C{
静态int func（）{return 0；}
};
样板
结构C:C{
//周围的所有其他事情。。。
};
int main（）{
C：：func（）；
C：：func（）；
}

由于您没有提供主模板的定义，接受的专门化包括：

• 仅包含给定函数的

  C

• C

  只接受原始示例中的参数

在电视上看

---

如果不能使用可变模板，您仍然可以对自定义类型执行类似操作。
例如：

struct func_only {};

template<typename T = func_only>
struct C;

template<>
struct C<func_only> {
    static int func() { return 0; }
};

template<typename T>
struct C: C<func_only> {
    // all the other things around...
};

int main() {
    C<int>::func();   
    C<>::func();   
}

struct func_only{}；
样板
结构C；
样板
结构C{
静态int func（）{return 0；}
};
样板
结构C:C{
//周围的所有其他事情。。。
};
int main（）{
C：：func（）；
C：：func（）；
}

---

---

也就是说，让它成为一个自由函数在我看来是最好的解决方案。

如果不依赖模板实例化，为什么不让它成为一个普通的、自由的静态（或非静态）函数呢？“我认为这在有些情况下会很有用，因为在逻辑上属于一个类的辅助静态函数”您可能会添加一些不正确的默认模板参数，如

template

，因此使用此类对象将不起作用，但您的方法将可以在不指定模板参数的情况下调用

C:：func（）

@Danra为什么它“逻辑上属于一个类”？如果没有对模板实例化的依赖，为什么不将它设置为一个普通的、自由的静态（或非静态）函数呢？“我认为这在您有一些辅助静态函数的情况下很有用，这些函数逻辑上属于一个类”您可能会添加一些不正确的默认模板参数，如

template

，因此使用此类对象将不起作用，但您的方法将可以在没有spe的情况下调用