标签: specialization

动机：有一个函数可以接受 lambda 或值（为简单起见，可以是 或const char *）std::string，如下所示

template <typename LambdaOrValue>
void Function(LambdaOrValue &&lambda_or_value) {
  // The idea here is to have sort of a magic that
  // evaluates a lambda if an argument is actually
  // a lambda or do nothing otherwise
  if (Evaluate(std::forward<LabmdaOrValue>(lambda_or_value)) ==
               std::string("pattern"))
    // Do something
}

我正在努力正确实现一个功能Evaluate()，即使下面的代码编译。特别是，在基于“值”的实现中使用哪个返回值来保留类型（例如const char *或std::string）

#include <type_traits>
#include <iostream>

template <typename T>
decltype(std::declval<T>()()) Evaluate(T &&t) {
  return t();
}

template <typename T>
T …

我正在尝试将一些代码从VC9移植到G ++,但是我遇到了模板特化的问题,显然不允许类成员使用.

以下代码是类方法的getValue特化的这些错误的示例.在所有情况下,错误都是"错误:非命名空间范围中的显式特化class ..."

template<typename T> T getValue(const_iterator key)const
{
    try{return boost::lexical_cast<T>(key->second);}
    catch(boost::bad_lexical_cast &e)
    {
        throw TypeParseError<T>(name, key->first, e.what());
    }
}
template<typename T> T getValue(const std::string &key)const
{
    iterator i = find(key);
    if(i == end())throw KeyNotFound(name,key);
    else return getValue(i);
}
template<> std::string getValue<std::string>(const_iterator key)const
{
    return key->second;
}
template<> std::string getValue<std::string>(const std::string &key)const
{
    const_iterator i = find(key);
    if(i == end())throw KeyNotFound(name,key);
    else return i->second;
}

它是否只是不支持确切的语法,并且一个小的更改将使它工作,或者我是否需要更改代码以避免像这样的专业化？如果后者这是一般的最佳方式吗？

我有以下结构:

template <typename T>
struct Odp
{
    T m_t;
};

我想专门化它,所以我可以添加一个运算符,以便类型与STL集很好地匹配.(我无法Odp直接修改;它是遗留代码.)以下是我看到的两种方法:

struct Ftw : public Odp<int>
{
    bool operator==(const Ftw& rhs)
    {
        return m_t == rhs.m_t;
    } 
};

struct FtwContain
{
    Odp<int> odp;
    bool operator==(const FtwContain& rhs)
    {
        return odp.m_t == rhs.odp.m_t;
    }
};

有没有理由比第一个更喜欢第二个？第一种方法似乎允许更清晰的代码:

Ftw ftw;
ftw.m_t = 2;

FtwContain ftwContain;
ftwContain.odp.m_t = 2;

(另外,我很可能对"模板专业化"这个术语的含义感到困惑.)

我发现模板方法可能会重载,我可以在模板类上做同样的事情吗？如果2个模板类与模板类实例化匹配,我们可以使用构造函数中的参数类型来推断使用哪个模板类.

template <typename T>
class A{
  A(T){}
};

template <typename T>
class A{
  A(T*){}
};

int main(){
  A<int*> a((int*)0);
  A<int> a((int*)0);
  return 0;
}

我有一个类似的结构

template<typename T>
struct S
{
    T value;

    void Set(const T& val) { value = val; }

    void Foo();
}

T可以是int,float,char,short和long long,也可以是N个其他基于struct的POD之一.

有大约50个左右的POD,它们看起来像:

struct POD1 { int i; char c; double d; }
struct POD2 { char c; double d; }
struct POD3 { POD1 p1; char s[10]; }

我想知道如何最好地构建这种安排.如果我想要通用T案例来处理POD,我是否需要提供int,float,char,short和long long案例的明确,具体的定义？

先感谢您.

代码:

#include <iostream>

template<int N>
struct A
{
    int a = A<1>::a;
};


int main() { }

对CLANG无效,但对GCC有效.什么行为实际上是正确的？该标准对此并不十分清楚:

N4296::14.7.1/1 [temp.inst]

除非已经显式实例化了类模板特化(14.7.2)或显式专用(14.7.3),否则在需要完全定义的对象类型或完整性的上下文中引用特化时,将隐式实例化类模板特化.类类型会影响程序的语义.

Mooing Duck 在这里发表评论"一个函数不能返回多个类型.但是,你可以专门化或委托重载,这很好."

我开始考虑这个问题,我想弄清楚,这个法律代码是怎样的:

template <typename T>
T initialize(){ return T(13); }

通话时:

auto foo = initialize<int>();
auto bar = initialize<float>();

这不会转换为仅由return-type重载的2个同名函数吗？

有人能告诉我如何删除下面的重复专业吗？

#include <iostream>
#include <fstream>
#include <string>

struct Thing {
    int a, b;
    void load (std::istream& is) {is >> std::skipws >> a >> b;}
};

struct Object {
    int a, b, c;
    void load (std::istream& is) {is >> std::skipws >> a >> b >> c;}
};

template <typename...> struct PassArgs;

// General case.
template <typename First, typename... Rest>
struct PassArgs<First, Rest...> : PassArgs<Rest...> {
    void operator()(std::istream& is, First& first, Rest&... rest) const {
        is >> first;
        PassArgs<Rest...>::operator()(is, rest...);
    }
}; …