Можно ли использовать явное ключевое слово, чтобы предотвратить автоматическое преобразование параметров метода?

Компилятор выдал предупреждение о "неоднозначном вызове", которого будет достаточно.

Я занимался разработкой TDD и не осознавал, что забыл реализовать соответствующий вызов в фиктивном объекте.

Вы также можете написать версию int, которая вызывает bool.

Нет. explicit предотвращает автоматическое преобразование между определенными классами независимо от контекста. И, конечно, вы не можете этого сделать для встроенных классов.

bool ЯВЛЯЕТСЯ int, который ограничен значением 0 или 1. В этом вся концепция return 0; логически то же самое, что сказать return false; (однако не используйте это в коде).

Нет, вы не можете использовать явное, но вы можете использовать шаблонную функцию для обнаружения неверных типов параметров.

С помощью C++ 11 вы можете объявить шаблонную функцию как deleted. Вот простой пример:

#include <iostream>

struct Thing {
    void Foo(int value) {
        std::cout << "Foo: value" << std::endl;
    }

    template <typename T>
    void Foo(T value) = delete;
};

Это дает следующее сообщение об ошибке, если вы попытаетесь вызвать Thing::Foo с параметром size_t:

error: use of deleted function
    ‘void Thing::Foo(T) [with T = long unsigned int]’

В коде до C++ 11 это может быть выполнено с использованием неопределенной частной функции.

class ClassThatOnlyTakesBoolsAndUIntsAsArguments
{
public:
  // Assume definitions for these exist elsewhere
  void Method(bool arg1);
  void Method(unsigned int arg1);

  // Below just an example showing how to do the same thing with more arguments
  void MethodWithMoreParms(bool arg1, SomeType& arg2);
  void MethodWithMoreParms(unsigned int arg1, SomeType& arg2);

private:
  // You can leave these undefined
  template<typename T>
  void Method(T arg1);

  // Below just an example showing how to do the same thing with more arguments
  template<typename T>
  void MethodWithMoreParms(T arg1, SomeType& arg2);
};

Недостатком является то, что в этом случае код и сообщение об ошибке менее ясны, поэтому следует выбирать вариант C++ 11 всякий раз, когда он доступен.

Повторите этот шаблон для каждого метода, использующего bool или unsigned int. Не предоставляйте реализацию для шаблонной версии метода.

Это заставит пользователя всегда явно вызывать версию типа bool или unsigned int.

Любая попытка вызвать Method с типом, отличным от bool или unsigned int, не будет скомпилирована, потому что член является частным, конечно, с учетом стандартных исключений из правил видимости (друг, внутренние вызовы и т. д.). Если что-то, у кого есть доступ, вызывает частный метод, вы получите ошибку компоновщика.

Что-то, что может сработать для вас, - это использовать шаблоны. Ниже показана функция шаблона foo<>(), специализированная для bool, unsigned int и int. Функция main() показывает, как разрешаются вызовы. Обратите внимание, что вызовы, использующие константу int без суффикса типа, будут разрешены в foo<int>(), поэтому вы получите сообщение об ошибке при вызове foo( 1), если вы не специализируетесь на int. В этом случае вызывающие абоненты, использующие буквальную целочисленную константу, должны будут использовать суффикс "U" для разрешения вызова (это может быть желаемое поведение).

В противном случае вам придется специализироваться на int и использовать суффикс "U" или преобразовать его в unsigned int, прежде чем передавать его в версию unsigned int (или, возможно, сделать утверждение, что значение не отрицательное, если вы этого хотите).

#include <stdio.h>

template <typename T>
void foo( T);

template <>
void foo<bool>( bool x)
{
    printf( "foo( bool)\n");
}


template <>
void foo<unsigned int>( unsigned int x)
{
    printf( "foo( unsigned int)\n");
}


template <>
void foo<int>( int x)
{
    printf( "foo( int)\n");
}



int main () 
{
    foo( true);
    foo( false);
    foo( static_cast<unsigned int>( 0));
    foo( 0U);
    foo( 1U);
    foo( 2U);
    foo( 0);
    foo( 1);
    foo( 2);
}

Ниже приводится очень простая оболочка, которую можно использовать для создания строгого определения типа:

template <typename V, class D> 
class StrongType
{
public:
  inline explicit StrongType(V const &v)
  : m_v(v)
  {}

  inline operator V () const
  {
    return m_v;
  }

private:
  V m_v; // use V as "inner" type
};

class Tag1;
typedef StrongType<int, Tag1> Tag1Type;


void b1 (Tag1Type);

void b2 (int i)
{
  b1 (Tag1Type (i));
  b1 (i);                // Error
}

Одной из приятных особенностей этого подхода является то, что вы также можете различать разные параметры одного и того же типа. Например, у вас может быть следующее:

class WidthTag;
typedef StrongType<int, WidthTag> Width;  
class HeightTag;
typedef StrongType<int, HeightTag> Height;  

void foo (Width width, Height height);

Клиентам foo будет ясно, какой аргумент является каким.

В настоящее время принятый отвечать (с использованием частной шаблонной функции) хорош, но устарел. В C++ 11 вместо этого мы можем использовать функции deleted:

#include <iostream>

struct Thing {
    void Foo(int value) {
        std::cout << "Foo: value" << std::endl;
    }

    template <typename T>
    void Foo(T value) = delete;
};

int main() {
    Thing t;
    int int_value = 1;
    size_t size_t_value = 2;

    t.Foo(int_value);

    // t.Foo(size_t_value);  // fails with below error
    // error: use of deleted function
    //   ‘void Thing::Foo(T) [with T = long unsigned int]’

    return 0;
}

Это более точно передает намерение исходного кода и предоставляет пользователю более четкое сообщение об ошибке при попытке использовать функцию с запрещенными типами параметров.