“无法引用默认构造函数”错误消息 - 在我的情况下是否必须使用默认构造函数？ （学习面向对象）

Question

#include <iostream>
#include <array>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <random>
#include <iterator>
#include <string>

class Deck;

class Card
{
public:
    enum cRanks
    {
        RANK_2,
        RANK_3,
        RANK_4,
        RANK_5,
        RANK_6,
        RANK_7,
        RANK_8,
        RANK_9,
        RANK_10,
        RANK_J,
        RANK_Q,
        RANK_K,
        RANK_A,

        MAX_RANKS,
        RANK_AIR
    };

    enum cSuits
    {
        SUIT_CLUBS,
        SUIT_DIAMONDS,
        SUIT_HEARTS,
        SUIT_SPADES,

        MAX_SUITS,
        SUIT_AIR
    };

private:
    cRanks m_rank{RANK_A};
    cSuits m_suit{SUIT_SPADES};

public:
    //Card() = default;

    Card(cRanks r, cSuits s)
        :m_rank{ r }, m_suit{ s }
    {
    }

    void print() const
    {
        char rank{};
        char suit{};
        switch (m_rank)
        {
            case(RANK_2): rank = '2'; break;
            case(RANK_3): rank = '3'; break;
            case(RANK_4): rank = '4'; break;
            case(RANK_5): rank = '5'; break;
            case(RANK_6): rank = '6'; break;
            case(RANK_7): rank = '7'; break;
            case(RANK_8): rank = '8'; break;
            case(RANK_9): rank = '9'; break;
            case(RANK_10): rank = 't'; break;
            case(RANK_J): rank = 'J'; break;
            case(RANK_Q): rank = 'Q'; break;
            case(RANK_K): rank = 'K'; break;
            case(RANK_A): rank = 'A'; break;
            case(RANK_AIR): rank = '_'; break;
            default: rank = '?';
        }
        switch (m_suit)
        {
            case(SUIT_CLUBS): suit = 'C'; break;
            case(SUIT_DIAMONDS): suit = 'D'; break;
            case(SUIT_HEARTS): suit = 'H'; break;
            case(SUIT_SPADES): suit = 'S'; break;
            case(SUIT_AIR): suit = '_'; break;
            default: suit = '?';
        }
        std::cout << rank << suit << ' ';
    }

    friend Deck; 
};

class Deck
{
public:
    using array_type = std::array<Card, 52>;
    using index_type = int;
private:
    array_type m_deck;
    index_type m_index{ 0 };

public:
    Deck()
    {
        m_index = 0;
        int index{0};
        for (int s{ 0 }; s < Card::MAX_SUITS; ++s)
        {
            for (int r{ 0 }; r < Card::MAX_RANKS; ++r)
            {
                m_deck[index].m_rank = static_cast<Card::cRanks>(r);
                m_deck[index].m_suit = static_cast<Card::cSuits>(s);
                index++;
            }
        }
    }

    void print()
    {
        if (m_index > static_cast<int>(m_deck.size()) - 1)
        {
            std::cout << "\nDeck out of cards!";
            return;
        }
        std::cout << '\n';
        for (int i{ m_index }; i < m_deck.size(); ++i)
            m_deck[i].print();
    }

    void shuffle(unsigned int seed = 777)
    {
        std::mt19937 g{ seed };
        std::shuffle(m_deck.begin(), m_deck.end(), g);
    }

    const Card& draw()
    {
        if (m_index > static_cast<int>(m_deck.size()) - 1)
        {
            std::cout << "\nDeck out of cards!";
            return Card(Card::RANK_AIR, Card::SUIT_AIR);
        }
        return m_deck[m_index++];
    }
};

int main()
{
    Deck deck{};
    deck.print();
    deck.shuffle();
    deck.print();



    return 0;
}

简单的二十一点游戏练习来学习 OOP。在上面的代码中，我在 Deck 构造函数上收到错误消息“无法引用的默认构造函数——它是一个已删除的函数”。假设我的 m_deck 数组无法实例化，以便 Deck 的构造函数可以为其赋值，因为 Card 类没有默认构造函数，是否明智？如果我希望我的默认 Card 构造函数有参数怎么办？我可以避免使用“Cards() = default;”吗？在我的卡片课上？我在想只有在你定义了它的性质（等级和花色）的情况下实例化一个 Card 对象才是明智的。

Answer 1

1. 在没有复制构造函数的情况下，没有从返回类型 const Card& 构造 Card() 对象的方法； constexpr Card::Card(const Card&)
2. 编译器想使用你提供的默认构造函数 或由它生成以匹配 std::array 中的返回类型 Card。因此， /usr/include/c++/7/array:94:12: error: no matching function for call to ‘Card::Card()
3. 我试图用最少的东西复制您的代码 外加的 Card() = default; Card(const Card& other) = default; 它似乎至少正在编译。我无法检查功能方面 你。

#include <iostream>
#include <array>

class Deck;

class Card
{
public:
    enum cRanks
    {
        RANK_A,
        MAX_RANKS,
        RANK_AIR
    };

    enum cSuits
    {
        SUIT_SPADES,
        MAX_SUITS,
        SUIT_AIR
    };
private:
    cRanks m_rank{RANK_A};
    cSuits m_suit{SUIT_SPADES};

public:
    Card() = default;

    Card(const Card& other) = default;

    Card(cRanks r, cSuits s)
        :m_rank{ r }, m_suit{ s }
    {
    }

    void print() const
    {
        char rank{};
        char suit{};
        switch (m_rank)
        {
            case(RANK_A): rank = '_'; break;
            default: rank = '?';
        }
        switch (m_suit)
        {
            case(SUIT_SPADES): suit = 'C'; break;
            default: suit = '?';
        }
        std::cout << rank << suit << ' ';
    }

    friend Deck; 
};

class Deck
{
public:
    using array_type = std::array<Card, 52>;
    using index_type = int;
private:
    array_type m_deck;
    index_type m_index{ 0 };

public:
    Deck()
    {
    }

    void print()
    {
    }

    void shuffle(unsigned int seed = 777)
    {
    }

    const Card& draw()
    {
    }
};

int main()
{
    Deck deck{};
    deck.print();
    deck.shuffle();
    deck.print();



    return 0;
}