C++ 指向指向对象的指针的动态数组的指针

卡片类标题

class card {

public: 

string rtn_suit() { return suit; }
int rtn_rank()    { return rank; }
void set_suit(string new_suit){ suit = new_suit; }
void set_rank(int new_rank) { rank = new_rank; }

card();
card(string suit, int rank);
card(const card& copyCARD);
~card();

private:
string suit;
int rank;

};

#endif

card.cpp

#include "card.h"
card::card()
{
set_suit("default");
set_rank(0);
}
card::card(string new_suit, int new_rank)
{
// allows for using private class member variables
set_suit(new_suit); // can be anything (string)
set_rank(new_rank); // anticipating simple number ranking (int) 
}

card::~card() {}

甲板舱首

class deck {

public:

static const int default_cap = 52;

void addCard(card *new_card);

deck & operator=(const deck &sourceDECK);

void deckPrint();

// ----------------------------------------------------

deck(int init_cap = default_cap);
deck(const deck& sourceDECK);
~deck(){ delete [] decklist ; }


private:
card *decklist;
int used;
int capacity;

};

#endif

甲板级

 deck::deck(int init_cap)
 {
card **decklist = new card*[init_cap];

 for(int i=0;i<init_cap;i++)
  {
      decklist[i]=new card;
  }

capacity = init_cap;
used=0;
}

deck::deck(const deck& sourceDECK)
{
card **newDECK;

if (capacity != sourceDECK.capacity)
{

    newDECK = new card*[sourceDECK.capacity];

    for(int i=0;i<sourceDECK.capacity;i++)   {   newDECK[i]=new card();  }

    decklist = /*reinterpret_cast<card*>(*/newDECK/*)*/;

    capacity = sourceDECK.capacity;
}

used = sourceDECK.used;
copy(sourceDECK.decklist, sourceDECK.decklist+ used, decklist);

}
deck& deck::operator= (const deck& sourceDECK)
{
if (this == &sourceDECK)

    return *this;


card ** newDECK;
if (capacity != sourceDECK.capacity)
{
    newDECK = new card*[sourceDECK.capacity];

    for(int i=0;i<sourceDECK.capacity;i++)   {   newDECK[i]=new card();   }
    for (int i=0; i<capacity; i++)           {   delete     &decklist[i];     }
    delete [ ] decklist; 
    decklist = /*reinterpret_cast<card*>(*/newDECK/*)*/;
    capacity = sourceDECK.capacity;
}

// Copy the data from the source array:

used = sourceDECK.used;
copy(sourceDECK.decklist, sourceDECK.decklist + used, decklist);

return *this;
}


void deck::addCard(card* new_card)
{
//------- Not using vectors----
//deckList.push_back(new_card);
//cout << "Card added."<<endl;

decklist[used] = new_card;

//decklist[used].set_rank(new_card->rtn_rank());

//decklist[used].set_suit(new_card->rtn_suit());

++used;

cout << "Card added."<<endl;
  }

void deck::deckPrint()
 {
if ( capacity > 0 ) 
{
for(int i = 0; i < capacity; i++)
             {
               cout << "----------"<<endl;
               cout << decklist[i].rtn_rank() << " ";
               cout << decklist[i].rtn_suit() << endl;
               cout << "----------"<<endl;
             }
}
else\
{
    cout << "There are no cards in the deck."<<endl;
}
 }

它将在deckPrint（）中抛出错误

我最初写这篇文章是为了一个简单的卡片类实现，然后我们开始学习动态数组——我有了一个好主意，尝试在混合中抛出指针。再说一次，这不是家庭作业——这是为了个人成长

如果有一个教程我错过了，它清楚地概述了我正在尝试做什么，请随时告诉我，我也在这里倾注了前30名的谷歌结果和大量的帖子。有一半的时间人们推荐使用向量，这也不是我的目标

---

谢谢你的时间，我知道时间很长

我认为您的deck类构造函数中有一个小错误

deck::deck(int init_cap)
{
    card **decklist = new card*[init_cap];

    for(int i=0;i<init_cap;i++)
    {
        decklist[i]=new card;
    }
}

decklist这里是私有变量

并更改声明

private:
   card **cardlist;

---

请做一个最小尺寸的例子来问你的问题。人们不太可能花时间阅读所有这些代码来帮助你。检查你的

deck

copy构造函数/赋值操作符。它们分配指针数组，但不为这些指针分配实际对象。将其与

deck

constructor（两者兼有）进行比较。赋值运算符也可以删除指针数组，而不删除底层对象…@Carl-我去掉了所有的脂肪。@AzzA-我会修复它们的，谢谢-我还没有开始清理。我的问题是否在副本cstr/任务op中？我以为它们在别处…@mate0x很遗憾你删除了复制构造函数和赋值运算符-它们是错误的来源。如果我没记错的话，在分配了

card*

指针数组之后，您试图将对象

card

复制到其中。这就是为什么您得到的是

binary'='：没有找到接受类型为“card*”的右操作数的运算符。

。。。遵循

deck

构造函数的逻辑：使用

new

分配指针数组，然后为循环中的每个指针创建另一个

new

对象。按相反顺序删除-删除循环中的对象，然后删除指针数组。很漂亮，非常感谢！编译并运行！仍然有错误，但你让我越过了障碍。谢谢你的时间！

deck::deck(int init_cap)
{
    card **decklist = new card*[init_cap];

    for(int i=0;i<init_cap;i++)
    {
        decklist[i]=new card;
    }
}

deck::deck(int init_cap)
{
    decklist = new card*[init_cap];

private:
   card **cardlist;