Question

我正在编写一个C ++程序，该程序读入乘客列表并创建存储在动态分配指针中的Passenger对象。但是，我注意到，当我运行该程序时，添加一名新乘客将导致所有先前设置的乘客也被分配给新乘客。

以下代码中可能存在问题的部分：

int x = 400;
passengerslot = 0;
Passenger * list = new Passenger[x];
ifstream myfile("Airline.CSV");
if (myfile.is_open())
{
    while (getline(myfile, line))
    {
        std::istringstream ss(line);
        std::string token;
        int dataslot = 0;
        while (std::getline(ss, token, ',')) {
            switch (dataslot){
            case 0:
                *last = token;
                break;
            case 1:
                *first = token;
                break;
            case 2:
                *rownum = atoi(token.c_str());
                break;
            case 3:
                *seat = token.at(0);
                break;
            case 4:
                *flightnum = atoi(token.c_str());
                list[passengerslot] = *new Passenger(last, first, rownum, flightnum, seat);
                cout << list[passengerslot].getPassenger() << endl; //prints as the passengers are assigned
                if (passengerslot != 0){
                    cout << list[passengerslot - 1].getPassenger() << endl;
                }

我的乘客构造函数：

Passenger::Passenger(string *fname, string *lname, int *rownum, int *flightnum, char *seatchar):firstname(fname), lastname(lname), rownumber(rownum), flightnumber(flightnum), seat(seatchar){
*firstname = *fname;
*lastname = *lname;
*rownumber = *rownum;
*flightnumber = *flightnum;
*seat = *seatchar;
}

Answer 1

几乎所有事情的异常解除引用让我担心你可能会反复重复使用相同的指针，每次都在相同的内存位置写入，然后将这些内存位置分配给Passenger内的指针。

例如，构造函数：

Passenger::Passenger(string *fname, string *lname, int *rownum, int *flightnum, char *seatchar):firstname(fname), lastname(lname), rownumber(rownum), flightnumber(flightnum), seat(seatchar)
{
    *firstname = *fname;
    *lastname = *lname;
    *rownumber = *rownum;
    *flightnumber = *flightnum;
    *seat = *seatchar;
}

firstname(fname)表示必须是指向字符串的指针，如果此程序编译，firstname将被分配fname指向的地址。其他成员和相关参数也遵循相同的模式。

*firstname = *fname;实际上没有任何效果。它将字符串复制到字符串顶部的fname处，因为前一点的赋值完全相同。

这意味着所有Passenger::firstname s指向fname，所有Passenger::lastname指向lname等...最终结果是所有乘客看起来与最近的乘客完全一样。

解决方案：停止使用指针。你可能不需要任何指针。

累积变量应为：

std::string first;
std::string last; 
int rownum;
int flightnum;
char seat;

乘客应该是：

class Passenger
{
public:
    Passenger(const std::string & fname, 
              const std::string & lname, 
              int rownum, 
              int flightnum,
              char seatchar);
    // other unspecified public methods
private:
    std::string firstname; 
    std::string lastname;
    int rownumber;
    int flightnumber;
    char seat;
    // other unspecified private data and methods
}

和构造函数

Passenger::Passenger(const std::string & fname, 
                     const std::string & lname, 
                     int rownum, 
                     int flightnum,
                     char seatchar):
    firstname(fname), lastname(lname), rownumber(rownum), 
    flightnumber(flightnum), seat(seatchar)
{
}

的存储定义

Passenger * list = new Passenger[x];

应该更符合

std::vector<Passenger> list;

std::vector是一个动态调整大小的数组，内置大多数用例所需的所有内存管理。

而不是用

加载列表

list[passengerslot] = *new Passenger(last, first, rownum, flightnum, seat);

使用

list.emplace_back(first, last, rownum, flightnum, seat);

动态内存分配 - 所有对象都相同

1 个答案: