Foo f = Foo (); // нет соответствующей функции для вызова 'Foo :: Foo (Foo)', а?

В конструкторе копирования есть две сомнительные вещи.

Во-первых, вы сделали конструктор копирования явным (что сомнительно), поэтому вам (теоретически) нужно сделать:

Foo d( (Foo()) );

Во-вторых, ваш конструктор копирования принимает ссылку, а не ссылку const, что означает, что вы не можете использовать его с временным Foo.

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

Обратите внимание, что explicit в вашем конструкторе по умолчанию не имеет никакого эффекта. [*] explicit влияет только на конструкторы, которые могут быть вызваны с одним параметром. Это предотвращает их использование для неявных преобразований. Для конструкторов, которые принимают только ноль или только два или более параметров, это не действует.

[Примечание: может быть разница между:

Foo d;

и

Foo d = Foo();

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

Изменить: [*] Я только что дважды проверил это, и в 12.3.1 [class.conv.ctor] сказано, что вы можете создать конструктор по умолчанию explicit. В этом случае конструктор будет использоваться для выполнения инициализации по умолчанию или инициализации значения. Честно говоря, я не понимаю значения этого, как если бы у вас есть объявленный пользователем конструктор, тогда это не-POD-тип, и даже локальные объекты не-POD-типа инициализируются по умолчанию, если у них нет инициализатора в этом разделе говорится, что это может быть сделано explicit конструктором по умолчанию. Возможно, кто-то может указать на крайний случай, когда это действительно имеет значение, но пока я не вижу, какое влияние explicit оказывает на конструктор по умолчанию.

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

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

Во-вторых, убедитесь, что конструктор копирования принимает ссылку 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
};

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

Foo foo = Foo()

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

Редактировать:

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

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

Затем он должен принять аргумент по ссылке 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();

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

Foo d = Foo();

должно быть

Foo d;

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

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

Сохраните свой класс таким же, но попробуйте это для создания экземпляра:

Foo d;

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

Foo d(arguments);

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

Foo(const Foo&) {}

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

Foo (Foo const &) {}

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

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