标签: specialization

noob在这里仍在试验模板.试图编写一个消息处理类模板

template <typename T> class MessageProcessor {

  //constructor, destructor defined
  //Code using t_ and other functions
foo( void ) {

//More code in a perfectly fine method
}
  private:  T *t_

};

全部在头文件中定义.我已经建立并测试了我的课程,一切都很好.现在,我正在尝试这样做:

template <typename T> class MessageProcesor {

  //Same stuff as before

foo(void) {
//Same code as before in foo, but one new line:
  t_->getMessageSender<MessageType>();

}

private: T *t_;
};

但是,这行在">"标记之前给出了错误表达式类型的错误.

我添加了必要的头文件来定义MessageType是什么.我之前很久就使用过这个函数,只是不是在这种情况下.

我怀疑编译器不喜欢模板函数在未定义的类模板(unspecialized？)中完全定义(专用？)的事实.我并不完全了解模板"专业化"的原因.大多数解释都集中在"完整"或"部分"的概念上,而不是首先使它成为专业的概念.

如果您想查看更多代码,请道歉.我在工作时没有互联网接入,这就是我正在做的事情,所以我必须将所有内容放入我的心理"暂存器"并将其带回家.

假设我们有以下模板类

template<typename T> class Wrap { /* ... */ };

我们无法改变 Wrap.这很重要.

让我们有来自的类Wrap<T>.例如,

class NewInt  : public Wrap<int>     { /* ... */ };
class MyClass : public Wrap<myclass> { /* ... */ };
class Foo     : public Wrap<Bar>     { /* ... */ };

我们也不能改变这些类.以上所有课程均为第三方.他们不是我的.

我需要以下编译时间type_traits:

template<class T>
struct is_derived_from_Wrap { 
     static const bool value = /* */;
};

我需要什么？

