Question

我知道我可以使用名为std::vector的东西，但我担心由于课程限制而无法实现。

我需要创建一个动态可扩展的对象数组。当需要存储新对象时，数组应该增长和增长。

这是该数组所属的类：

class TransactionList
{
    private:
        Transaction *trans;
        int amountTransactions;
        Transaction newTrans;

    public:
        TransactionList();
        ~TransactionList();
        void read( istream &is );
        void write( ostream &os );
        void add( Transaction & newTrans ); 
        double totalExpenses();
        double hasPaid( string namnet );
        double isDebted( string namnet );
        //PersonList FixPersons();
 };

方法“void add（Transaction＆amp; newTrans）”是我需要的方法。是的，我认真地必须做指针式。

到目前为止，这种方法完全不完整，甚至没有接近功能。我已经尝试了几种不同的方法，但最终会出现运行时错误或只是结果。

void TransactionList::add(Transaction & newTrans)
{
    Transaction* tempArrPtr;

    amountTransactions++;
    trans = new Transaction[amountTransactions]
    trans[amountTransactions - 1] = newTrans;
}

我想要的方法是构建一个Transaction-objects数组，并在获取更多对象时增大其大小。

我希望我已经清楚地写了我的问题并希望有人能给我一个好的答案。我试过谷歌搜索，但我仍然卡住了 - 否则我不会打扰他们：p

如果有人可以提供一些关于复制构造函数的指示，我会非常感激。在我们的课程材料中，他们几乎甚至没有展示复制构造函数应该是什么样子。就像“你需要复制构造进行深度复制，祝你好运！”

Answer 1

您应该添加maxTransactions变量，该变量将指示您的trans *数组的已分配长度，并将ammountTransactions和maxTransactions初始化为0。

当我们达到trans

的限制时，你的数组会自动加倍


void TransactionList::add(Transaction & newTrans)
{
    if(amountTransactions == maxTransactions){ //we've reached the capacity of trans
        //allocate a new array
        Transaction* nuTrans = new Transaction[maxTransactions*2+1];
        //copy the old values of trans into nuTrans
        memcpy(nuTrans, trans, sizeof(Transaction)*maxTransactions);
        //deallocate the old trans array
        delete []trans;
        //set trans to point at your newly allocated array
        trans = nuTrans;
        //update maxTransactions
        maxTransactions = maxTransactions*2+1;
    }

    trans[amountTransactions] = newTrans;
    amountTransactions++;
}

PS。我在这里直接写了它，我没有检查它是否作为一个整体编译或没有调试代码。但我把它作为你可以遵循的想法提出

编辑：工作示例@ http://ideone.com/uz1mE

Answer 2

当您添加一个对象并且该数组太小时，您需要创建一个具有正确或更大尺寸的新对象，复制数据，删除旧数据并将其替换为新数据。

复制构造函数与普通构造函数一样，只是它们采用相同类型的对象。这样做时要记得妥善处理你的指针。

 TransactionList(const TransactionList & o);

Answer 3

现在我终于设法解决了这个难题。事实证明，我没有足够重视我的Transaction-objects本身拥有一个动态数组的事实，所以我终于提出了使用assign函数来复制对象的想法。以为我会分享我的解决方案，以防任何人必须使用相同的有限工具解决同样的问题。

这就是它的结果：

   void TransactionList::add(Transaction & newTrans)

   {
    amountTransactions++;

    cout << "Adding a transaction-object to the array. amountTransactions = " << amountTransactions << endl;
    //Allocate a new array
    Transaction* tempTrans = new Transaction[amountTransactions];
    //Copy the objects with the assign-function
    for (int i = 0; i < amountTransactions - 1; i++)
            tempTrans[i].assign(trans[i]);

    //Delete the old one
    delete[] trans;

    //Set trans to point at the new one
    trans = tempTrans;

    //Add the newcomer object
    trans[amountTransactions - 1].assign(newTrans);
}

assign-function看起来如下：

void Transaction::assign(const Transaction & t)
{
    date = t.date;
    type = t.type;
    name = t.name;
    amount = t.amount;
    amountFriends = t.amountFriends;

    cout << "Hello assign " << amountFriends << endl;

    delete [] friends;
    if (amountFriends > 0)
    {
        friends = new string[amountFriends];

        for (int i = 0; i < amountFriends; i++)
            friends[i] = t.friends[i];
    }

    else
        friends = NULL;
}

我的最终解决方案是基于matyas的答案，所以我欠你一个好友！ :) 还要感谢Alexandre C.好好阅读！

我没有指望代码中可能存在某些错误的可能性，但至少它编译，运行并产生正确的结果。如果你发现一些不正确的东西，请随时指出。

动态对象数组

3 个答案: