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

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

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

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<>() специализируемый для bool, unsigned int, и int. main() функция показывает, как вызовы разрешены. Обратите внимание, что вызовы, которые используют константу int, которые не определяют суффикс типа, решат к foo<int>(), таким образом, Вы получите ошибку при вызове foo( 1), если Вы не специализируетесь на int. Если это верно, вызывающие стороны, использующие литеральную целочисленную константу, должны будут использовать эти "U" суффикс, чтобы заставить вызов решать (это могло бы быть поведением, которое Вы хотите).

Иначе необходимо будет специализироваться на [1 111] и использовать эти "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);
}

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

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

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

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

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

#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;
}

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