如何在对象中正确使用整数和浮点数？

Question

所以我正在尝试编写一个程序来跟踪具有以下属性的酒厂的各种属性。

-动态分配内存

-跟踪酿酒厂开始年份的整数

-成功评级和葡萄园占用的土地面积的浮动。

-添加、删除、显示（按评级和名称）和保存酒厂数据的功能。

我已经编写/调试过代码以使用一个类似的程序，其中所有属性都是 cstrings，并且此代码基于相同的框架。

我的问题是适用于动态分配的 cstrings 的相同代码不适用于整数或浮点数，并且我从编译器收到转换错误消息。我有一个包含aWinery 的list 类，因为我使用私有成员来隐藏数据，所以我有函数可以从客户端程序传递到list 和aWinery。相同类型的函数是相同的，所以我在这里只包括每种类型的一种。

有人能指出我做错了什么吗？如果aWinery 的int 和float 定义不是指针，我不知道如何通过参数返回。我可以在类中找到的唯一动态内存编程示例使用 cstrings。我在从讲师那里复制的代码中注意到了几点，因为我无法弄清楚。

编辑：我得到的具体错误是invalid conversion from int* to int\n year = this->year，在aWinery 的所有基于整数和浮点数的访问器和修改器函数中都发生了一些排列。

列出访问器、修改器、构造器和析构器函数

void list::getWineryLocation(char location[]) const
{
    wineryData.getLocation(location);
}

void list::getWineryYear(int year) const
{
    wineryData.getYear(year);
}

void list::getWineryAcres(float acres) const
{
    wineryData.getAcres(acres);
}

void list::setWineryLocation(char location[])
{
    wineryData.setLocation(location);
}

void list::setWineryYear(int year)
{
    wineryData.setYear(year);
}

void list::setWineryAcres(float acres)
{
    wineryData.setAcres(acres);
}

//Constructor functions

list::list()
{
    nameHead = NULL;
    nameTail = NULL;
    ratingHead = NULL;
    ratingTail = NULL;
    size = 0;
}

//Destructor
//Doesn't delete the head/tailRating pointers to avoid double deleting a winery
list::~list()
{
    node * curr = nameHead;

    while (nameHead != NULL)
    {
        curr = nameHead->nextByName;

        delete nameHead;

        nameHead = curr;
    }
}

aWinery Accessor、Mutator、Constructor 和 Destructor 函数

//Winery object constructor
aWinery::aWinery()
{
    name = new char[strlen("Unknown")+1];
    strcpy(name, "Unknown");
    location = new char[strlen("Unknown")+1];
    strcpy(location, "Unknown");
    year = new int;
    year = 0;
    acres = new float;
    acres = 0;
    successRating = new float;
    successRating = 0;
}

//I have no idea whats going on here
//Winery destructor
aWinery::~aWinery()
{   
    if(name != NULL)
        delete [] name;
    if(location != NULL)
        delete [] location;
    if(year != 0)
        delete year;
    if(acres != 0)
        delete acres;
    if(successRating != 0)
        delete successRating;
}

void aWinery::getLocation(char location[]) const
{
    strcpy(location, this->location);
}

void aWinery::getYear(int year) const
{
    year = this->year;
}

void aWinery::getAcres(float acres) const
{
    acres = this->acres;
}

//I have no idea why this is written this way, I copied this from an instructor example
void aWinery::setLocation(char location0[])
{
    if(this->location != NULL)
        delete [] this->location;
    this->location =  new char[strlen(location0)+1];

    strcpy(this->location, location0);
}

void aWinery::setYear(int year0)
{
    if(this->year != 0)
        delete this->year;
    this->year =  new int;

    this->year = year0;
}

void aWinery::setAcres(float acres0)
{
    if(this->acres != 0)
        delete this->acres;
    this->acres =  new float;

    this->acres = acres0;
}

aWinery 头文件

#ifndef AWINERY_H
#define AWINERY_H

#include <iostream>
using namespace std;

//winery object
class aWinery
{
public:
    //Constructor
    aWinery();

    //Destructor
    ~aWinery();

    //Accessor Prototypes
    void getName(char name[]) const;
    void getLocation(char location[]) const;
    void getYear(int year) const;
    void getAcres(float acres) const;
    void getSuccessRating(float successRating) const;

    //Mutator Prototypes
    void setName(char name0[]);
    void setLocation(char location0[]);
    void setYear(int year0);
    void setAcres(float acres0);
    void setSuccessRating(float successRating0);


private:
    char* name;
    char* location;
    int* year;
    float* acres;
    float* successRating;
};

#endif

列出头文件

#ifndef ALIST_H
#define ALIST_H

#include <iostream>
using namespace std;

const int MAX_CHAR_LENGTH = 1000;

class list
{
public:
    //Prototypes
    void setInWinery(char name[], char location[], int year, float acres, float successRating);
    void initializeDbase(char savePathName[]);
    void printEntireDbase();
    void deleteWinery(char nameOfWinery[]);
    void whereIsWinery(char nameOfWinery[]);
    void save(char savePathName[]);

    //Accessor Prototypes
    void getWineryName(char name[]) const;
    void getWineryLocation(char location[]) const;
    void getWineryYear(int year) const;
    void getWineryAcres(float acres) const;
    void getWinerySuccessRating(float successRating) const;
    int getSize() const;

    //Mutator Prototypes
    void setWineryName(char name[]);
    void setWineryLocation(char location[]);
    void setWineryYear(int year);
    void setWineryAcres(float acres);
    void setWinerySuccessRating(float successRating);

    //Constructor Prototype
    list();

    //Destructor
    ~list();

private:
    //Wine object
    struct node
    {
        aWinery wineryData;
        node * nextByName;
        node * nextByRating;
    };
    node * nameHead, * nameTail, * ratingHead, * ratingTail;

    aWinery wineryData;

    int size;
};

#endif

Answer 1

我认为你的大部分问题都在标题中，这里：

private:  
   char* name;
   char* location;
   int* year;
   float* acres;
   float* successRating;

确实没有理由对这些成员变量中的任何一个使用指针；您不妨将它们都设为普通的按值成员，如下所示：

private:  
   std::string name;
   std::string location;
   int year;
   float acres;
   float successRating;

请注意，我用 std::string 替换了 (char *) 成员变量，因为在 C++ 程序中确实没有理由不使用正确的字符串对象。 （如果你用 C 语言编写，使用动态分配的 char 数组来保存字符串可能是一个必要的坏事，但在 C++ 中它只是受虐狂）

通过按值存储所有数据，您可以摆脱所有 new 和 delete 命令（以及随之而来的不可避免的错误和低效率），只需在以下情况下直接设置和获取值必要的。

另外，这个访问函数是错误的：

void aWinery::getYear(int year) const
{
    year = this->year;
}

它不起作用，因为在 C++ 中，方法参数（默认情况下）是按值传递的（即制作传入值的临时本地副本，供方法使用），所以上述所有方法都可以就是修改局部参数year，然后函数一返回就立即销毁。正确的访问器方法看起来更像这样：

int aWinery::getYear() const
{
    return this->year;   // assuming year member variable is now of type int
}

.... 同样，setter 方法应如下所示：

void aWinery::setYear(int newYear)
{
    this->year = newYear;   // assuming year member variable is now of type int
}