Question

假设我在下面所示的类中有2个重载方法请忽略这种奇怪的方法重载的需要，这是我最近遇到的

<v-dialog>
  <template #activator="{ on: dialog }">
    <v-tooltip>
      <template #activator="{ on: tooltip }">
        <v-btn v-on="{ ...tooltip, ...dialog }">Button</v-btn>
      </template>
      <span>Tooltip text</span>
    </v-tooltip>
  </template>
  <v-card>
    Dialog content
  </v-card>
</v-dialog>

在class A{ public: //Lets call this method 1 int GetVal(bool isCondition) const { //do something and return val } //Lets call this method 2 template<typename T> int GetVal(T expression) { //do something using expression //and return val } }; int main() { A obj; int val = obj.GetVal(false) << std::endl; //I want to invoke method 1 }函数中，我想调用method1而不是method2。我该如何实现？感谢您的阅读

Answer 1

在main（）函数中，我要调用method1而不是method2。我该如何实现？感谢您的阅读

这正是您要拨打的电话

obj.GetVal(false)

因为false是bool，所以它与非模板方法完全匹配。并且，当调用使用模板方法和非模板方法进行匹配时，首选非模板方法（在完全匹配的情况下）。

真正的问题是：如何调用非模板方法（方法1）类型（bool）调用的method2？

答案（可能的答案）是：添加一个template来调用

obj.template GetVal(false)

以下是一个完整的工作示例

#include <iostream>

struct A
 {
   //Lets call this method 1
   int GetVal (bool)
    { return 1; }

   //Lets call this method 2
   template <typename T>
   int GetVal (T)
    { return 2; }
 };

int main ()
 {
   A obj;

   std::cout << obj.GetVal(false) << std::endl;           // print 1
   std::cout << obj.template GetVal(false) << std::endl;  // print 2
 }

-编辑-

鉴于OP精确地指出方法1为const（而方法2不是），方法2成为更好的匹配。

可以按照Jarod42的答案修改A来解决该问题（添加一个调用const方法的not-const not-template方法，或者当T为{{1时，SFINAE禁用模板方法2 }}或Wanderer的答案（使bool也是方法2）。

但是，如果您不会（或者如果不能）修改类const，则可以直接在A中使用static_assert()

main()

Answer 2

您可能会添加额外的重载：

class A{
public:
    // Lets call this method 1
    int GetVal(bool isCondition) const { /* do something and return val */ }
    int GetVal(bool b) { return static_cast<const A&>(*this).GetVal(); }

    // Lets call this method 2
    template<typename T>
    int GetVal(T expression) { /* do something using expression and return val */ }}
};

或对方法2使用SFINAE放弃bool参数：

class A{
public:
    // Lets call this method 1
    int GetVal(bool isCondition) const { /* do something and return val */ }

    // Lets call this method 2
    template <typename T, std::enable_if_t<!std::is_same<bool, T>::value>, int> = 0>
    int GetVal(T expression) { /* do something using expression and return val */ }}
};

Answer 3

我只有2个选择

使用所有重载作为const

//Lets call this method 1
int GetVal(bool isCondition) const
{ /*do something and return val*/ }

//Lets call this method 2
template<typename T>
int GetVal(T expression) const
{ /*do something using expression and return val*/ }

或作为非const

//Lets call this method 1
int GetVal(bool isCondition)
{ /*do something and return val*/ }

//Lets call this method 2
template<typename T>
int GetVal(T expression)
{ /*do something using expression and return val*/ }

然后将调用方法1

   std::cout << obj.GetVal(false) << std::endl;

如果需要方法1常量，请使用Jarod42第二个示例。真

template <typename T, std::enable_if_t<!std::is_same<bool, T>::value> = 0 >
int GetVal(T expression)
{ /*do something using expression and return val*/ }

调用和重载模板功能

3 个答案: