Foo f = Foo ();//никакое соответствие функционируют для вызова 'Foo:: Foo (Нечто)' … ха?

Вы не хотите отмечать ни один из этих конструкторов как явный - компилятор должен использовать их оба, особенно конструктор копирования, неявно. Чего вы пытаетесь достичь, помечая их явным образом?

Компилятор сообщает вам ... Используйте это:

Foo(const Foo&) {}

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

Во-вторых, убедитесь, что конструктор копирования принимает ссылку const .

В-третьих, Foo f; - это правильный способ создать объект класса foo, созданный по умолчанию. Обратите внимание, что Foo f (); неверно, потому что компилятор интерпретирует это как объявление функции f () , которая возвращает объект класса Foo .

В-четвертых, если вы написали свой собственный конструктор копирования, вам также следует написать оператор присваивания.

class Foo
{
  Foo() {} // no need to make explicit.  Nothing to convert from.

  Foo(const &Foo f) {} // again, nothing wrong with conversion from Foo to Foo

  explicit Foo(int a) {}  // need explicit to prevent accidental passing of an int
                          // to a function that takes Foo as an argument
};

Конструктор копирования не должен быть явным (что делает его uncallable здесь и во многих других вполне разумных контекстах, например, при передаче или возврате по значению).

Затем он должен принять аргумент по ссылке const , поскольку в противном случае он не может привязаться к временным файлам.

Foo f = Foo();
        ^^^^^
          |
          --- this is a temporary that cannot be passed to a function
              that accepts a non-const reference

Кроме того, нет причин делать конструктор по умолчанию явным : это ключевое слово имеет смысл только для конструкторов (кроме конструктора копирования), которые могут быть вызваны ровно с одним аргументом, и в этом случае оно предотвращает неявные преобразования других типов в Foo через этот конструктор. Например, если конструктор, принимающий int , был явным , такие ситуации не будут компилироваться:

Foo f;
f = 1;  //assuming no operator= overload for (types convertible from) int
        //this implicitly performs f = Foo(1);

Foo g = 10;

void x(Foo);
x(20);

В целом:

class Foo
{
public:
    Foo();
    Foo(const Foo&);
    //...
};

Foo x = Foo();

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

class Foo
{
public:
    explicit Foo() {}
    explicit Foo(const Foo&) {}
};

Foo d = Foo()

Foo d = Foo();

должно быть

Foo d;

Первая строка создает экземпляр Foo, а затем копирует его в d;

Попробуйте без явного? Я думаю, что:

Foo foo = Foo()

создает неявную копию, поэтому явный конструктор копирования не срабатывает.

Edit:

Это только половина ответа. Смотрите пост Чарльза Бейли или UncleBens о том, зачем нужна const.

Ваша проблема в инстанцировании. Вам не нужно Foo d = Foo(); для конструктора по умолчанию.

Оставьте свой класс прежним, но попробуйте сделать вот так:

Foo d;

На самом деле, вам даже не нужно Foo d = Foo(arguments); для конструирования с параметрами. Это должно выглядеть так:

Foo d(arguments);

Вы можете решить эту проблему одним из двух способов. Первый (уже предложенный Randolpho) - отказаться от использования copy ctor. Другой - написать правильный copy ctor:

Foo (Foo const &) {}

Обычно вы хотите сделать и то, и другое.

Редактирование: Если посмотреть на это, то мой последний комментарий легко неправильно истолковать. Довольно многим классам не нужен copy ctor вообще, но если вам нужен copy ctor, он обычно должен иметь вид, приведенный выше (не явный, и принимающий const ссылку в качестве параметра).