C++ 如何在c+中执行依赖于if-else的类型+；模板？ //模板专门化 #包括 使用名称空间std； //类模板： 模板 类霉菌容器{ T元素； 公众： mycontainer（T arg）{element=arg；} T增加（）{ //if（T.type==int）//如何执行此操作或类似操作？ //如果一个int return++元素； //if（T.type==char） //如果（（element>='a'）&&（element

您可以使用

typeid

：

// template specialization
#include <iostream>
using namespace std;

// class template:
template <class T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase () {

    //if(T.type==int)//how to do this or something similar?
    //do this if an int
    return ++element;

    //if(T.type==char)
     //if ((element>='a')&&(element<='z'))
      //element+='A'-'a';
      //return element;

    }
};

或者您可以使用

std:：is_same

类型特征：

if (typeid(T) == typeid(int))

if（std:：is_same:：value）

你想要的可能是一个。 不幸的是，C++11对这种语言构造没有本机支持

但是，如果您只想检查两种类型是否相同，那么

std:：is_same

type特征应该可以帮助您：

if (std::is_same<T, int>::value)

---

此外，正如注释中正确指出的，编译器可能会发出警告，因为您的条件将始终计算为

true

或

false

，因此这两个分支中的一个分支将包含无法访问的代码。

简单重载如何

if (std::is_same<T, int>::value)
{
    cout << element;
}
else if (std::is_same<T, my_class>::value)
{
    element->print();  // Would not compile when T is int!
}

//在私有部分
静态int&do_递增（int&i）{return++i；}
静态字符和do_增加（字符和c）{
如果（c>='a'&&c，通常的解决方案是转发到重载函数
带一个附加参数。类似于：

// in the private section
static int& do_increase(int& i){ return ++i; }
static char& do_increase(char& c){
  if(c >= 'a' && c <= 'z')
    c += 'A' - 'a';
  return c;
}
template<class U>
static U& do_increase(U& arg){
  // some default implementation?
  return arg;
}

模板
类霉菌容器
{
T增加（int const*）{/*对int*/}的特殊处理
T增加（…）{/*默认处理*/}
公众：
T增加（）
{
收益增加（（T常数*）0）；
}
};

只要有一点想象力，你就能想出各种各样的办法
区别。如果你用额外的
参数模板，您甚至可以利用SFINAE:design
伪参数，使模板类型替换失败，以及
在过载设置中不考虑该功能。以及
因为所有函数都是内联的，所以很可能
如果您进行优化，将不会产生额外的开销。
这与Andy Prowls的答案一致，但都是在编译时使用具有专门化的最小帮助器类完成的

在本例中，您有一个实际执行专门化的helper，但您也可以让helper类只接受一个bool，然后使用类似于
std:：is_same:：value
的内容将该值作为模板参数传递

template <typename T>
class MyContainer
{
    T increase( int const* ) { /* special treatment for int */ }
    T increase( ... )        { /* default treatment         */ }
public:
    T increase()
    {
        return increase( (T const*)0 );
    }
};

模板
结构myContainerHelper；
{
//一般情况
静态内联T增加（T元素）
{
return++元素；
}
};
模板
结构myContainerHelper
{
//具体案例
静态内联字符增加（字符元素）
{
如果（（element>='a'）&&（element），则可以使用显式模板专门化

template <typename T>
struct myContainerHelper;
{
    // General Case
    static inline T increase(T element)
    {
        return ++element;
    }
};

template <>
struct myContainerHelper<char>
{
    // Specific case
    static inline char increase(char element)
    {
        if ((element>='a')&&(element<='z')) element+='A'-'a';
        return element;
    }
};

template <class T>
class mycontainer 
{
    T element;
public:
    mycontainer (T arg) {element=arg;}
    T increase () 
    {
        return myContainerHelper<T>::increase(element);
    }
};

#包括
使用名称空间std；
//类模板：
模板
类霉菌容器{
T元素；
公众：
mycontainer（T arg）{element=arg；}
T增加（）；
};
模板
int mycontainer:：increase（）{
return++元素；
}
模板
char mycontainer:：increase（）{
如果（（元素>='a'）&&（elementC++确实有编译时
if
：它被称为函数重载解析。这也意味着您会收到未使用的分支的警告。更好的形式是标记分派，我在回答时想到了这一点，但简单的重载也可以做到这一点。@JamesKanze:这与真正的
静态方法完全不同if
construct。您可能可以通过简单的重载解析来实现，但它不容易扩展（例如，如果他想为整型类型做一件事，为所有其他类型做另一件事）。@AndyProwl它实现了相同的目的。内部
increase
调用不需要模板参数（事实上，这将是一个错误）@Xeo正确。我最初做了一些更通用的事情，这要求两个目标函数是模板（为了让SFINAE发挥作用）。我会在这里解决它。如果有一个
static\u If
…也许这会解决同样的问题有很多关于
static\u If
的建议，但都有问题。SG8最近写了。@JosephMansfield你提供的链接没有预览。C++17引入了constepr If，这可能是你想要的。我喜欢这个不依赖于任何成员函数参数的解决方案。我需要将
*userp
转换为成员函数内的
t
模板类型，例如
静态大小\u t写回调（void*response，size\t size，size\t nmemb，void*userp）
，具有严格的不可修改签名。
template <typename T>
struct myContainerHelper;
{
    // General Case
    static inline T increase(T element)
    {
        return ++element;
    }
};

template <>
struct myContainerHelper<char>
{
    // Specific case
    static inline char increase(char element)
    {
        if ((element>='a')&&(element<='z')) element+='A'-'a';
        return element;
    }
};

template <class T>
class mycontainer 
{
    T element;
public:
    mycontainer (T arg) {element=arg;}
    T increase () 
    {
        return myContainerHelper<T>::increase(element);
    }
};

#include <iostream>
using namespace std;

// class template:
template <class T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase();
};


template<>
int mycontainer<int>::increase(){
    return ++element;
}

template<>
char mycontainer<char>::increase(){
    if ((element>='a')&&(element<='z'))
       element+='A'-'a';
    return element;
}

int main(){
        mycontainer<int> A(10);
        mycontainer<char> B('x');

        cout << A.increase() <<endl;
        cout << B.increase() <<endl;
        return 0;
}