Question

我试图在我的成员函数中创建一个动态数组，但是，每次调用该函数时，它似乎都会创建一个新的动态数组。无论如何在成员函数中创建一个动态数组，因此它不会重制自己。

class predator
{
private: 
    string name; 
    string species;
protected:
    string *list;

public: 
    predator(string theSpecies);
    void killsRecorded(string kills); // add a new kill to the end of the predator's list of kills
    string *killsList();  // return a pointer to the array of all kills by this predator 
    int noOfTotalKills();  // how many kills have been recorded

    int k; 
    static int n;
};

//The header file
void predator::killsRecorded(string kills)
{
    k = 0; 
    list = new string[5];
    *(list + k) = kills;
    k = n++;
    cout<< k<< endl;
}

string* predator::killsList()
{
    //cout<< (sizeof(list)/sizeof(list[0]))<< endl;
    for(int i=0; i<5; i++)
    {
        cout<< *(list + i)<< endl;
    }
}

上面是我的类和头文件，void killsRecorded（string kills）应该为我的数组添加kill，但是，当我在我的主程序中尝试时。

predator *prey;
prey = new predator("Cheetah");

prey->killsRecorded("Mouse");
prey->KillsRecorded("Donkey");

prey->killsList();

打印出来

Created a hunter that is a Cheetah
0
1
Donkey
*BLANK LINE
*BLANK LINE
*BLANK LINE
*BLANK LINE

相反，Mouse应位于第一行，而Donkey位于第二行。难道我做错了什么？另外，我不能使用向量，而是用于作业。

Answer 1

在构造函数中，为n指定一个默认值，例如5.然后创建一个该大小的数组。

header('Location: http://x.in/home/index.php');

然后recordKills检查杀戮是否有空间，必要时重新分配：

predator::predator()
    : n(5),
      k(0)
{
    kills = new string[n];

}

通过数据结构的名称调用变量通常是一个坏主意，所以我重命名了＃list;＃39; list＆＃39;杀死＆＃39;。

然后在打印杀戮时，循环直到k：

recordKills(string kill)
{
    if(k >= n) {
        string* oldKills = kills;
        kills = new string[2*n];

        // copy
        for(int i = 0; i< n: i++) {
            kills[i] = oldKills[i];
        }

        n *= 2;

        delete [] oldKills;
    }

    kills[k++] = kill;
}

请记住在析构函数中删除杀戮！

Answer 2

你应该使用std :: vector ... 要做到这一点，你必须

#include <vector>

使用命令

std::vector<string> kills;

你可以创建一个新的字符串向量

使用命令

kills.pushback(stringvalue);

你可以在你的矢量“列表”中添加一个新的字符串，你也不必计算你的杀戮......你可以使用

kills.size();

获取字符串数量。要获取值（字符串），可以使用像数组一样的向量

string name = kills[3];

btw：你应该将矢量保存为成员......要做到这一点你必须将它保存在你的类定义中（标题）

如果您不允许使用std :: vector，您可以编写自己的列表...

class list
{
private:
    node* head;        
    int size = 0;

    struct node
    {
        node* next;
        string value;
    }

public:
    list();
    ~list();
    void PushBack(string);
    string GetElement(int index);
    int GetSize();  
};


list::list()
{
    head = new list();
    head->next = nullptr;
}

list::~list()
{
    node* temp = head;
    node* temp2 = temp;
    do //delete hole list
    {
       temp2 = temp->next;
       delete temp;
       temp = temp2;
    }while(temp != nullptr);  
}   

void list::PushBack(string item)
{
    node* temp = head;
    while(temp->next != nullptr)
    {
        temp = temp->next;
    }
    //found the end of the list
    node* newNode = new node();
    newNode->value = item;
    newNode->next = nullptr;
    temp->next = newNode;
    size++;
}   

int list::GetSize()
{
    return size;
}

string list::GetElement(int index)
{
    node* temp = head;
    while(temp->next != nullptr)
    {
        temp = temp->next;
        if(index == 0)
        {
            return temp->value;
        }
        index--;
    }
    //index out of bounds
    return "";
}

我现在无法检查代码是否正确，因为在这台计算机上没有IDE ...但我认为它应该用词;）

BTW：您可以使用此列表而不是数组来执行您必须编写的内容：

list kills;

kills.PushBack("Peter");
kills.PushBack("Thomas");
kills.PushBack("Alex");

for(int i = 0; i< kills.GetSize();i++)
{
    std::cout<<kills.GetElement(i)<<std::endl;
}

Answer 3

嗯，您的killsRecorded(string kills)方法是编写不的示例...

你删除所有以前记录的杀人名单
你丢失了前一个new[]获得的指针导致内存泄漏（如果你的程序忘记了已分配的内容，你怎么能解放它们）

应该做什么（引擎盖下的矢量类）：

定义您最初分配的 chunk
将录制的字符串添加到此简单数组中，直至其已满
当它是完整的时，分配另一个大小两倍的数组，小心地复制旧数组中的值，释放旧数组，只有它们影响新数组才能保存指针
不要忘记在类析构函数
并在类中存储当前大小（被杀数量）和最大大小（已分配大小）

代码可以是：

class predator
{
private: 
    string name; 
    string species;
protected:
    string *list;
    size_t max_size;
    size_t cur_size;

public: 
    predator(string theSpecies);
    void killsRecorded(string kills); // add a new kill to the end of the predator's list of kills
    string *killsList();  // return a pointer to the array of all kills by this predator 
    int noOfTotalKills();  // how many kills have been recorded

    /*int k; what it that???
    static int n;*/
};

//实施文件

predator(string theSpecies): species(species) {
    list = new string[5];
    max_size = 5;
    cur_size = 0;
    // what do you do with name ?
}

void predator::killsRecorded(string kills)
{
    if (cur_size >= max_size) {  /* need a bigger array */
        max_size *= 2;
        temp = new string[max_size];
        for(int i=0; i<cursize; i++) { // copy previous recorded values
            temp[i] = list[i];
        }
        delete[] list;   // free previous allocated array
        list = temp;     // ok list is now big enough
    }
    list[cur_size++] = kills;
}

在类成员函数中创建动态数组

3 个答案: