Cannot Access Vector in C++ Dungeon Text Game - c++

Question

Intro:
So my final project for this semester is to create a dungeon game that the player inputs the choices he/she has to make on the terminal and the output is his/her current status (e.g. current health, shield, damage, current room, etc). The dungeon is made up of rooms (2-dimensional, so the player could go up, down, right, left depending on the map) and the rooms have objects in them, including Monsters, NPCs, Items. Player can choose to interact with the objects (fight monsters, buy from NPCs or pick up Items) or move to another room. The professor has given us the classes' header files, and we have to simply write the cpp files for it.
Classes, members, and methods (that has to do with the problem):
Room - it has private members Room* upRoom, downRoom, leftRoom, rightRoom int index vector<Object*> objects and it basically just a linked list but 2-dimensional. Every room has its own index and vector of object pointers (might point to Item, Monster or NPC). To access the index of the room, use getIndex() function that returns the index. To access the vector objects, use getObjects() function that returns the vector.
Object - the base and abstract class, it has a private member string name, and access name using getName function. There's also a virtual function that deals with different interactions with the Player based on different children classes of Object.
Item - derived from Object, its private members are int shield, health, attack that could increase the player's states when picked up.
Game Character - derived from Object, its private members are int currentHealth, maxHealth, attack, shield (basically the status of a character)
Monster - derived from Game Character.
NPC - derived from Game Character, it has private members string script vector<Item> items items are what the player could buy from the NPC.
Player - derived from Game Character, it has a private member Room* currentRoom a pointer that points to the player's current room. We can access currentRoom using getCurrentRoom() function.
Dungeon - the dungeon itself, it has private members Player player vector<Room> rooms that make up the whole game. It has functions like runDungeon createRoom() and createPlayer. The main.cpp only consists of runDungeon.
So back to the problem:
In the createRoom() function, I declared all the things I want in the map and pushed back to vector<Room> rooms, which is a private member of Dungeon. For example:
void Dungeon::createRoom(){
//create monster
Monster zombie("Zombie", 50, 50, 10); //the ints are just the states
//create commodities
Item beef("Beef", 69, 0, 30);
Item banana("Banana", 15, 0, 5);
Item deagle("Deagle", 0, 59, 0);
//create NPC
NPC vick("Vick", "Hello there! I'm Vick the monkey.", {banana, deagle});
//create rooms
Room zero(0, {&vick}); //contains index and vector<Object*> objects
Room one(1, {&beef, &zombie})
//linking rooms together
zero.setRightroom(&one);
one.setLeftroom(&zero);
//finally pushing back the rooms declared in this function to vector<Room> rooms
rooms.push_back(zero);
rooms.push_back(one);
}
There'a a function called displayRoom() which is to print out the room index and all the objects inside it.
void Dungeon::displayRoom(){
//print out current room index, this works fine
cout << player.getCurrentRoom()->getIndex << endl;
//print out current room's first object's name, this won't work
cout << player.getCurrentRoom()->getObjects().at(0) << endl;
//print out current room's vector<Object*> size, and it always print 0
cout << player.getCurrentRoom()->getObjects().size() << endl;
}
So my problem is that the vector full of object pointers disappears. Does declaring objects inside a function and pushing them back to a private member which other functions could access work? If not, is there a solution that might help? Sorry for my bad English, I hope you understand. :)

Answer 1

The variables you defined in createRoom have lifetimes which end when the function returns. So pointers to them (&vick, &beef, &zombie, &one, &zero) are dangling at that point, and any use of them is undefined behavior.
To create objects which live past the end of the function where they were created, they need to be put in some other object or container, or created with new or std::make_unique or std::make_shared. You'll also want to choose one object which acts as the "owner" of each object with longer lifetime, to make sure there's simple logic in charge of cleaning up the objects' lifetime ends. Probably the Dungeon is the owner of the Rooms, a Room is the owner of its objects, and an NPC is the owner of its stock for sale. (What about the player's inventory? Can a Monster have Items? Maybe GameCharacter should have some inventory ownership logic?)
The raw pointers you've mentioned suggest you're expected to use new and delete, even though that's harder and not a great design. If you must use raw pointers, then every class which acts as an owner of other objects via raw pointers must carefully follow the Rule Of Five. In this case, copying most objects doesn't make sense, so you could delete the copy constructor and copy assignment and have move-only classes.
But if you're allowed to, it would be much easier to express ownership of pointers using std::unique_ptr. For example, change the std::vector<Object*> objects; in Room to a std::vector<std::unique_ptr<Object>> objects;. Note this should only be the "owning" pointers. The "right room", etc. properties can stay as raw pointers, since it's really the Dungeon which owns all rooms. But you do want to make sure those raw pointers are pointing at the Room objects held by the Dungeon and not copies of them.

Answer 2

So I did a simplified version of my code using new and I think it worked correctly:
main.cpp
#include <iostream>
#include "object.h"
#include "room.h"
using namespace std;
class dungeon{
private:
vector<room> rooms;
public:
void createMap(){
room zero, one;
object* obj;
obj = new object("sword");
zero.addObjects(obj);
obj = new object("knife");
zero.addObjects(obj);
obj = new object("zombie");
one.addObjects(obj);
obj = new object("titan");
one.addObjects(obj);
rooms = {zero, one};
}
vector<room> getRooms(){
return rooms;
}
};
int main(){
dungeon Dungeon;
Dungeon.createMap();
cout << Dungeon.getRooms().at(0).getObjects().at(0)->getName() << endl;
}
room.h
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class room{
private:
int index;
vector<object*> objects;
public:
room(){}
room(int index, vector<object*> objects){
this->index = index;
this->objects = objects;
}
int getIndex(){
return index;
}
vector<object*> getObjects(){
return objects;
}
void setIndex(int index){
this->index = index;
}
void addObjects(object* obj){
objects.push_back(obj);
}
};
object.h
#include <iostream>
#include <string>
using namespace std;
class object{
private:
string name;
public:
object(string name){
this->name = name;
}
string getName(){
return name;
}
};