Question

我有以下代码。代码编译得很好：

档案A.h

#include <memory>

class B {};
class C {};

template <class T1>
class A
{
public:
    explicit A(T1 t1);
    template <class T2, class T3>
    void foo(T1 t, T2 t2, T3 t3);
    template <B&, C&>
    void foo(T1 t, const std::shared_ptr<B>& b, const std::shared_ptr<C>& c);
};

#include "A-inl.h"

文件A-inl.h

#include <iostream>
#include <memory>

template <class T1>
A<T1>::A(T1 t)
{
}

template <class T1>
template <class T2, class T3>
void A<T1>::foo(T1 t, T2 t2, T3 t3)
{
    std::cout << "Foo templatized" << std::endl;
}

template <class T1>
template <B&, C&>
void A<T1>::foo(T1 t, const std::shared_ptr<B>& b, const std::shared_ptr<C>& c)
{
    std::cout << "Foo specalized" << std::endl;
}

文件main.cpp：

#include <iostream>
#include<memory>

#include "A.h"

class X{};
class Y{};
class Z{};

int
main()
{
    X x;
    A<X> a(x);
    Y y;
    Z z;
    a.foo(x, y, z);
    const std::shared_ptr<B> b = std::make_shared<B>(B());
    const std::shared_ptr<C> c = std::make_shared<C>(C());
    a.foo(x, b, c);
}

输出：

Foo templatized
Foo templatized

我有两个问题：

（1）如何调用模板函数foo的专用版本。

（2）我有

 template <B&, C&>
 void foo(T1 t, const std::shared_ptr<B>& b, const std::shared_ptr<C>& c);

类型是什么：

const std::shared_ptr<B>& b
                      --

是吗

B& or B.

Answer 1

template <B& /*unnamed*/, C& /*unnamed*/>
void foo(T1 t, const std::shared_ptr<B>& b, const std::shared_ptr<C>& c);

是foo的重载，而非专业化。

可以通过指定不可推导的引用来调用它：

static B globalB;
static C globalC;

int
main()
{
    X x;
    A<X> a(x);
    Y y;
    Z z;
    a.foo(x, y, z);
    const std::shared_ptr<B> b = std::make_shared<B>(B());
    const std::shared_ptr<C> c = std::make_shared<C>(C());
    a<globalB, globalC>.foo(x, b, c);
}

类型是什么：const std::shared_ptr<B>& b

B不是模板参数，而是类。因此B 类B。

Answer 2

因为B和C是普通类，所以你不需要专业化中的模板参数

类定义：

template <class T1>
class A
{
public:
    explicit A(T1 t1);
    template <class T2, class T3>
    void foo(T1 t, T2 t2, T3 t3);

    void foo(T1 t, const std::shared_ptr<B>& b, const std::shared_ptr<C>& c); 
};

和重载：

template <class T1>
void A<T1>::foo(T1 t, const std::shared_ptr<B>& b, const std::shared_ptr<C>& c)
{
    std::cout << "Foo specalized" << std::endl;
}

工作正常

如果您希望您的重载适用于您可以执行的每种类型的共享指针：

A.H

class A
{
    // ...
    template <class T2, class T3>
    void foo(T1 t1, const shared_ptr<T2>& t2, const shared_ptr<T3>& t3);
};

A-inl.h

template <class T1>
template <class T2, class T3>
void A<T1>::foo(T1 t1, const shared_ptr<T2>& t2, const shared_ptr<T3>& t3)
{
    std::cout << "Foo specalized" << std::endl;
}

C ++调用模板专用函数

2 个答案: