Вызов и перегруженная функция шаблона

В функции main() я хочу вызвать метод1, а не метод2. Как я могу этого добиться? Спасибо за чтение

И это именно то, что вы звоните

obj.GetVal(false)

потому что false — это bool, так что это точное совпадение с не-шаблонным методом. И когда вызов совпадает с методом шаблона и методом не шаблона, метод не шаблона (в случае точное совпадение) предпочтительнее.

Настоящая проблема: как вызвать метод2, вызвав его с типом (bool) не шаблонного метода (метод 1)?

Ответ (возможный ответ): добавьте 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 становится более подходящим.

Проблема может быть решена путем изменения A, как в ответе Jarod42 (добавление неконстантного нешаблонного метода, который вызывает константный метод, или SFINAE, отключающего метод шаблона 2, когда T равно bool), или как в ответе Странника (создание const также метода 2) .

Но если вы не хотите (или не можете) изменять класс A, вы можете просто использовать static_assert() непосредственно в main()

std::cout << static_cast<A const &>(obj).GetVal(false) << std::endl;

Вы можете добавить дополнительную перегрузку:

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 */ }}
};

Или используйте SFINAE для метода2, чтобы отбросить параметр 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 */ }}
};

Я знаю только 2 варианта

1. Использовать все перегрузки как константы

   //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*/ }
   

2. или как не константа

   //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 const, используйте второй пример 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*/ }