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

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

В 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]’

В коде pre-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, не будет скомпилирована, потому что член является закрытым, конечно, с учетом стандартных исключений из правил видимости (друг, внутренние вызовы и т. д.). Если что-то, у кого есть доступ, вызывает закрытый метод, вы получите ошибку компоновщика.

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

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

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' будет ясно, какой аргумент есть какой.

Что-то, что может сработать для вас, — это использовать шаблоны. Ниже показано, как шаблонная функция 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);
}

Принятый в настоящее время ответ (с использованием частной шаблонной функции) хорош, но устарел. В 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;
}

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

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

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

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

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