是否可以根据类模板的参数调用类方法和全局方法？

Question

这是我的问题：

#include <string>



struct Print
{
    template <typename T>
    void Printer( const T& data )
    {
        PrinterInstance( data );
    }


    void PrinterInstance( const int& data )
    {
        printf( "INTEGER\n" );
    }
};



void PrinterInstance( const std::string& data )
{
    printf( "STRING\n" );
}



int main()
{
    Print print;
    print.Printer( "3" );
    return 0;
}

在 Print 类中，我有一个模板 Printer，它基本上根据模板的参数调用 PrinterInstance。此外，我应该能够通过在类之外添加更多 PrinterInstance 来扩展此功能。

但这不会编译。如果我只在类中实现 PrinterInstance，那没关系。如果我只在类外实现 PrinterInstance，也可以。但是一旦我在类内和类外都有一个 PrinterInstance，模板将只尝试使用类一。

我可以做这个吗？

编辑： 它必须在 C++11 中工作。

Answer 1

如果您可以在Print 内添加模板PrinterInstance()

template <typename T>
void PrinterInstance (T const & data)
 { ::PrinterInstance(data); }

调用全局PrinterInstance()，当类型完全匹配时，编译器使用方法PrinterInstance()，否则使用全局版本（通过模板方法）。

但是，正如 LeDYoM 的回答一样，这要求在 Printer 正文之前定义（或至少声明）PrinterInstance() 的全局版本。

以下是完整的编译示例

#include <string>
#include <iostream>

void PrinterInstance ( const std::string& data )
 { std::cout << "STRING, " << data << std::endl; }

struct Print
 {
   template <typename T>
   void Printer (T const & data)
    { PrinterInstance( data ); }

   template <typename T>
   void PrinterInstance (T const & data)
    { ::PrinterInstance(data); }

   void PrinterInstance (int const & data)
    { std::cout << "INTEGER, " << data << std::endl; }
 };

int main ()
 {
   Print p;
   p.Printer("3");
   p.Printer(5);
 }

Answer 2

如果你可以使用 C++17：

#include <string>
#include <type_traits>

void PrinterInstance( const std::string& data );

struct Print
{
    template <typename T>
    void Printer( const T& data )
    {
        if constexpr (std::is_same_v<T,int>)
        {
            PrinterInstance( data );
        }
        else
        {
            ::PrinterInstance(data);
        }
    }

    void PrinterInstance( const int& data )
    {
        printf( "INTEGER\n" );
    }
};

void PrinterInstance( const std::string& data )
{
    printf( "STRING\n" );
}

int main()
{
    Print print;
    print.Printer( "3" );
    return 0;
}

注意： 必须首先声明免费的 PrintInstance。 （或者你想要的所有重载）。 您可以根据需要向 if constexpr 添加任意数量的类型（结构内的重载）。 您可能可以将其翻译成 C++14 和一些 SFINAE。

代码：https://godbolt.org/z/S1ZJ93

Answer 3

问题是成员在命名空间范围内隐藏了函数。

一种解决方案是分派到正确的函数，例如：

void PrinterInstance( const std::string& data )
{
    printf( "STRING\n" );
}

// Declarations of PrinterInstance for built-in should also be visible before `Printer`

struct Print
{
    template <typename T>
    void Printer( const T& data )
    {
        if constexpr (std::is_invocable<decltype(&Print::PrinterInstance), Print, T>::value) {
            PrinterInstance( data );
        } else {
            using ::PrinterInstance; // make function at global scope visible,
                                     // hide member function and so allows ADL
            PrinterInstance( data );
        }
    }


    void PrinterInstance( const int& data )
    {
        printf( "INTEGER\n" );
    }
};

namespace N
{
    struct S{};

    void PrinterInstance( const N::S& )
    {
        printf( "S\n" );
    }
}

Demo

在 C++11 中，可能是；

struct Print
{
    template <typename T>
    void Printer( const T& data );

    void PrinterInstance( char data )
    {
        printf( "CHAR\n" );
    }

    void PrinterInstance( const int& data )
    {
        printf( "INTEGER\n" );
    }
};

template <typename T>
auto printerImpl(Print& p, const T& arg) -> decltype(p.PrinterInstance(arg))
{
    return p.PrinterInstance(arg);
}

template <typename T>
auto printerImpl(Print&, const T& arg) -> decltype(PrinterInstance(arg))
{
    return PrinterInstance(arg);
}

template <typename T>
void Print::Printer( const T& data )
{
    printerImpl(*this, data);
}

Demo