Question

我希望bag类有一个动态分配的项目对象数组，但不知道如何执行此操作。还需要有人看看我的其余代码。我想将Item对象添加到Bag对象并对如此形成的ADT执行操作，这从代码中可以看出。

Item.h

#ifndef ITEM_H
#define ITEM_H


class Item
{
char* item_name;
public:
    Item(char *name);
    void display_item(Item i);
    ~Item();

protected:

private:
};

#endif

Item.cpp

#include "Item.h"
#include<string.h>
#include<iostream>
#include<malloc.h>
using namespace std;

 Item::Item(char* name)
 {
     item_name = new char[sizeof(name)];
     strcpy(item_name,name);
 }
 void Item::display_item(Item i)
{
    cout<<i.item_name<<" ";
}

 Item::~Item()
 {

 }

Bag.h

#include "Item.h"
#ifndef BAG_H
#define BAG_H


 class Bag
{
     int no_of_items;
     int capacity;
     Item list[];
      public:
          Bag(int no_of_items);
         void add(Item i);
         void display();
          ~Bag();

        protected:

        private:
  };

  #endif

Bag.cpp

#include "Bag.h"
#include "Item.h"
#include<malloc.h>
Bag::Bag(int capacity)
{
     Item list[capacity];
    no_of_items =0;
}
 void Bag::add(Item i)
{
    if(no_of_items<capacity)
    {
        list[no_of_items] = i;
        no_of_items++;
    }
   else
   {
          cout<<"bag is full";
    }


}
 void Bag:: display()
{
     for(i=0;i<no_of_items;i++)
    {
       display_item(list[i]);
    }

 }

 Bag::~Bag()
{
   //dtor
 }

Answer 1

我不会谈论您的代码，如果您遇到问题，请使用最少的代码在单独的问题中提出，以重现错误。这是一个链接，在本答案的最后，解释了如何为您的阵列动态分配内存。如果你这样做是因为你需要一个可变大小的数组，我会推荐一个向量。虽然类型数组的对象必须具有在编译时定义的大小，但向量不具有此要求，并且您可以使用vector_pushback轻松添加新元素。但如果您坚持使用数组，请按照此处的说明操作：http://www.cplusplus.com/forum/articles/416/

Answer 2

尽可能使用STL容器。它们具有类似的界面并且有很好的文档记录。他们中的大多数是动态的。因此，使用STL容器（std::string和std::vector）的代码可能如下所示：

#include <string>
#include <vector>
#include <iostream>

class Item {
public:
    Item(const std::string& name) : item_name(name) {}
    virtual ~Item() {}

    void display_item() {
        std::cout << item_name << " ";
    }
private:
    std::string item_name;
};

class Bag {
public:
    void add(const Item& i) {
        items.push_back(i);
    }

    void display() {
        for(std::vector<Item>::iterator it = items.begin();
                it != items.end(); ++it)
            it->display_item();
    }
private:
    std::vector<Item> items;
};

由于您的问题是针对如何使用动态分配实现示例，因此上面没有STL容器的代码可以完成：

#include <cstring>
#include <algorithm>
#include <iostream>

class Item {
public:
    Item() : item_name(0) {} // required for new[] expression
    Item(const char* name) : item_name(0) {
        copyName(name);
    }
    virtual ~Item() {
        delete[] item_name; // don't forget to free the allocated memory
    }

    void display_item() const {
        std::cout << item_name << " ";
    }

    Item& operator=(const Item& other) { // required for copying
        copyName(other.item_name);
        return *this;
    }

private:
    void copyName(const char* str) {
        // get the size of the new name and delete the actual name
        const size_t name_size = strlen(str);
        delete[] item_name;
        // allocate memory for new name and copy it
        item_name = new char[name_size + 1]; // extra place for '\0'
        strcpy(item_name, str);
    }

    char* item_name;
};

class Bag {
public:
    Bag(size_t cap = 0) :
            items(cap ? new Item[cap] : 0), capacity(cap), size(0) {}
    virtual ~Bag() {
        delete[] items;
    }

    void add(const Item& i) {
        // "resize" the actual array if there is no space for a new item
        if(size == capacity) {
            // allocate new array and copy the actual content
            capacity += 100;
            Item* temp = new Item[capacity];
            std::copy(items, items + size, temp);
            // delete the actual array and assign the newly allocated one
            delete[] items;
            items = temp;
            temp = 0;
        }
        // add the new item
        items[size] = i;
        size++;
    }

    void display() {
        for(size_t i = 0; i < size; ++i)
            items[i].display_item();
    }

private:
    Item* items;
    size_t capacity;
    size_t size;
};

处理另一个类中动态分配的类对象数组

2 个答案: