Dynamic Memory Allocation - All objects are the same - c++

Question

I'm writing a C++ program that reads in a list of passengers and creates Passenger objects that are stored in a dynamically allocated pointer. However, I noticed that when I ran the program, adding a new passenger would cause all of the previously set passengers to be assigned to the new passenger too.
The likely problematic segment of the code below:
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;
}
My passenger constructor:
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

The unusual dereferencing of pretty much everything has me worried that you may be reusing the same pointers over and over, writing over the same memory locations every time, then assigning those memory locations to pointers inside the Passenger.
For example, the constructor:
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) means that what has to be a pointer to string, if this program compiles, firstname is being assigned the address pointed to by fname. The same pattern follows for the other members and associated parameter.
*firstname = *fname; does effectively nothing. It copies the string at fname over top of the string at firstname, which because of the assignment in the previous point are the exact same place.
This means that all of the Passenger::firstnames point to fname, all Passenger::lastnames point to the lname, etc... The end result is that all Passengers look exactly the same as the most recent Passenger.
Solution:
Stop using pointers for everything. You probably don't need any pointers.
The accumulation variables should be:
std::string first;
std::string last;
int rownum;
int flightnum;
char seat;
Passenger should be:
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
}
and the constructor
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)
{
}
Storage definition of
Passenger * list = new Passenger[x];
should be more along the lines of
std::vector<Passenger> list;
std::vector is a dynamically sizing array with all of the memory management required for most use cases built right in.
And rather than loading list with
list[passengerslot] = *new Passenger(last, first, rownum, flightnum, seat);
use
list.emplace_back(first, last, rownum, flightnum, seat);