标签: partial-specialization

我想知道在when没有案例基础的boost::hana::when<false>情况下，专业化是如何工作的。

boost::hana::tag_of 执行：

 template<bool condition>
 struct when; // forward declaration only

 template<typename T, typename = void>
 struct tag_of;

 template<typename T, typename>
 struct tag_of : tag_of<T, when<true> >
 {};

 template<typename T, bool condition>
 struct tag_of<T, when<condition> >
 {
    using type = T;
 };

和一个测试示例：

 struct my_tag {};
 struct my_tag2 {};

 namespace boost {
    namespace hana {

       template<class T>
       struct tag_of<T, when<std::is_same<T, int>{}()> >
       {
           using type = my_tag;
       };

       template<class T>
       struct tag_of<T, when<std::is_same<T, unsigned>{}()> >
       { …

我有一个处理不同容器的通用函数。

template<template<class, class> class C, class T, class A>
void handle(C<T, A> const& c)
{
    cout << "General handling\n";
}

现在，如果我将自定义容器传递给它，我希望它做出不同的反应。为简单起见，我首先尝试以单独的方式处理向量，尝试将此函数部分专门化为向量。
这就是我认为它应该是什么样子。

template<class T, class A>
void handle<std::vector>(std::vector<T, A> const& c)
{
    cout << "vector handling\n";
}

但是gcc给出了以下错误：

无法执行程序编译器返回：1 编译器标准错误：16:36：错误：模板 id 'handle class std::vector>' in declaration of primary template 16 | (std::vector const& c) |

这可以通过部分模板特化来完成吗？

对于主要模板:

template<typename A, typename B> class MyClass {...

与模板专业化,有什么区别

template<typename A, typename B> class MyClass<int, float> {...

和

template<> class MyClass<int, float> {...

#include <iostream>
using namespace std;

template <class T1, class T2>
class A {
public:
    void taunt() { cout << "A"; }
};

template <class T1>
class A<T1, T1> {
public:
    void taunt() { cout << "B"; }
};

class B {};

class C {};

int main (int argc, char * const argv[]) {

    A<B> a;

    return 0;
}

如何将我的两个参数模板转换为一个参数模板？

上面的代码会给'A a;'一个编译错误 '错误的模板参数数'.

我正在编写一个带有一个类型参数和一个布尔值的模板类,这里是代码:

template<class T, bool p = true>
class A
{
private:
    T* ptr;
public:
    A();
};


template<class T>
A<T,true>::A()
{
    ptr = 0xbaadf00d;
}

int main()
{
    A<int> obj;
    A<int, false> o;
    return(0);
}

我收到这些编译错误:

Error   1   error C3860: template argument list following class template name must list parameters in the order used in template parameter list tst.cpp 15
Error   2   error C2976: 'A<T,p>' : too few template arguments  tst.cpp 15

我究竟做错了什么？或者由于某种原因禁止部分专门化非类型参数？

同时,如果我在if语句中使用boolean参数,我收到此警告:

Warning 1   warning C4127: conditional expression is …

我只有一个简单的问题,请查看此代码:

template < typename A >
void foo( A a )
{ cout<<"1\n"; };

template< >
void foo<float>( float a )
{  cout<<"2\n"; }

void foo( float a )
{ cout<<"3\n"; }


int main()
{
    foo<float>( 1.0f );
}

用g ++ 4.7.2编译当然可以,但我不清楚的是为什么输出是"2"而不是"3".

据我记得,非模板函数应始终优先用于模板,因此为什么称为专用foo？

谢谢

我是C++模板的新手.谁能解释为什么我的专用构造函数永远不会被执行.它删除const和引用运算符时工作.

#include<iostream>
#include<string>

using namespace std;

template<typename T>
class CData
{
public:
    CData(const T&);
    CData(const char*&);
private:
    T m_Data;
};

template<typename T>
CData<T>::CData(const T& Val)
{
    cout << "Template" << endl;
    m_Data = Val;
}
template<>
CData<char*>::CData(const char* &Str)
{
    cout << "Char*" << endl;
    m_Data = new char[strlen(Str) + 1];
    strcpy(m_Data, Str);
}

void main()
{
    CData<int> obj1(10);
    CData<char*> obj2("Hello");
}

输出是

模板

模板

我创建了这些类型特征来确定类型是否是动态容器,但是当对向量的引用未返回true时,最近遇到了混乱.

template<typename T>
struct is_dynamic_container
{
    static const bool value = false;
};

template<typename T , typename Alloc>
struct is_dynamic_container<std::vector<T , Alloc>>
{
    static const bool value = true;
};

我想我需要使用std::decay,但我无法弄清楚是否可以这样做而不是在呼叫站点.

template<typename T , typename Alloc>
struct is_dynamic_container<std::decay<std::vector<T , Alloc>>::type>
{
    static const bool value = true;
};

^^这不起作用.

我只想写能is_dynamic_container<std::vector<int>&>而不是is_dynamic_container<std::decay<std::vector<int>&>::type>.那可能吗？

假设以下声明:

template <typename T> struct MyTemplate;

以下部分特化的定义似乎使用相同的字母T来表示不同的类型.

template <typename T> struct MyTemplate<T*> {};

例如,让我们进行具体的实例化:

MyTemplate<int *> c;

现在,再次考虑上面部分特化的定义:

template <typename T> struct MyTemplate<T*> {};

在这一行的第一部分(即template <typename T>),T是int *.在线的第二部分(即MyTemplate<T*>),T是int!

那么,部分专业化的定义如何读取？

两个模板参数为同一类型如何部分专业化。

如何使用第二个函数编写此代码。

#include <utility>
#include <iostream>

template <typename A, typename B>
void Translate(A&& a,B* b){
  // make some translate from a to b
  // b->bvalue=a.av;
  std::cout<<"normal function";
}
//if a and b are same type,
template <typename A>
void Translate(A&& a, A* b) {
  *b = std::forward<A>(a);
  std::cout<<"forward function";
}

int main(int argc, char** argv) {
  int in=0,out=0;
  Translate(in,&out);
  return 0;
}

期望输出“转发功能”。