assert(is_derived_from_Wrap<Int>::value == true);  // Indeed I need static assert
assert(is_derived_from_Wrap<MyClass>::value == true);
assert(is_derived_from_Wrap<char>::value …

我有一个vec_base像这样定义的类:

template<typename T, std::size_t Size>
class vec_base;

我想把它专门化

vec_base<float, /* any multiple of 4 */>

和

vec_base<double, /* any multiple of 2 */>

例如,可以独立地拥有特定成员

vec_base<int, 6>

哪个会有我已定义的通用成员

我很难实现这个,因为允许的宽松大小(4或2的任意倍数),如果它特别是2或4我知道我可以执行完全专业化,但事实并非如此:/

我该怎么做？感谢任何帮助,我总是喜欢学习新的语言技巧!

编辑

好吧所以我到目前为止:

template<std::size_t Size>
struct is_div_by_4{static const bool value = (Size % 4 == 0);};
// have to define because of template requirements
// about not being dependent on other parameters

template<typename T, std::size_t Size, bool is_special>
class vec_base;

template<typename T, std::size_t Size>
class vec_base<T, Size, false>{
    // generic …

让我们有一个简单的片段：

template<class T, class... Args>
struct A {
    void operator()() { std::cout << "A"; }
};

template<class T, class... Args>
struct A<T, double, Args...> {
    void operator()() { std::cout << "B"; }
};

template<class T, class B, class... Args>
struct A<T, B, double, Args...> {
    void operator()() { std::cout << "C"; }
};

我可以这样使用：

int main() {
    A<int, int, int> a;
    A<int, double, int> b;
    A<int, int, double> c;
    a(); b(); c();
    return 0;
}

它正确返回"ABC"。但是当我声明时，A<int, double, …

我有一个模板化的类,里面我有一个模板化的函数(不同的模板参数),我有问题让编译器调用正确的.

例:

template< class Parm1, class Parm2, class Parm3 >
class Class {
public:
   void   Func( Parm1 arg1, Parm2 arg2 ) {
      Call<Parm3>( arg1, arg2 ); 
   }

protected:
   template< class Type >
   void   Call( Parm1 arg1, Parm2 arg2 ) {
   }

   template<>
   void   Call<void>( Parm1 arg1, Parm2 arg2 ) {
   }
};

因此,如果Parm3的类型为"void",我希望调用第二个Call.否则第一个.VS它工作正常,但GCC呕吐了它.它总是称为第一个.现在这是一个专门针对非专业课程的问题,还是与我专注于'void'的事实有关

任何帮助都会很棒.谢谢.

我对模板专业化略有困惑.

我有类Vector2,Vector3其中包含operator+=(以下面的方式定义).

   Vector2& operator+=(const Vector2& v) {

      x() += v.x(), y() += v.y();

      return *this;
   }

现在我想添加泛型添加行为并说出如下内容:

template <typename V> const V operator+(const V& v1, const V& v2) {
   return V(v1) += v2;
}

这编译很好,适用于Vector2和Vector3.但是,假设我想为我做一个稍微高效的"+"操作,我Vector2希望它采用以下方式(使用模板特化):

template<> const Vector2 operator+(const Vector2& v1, const Vector2& v2) {
   return Vector2(v1.x() + v2.x(), v1.y() + v2.y());
}

这看起来很好,但遗憾的是,将这两个代码块放在一起使得代码无法编译

(链接器说错误LNK2005: "Vector2 const operator+<Vector2>(Vector2 const &,Vector2 const &)" (??$?HVVector2@core@lf@@@core@lf@@YA?BVVector2@01@ABV201@0@Z) already …

我的一个类声明了一个模板化的函数:

template<class A, class B>
A do_something(const std::vector<B> &data)

我想部分专注于typename A.B是一个实现非常小的接口的类型系列,我们使用了很多,所以我希望我的专业化是通用的B.我怀疑这是双重烦恼,因为typename A它只用作返回类型.

从互联网上,我发现我不能部分专门化一个函数,所以我创建了一个类,如下所示:

template<class A, class B> 
class do_something_implementation {
  public:
    do_something_implementation(const std::vector<B> &data_) {
      data = data_;
    }

  int do_something_implementation<int, B>::operator()() {
    /* Complicated algorithm goes here... */
  }

  double do_something_implementation<double, B>::operator()() {
    /* Different complicated algorithm goes here... */
  }

  private:
      std::vector<B> data;
}

当我尝试编译它(使用Visual Studio 2008)时,编译器崩溃(!),我收到以下错误:

fatal error C1001: An internal error has occurred in the compiler.

我认为这是我的问题,而不是编译器.有没有更好的方式来表达我的目标部分专业化？

下面的代码(编译和执行得当,做我想要的)是一个怪胎,而写一个类来存储需要删除的指针,当它不再知道自己的类型的能力不同类型的属性,我经历的一个小例子.我的解决方案是使用模板化函数创建一个Deleter类,该函数可以获取并存储其地址以删除特定类型.我不明白为什么这段代码有效,具体来说:

• 为什么不打断断言呢？
• 为什么/如何需要/使用(看似)无关的专业化？

码:

#include <iostream>
#include <string>
#include <cassert>

#include <locale> //Just here as an unused class to specialize

using namespace std;

typedef void(*void_voidptr_func_t)(void*);

class ClassWithDestructor {
public:
    ~ClassWithDestructor() {
        cout << "Destroyed\n";
    }
};

class Deleter {
public:
    template <class T>
    static void Delete (T* ptr) {
        assert(0);
    }

    //locale here can be any class
    //it doesn't matter what class it is
    //but if this specialization doesn't exist
    //compile fails
    template <class locale>
    static void Delete(void* …

当模板参数类型相同时,我试图专门化两个模板参数的功能.我这样做的方式如下:

#include <iostream>
#include <type_traits>

using namespace std;

template<typename U, typename T>
int fun( U& u, T t );

template<>
inline
int fun( int& u, float t )
{
    cout << "int, float" << endl;
    return 0;
}

template<typename U, typename T>
inline
int fun( U& u, typename std::enable_if<std::is_same<U, T>::value ,T>::type t )
{
    cout << "U == T" << endl;
    return 0;
}

int main()
{
    int a;
    float b1, b2;

    fun(a, b1);
    fun(b1, b2);

    return 0;
}

这段代码编译得很好(GCC …

假设我有一组继承自单个超类S的类:

class S{ ... };

class C1 : public S{ ... };
class C2 : public S{ ... };

然后假设我有一个模板化的方法:

template<class T> void foo(T* instance);

我想静态检查foo从未被调用提供超类的实例,但只调用提供其中一个(具体)子类(例如显式调用foo<C1>(x)实例)

这可能吗？