I'm a newbie or I would try to help you.

However, I've found using pastebin.com will make it easier for others to answer your question. Also, paste code here using the code tag. That might get you some answers!


EDIT: I'm playing your game now, by the way!

Can someone please give me some tips on how to clean this up and make it more object-oriented?

Initially I tried to create an enter function within the store(i.e. store.enter(mainPlayer)) and pass a pointer to player into the function but that didn't work out as I am still struggling to grasp the concept of pointers.

Also random encounter during rest is pretty messy. I would have liked to create the the random encounter within the rest function but failed as I'm sure using pointers is the solution.

I'm not asking for someone to just hand me over a solution I would just like some tips on improvement and hopefully help grasping pointers and their mechanics. Thank you in advance.

As a general rule of thumb, if you are passing a naked non-const pointer, that should be a "code smell" of sorts. That said, you can learn that lesson much later.


Pointers are actually relatively straight forward, at least compared to other aspects of C++!

Think of pointers if you will like GPS coordinates. They simply refer to a location in memory, however, like with GPS coordinates, when you resolve them, they are actually a physical location. For example, [color="#3366BB"][font="sans-serif"]

42.9837°N 81.2497°W

[/font] are the GPS coordinates of my hometown, but once you resolved them you have the city of London, Ontario.

With code pointers it much the same thing:

int i = 42;
int * intPointer = &i;

Just like the GPS example, intPointer represents the location of the integer i. However, just like with coordinates, once you actually resolve them, or dereference in C++ parlance, you get the actual object itself, so:

cout << *intPointer;

Would print out 42, because that is the value at the location pointed to by i. At this point I suppose it makes sense to point out that '*' when applied to a pointer is what causes it to de-reference ( look at the value pointed at, not the location ), while the earlier used '&' when applied to a type says "give me the address/location of this thingy". The pointer is declared as the type it is pointed to; so a pointer point at an int is declared as "int *" while a pointer pointing at a class Widget is declared as "Widget *".



That's the gist of pointers, now the why. One very good reason is scope/lifetime.

Consider this function:

Player CreatePlayer()
{
Player p;
p.Name = "Bob";
// ... all kinds of other stuff
return p;
}


This code works perfectly fine, however when it returns, it actually creates a completely new copy of Player, so if the Player class is really large, this is going to be quite slow and wasteful. So, instead off going through the motions twice, you could:

Player* CreatePlayer()
{
Player * p = new Player();
p->Name = "Bob";
return p;
}

What happens here is CreatePlayer creates a new Player as a pointer instead of as a local variable. Since it is simply a pointer to a location in memory, you have to say "OK, now fill it with type Player, which is essentially what new does ( it actually does so by calling Player's constructor, but thats another story ). Now, since you are dealing with a player instead of a standard variable, you have to use -> instead of "." when accessing members. Now what made this call so much different than the earlier call? This is where scope comes into the equation.


Consider this:

{
int i = 42;
{
int j = 43;
}
int k = i + j;
}

Once wrong with this equation? Well, you can't access j because it went out of scope. That is exactly what the { } characters delineate. The lifetime of a variable is only as long as it is in scope. So once j hits the next } POOF, it ceased to exist.

So, what do you do when you want a variable to last longer than it's scope? This is where pointers can come in.

Consider this function again:


Player* CreatePlayer()
{
Player * p = new Player();
p->Name = "Bob";
return p;
}

At the end of this method, instead of a copy being returned, it's still the original p variable that exists, and the address of it is returned to the caller. This presents one of the biggest downsides to pointers too... leaks.

{
Player * ourPlayer = CreatePlayer();
// do stuff
}

That code just leaked a Player object, since variables created via pointers do not get destroyed when they go out of scope. Therefore you have to delete it yourself, such as:

{
Player * ourPlayer = CreatePlayer();
delete ourPlayer;
}


This has another downside, in that you need to be careful that a deleted pointer is never accessed again, consider:

{
Player * ourPlayer = CreatePlayer();
delete ourPlayer;
// stuff
cout << ourPlayer->Name;
}



KABOOOM!


Want to know the worst part... that's not even guaranteed to go KABOOM!, because even though you deleted the pointer, keeping in mind pointers are just a reference to a location in memory, even though you deleted the pointer, it doesn't mean that C++ has deleted what the pointer pointed to! That means that code may actually work, at least until something overwrites that location of memory. These create some seriously nasty and hard to find bugs! This is also why you will often see:

{
delete ourPlayer;
ourPlayer = NULL;
}

Because the guarantees that pointer will blow up if accessed again. Trust me, you would rather get a null pointer exception than have code that sorta works through that bug, so get in the habit of null'ing out your pointers.



Another big value of pointers is passing them around, lets say you had somethings like this:


{
Gameworld world;
ChangeWorld(world);
}

Gameworld ChangeWorld(Gameworld gameWorld)
{
gameWorld.time = "4:00pm";
// do other stuff to game world
return gameWorld;
}

Looks good and works, right? Well sorta. Here is the problem, you actually created 3! Gameworld objects in this process! The first one when you declared it, then when you passed it into ChangeWorld, since it was passed by value it actually created another local copy, then when you returned it, it created yet another copy to overwrite the original world object! This may be ok with small types like int, but with large classes or in a tight loop this is going to bring your program to a screeching halt.

Now, you can do the exact same thing with pointers:


{
Gameworld * world = new Gameworld();
ChangeWorld(world);
}

void ChangeWorld(Gameworld *gameWorld)
{
gameWorld->time = "4:00pm";
// do other stuff to game world
}

In this case, only one instance is ever created and even more importantly, you don't have to return the updated Gameworld object, as you actually made changes directly to the original.

That said C++ ( and not C ) provides a special quasi pointer called a reference.

When a reference is declared in a function, it changes things a bit. Generally when you are calling a function you are passing "by value", where as when you use a reference you are passing, predictably enough, by reference. You can think of this as the same as passing in a pointer, except the compiler does the work for you behind the scenes. So considering the earlier example, passed by reference it would be:


{
Gameworld world;
ChangeWorld(world);
}

void ChangeWorld(Gameworld &gameWorld)
{
gameWorld.time = "4:00pm";
// do other stuff to game world
}


So, it looks just like the first version, where it create a local copy, however because of that magical ampersand you are telling the compiler to pass in a reference to the object instead of a copy of the object, so in the function when you make changes, you are in fact making changes to the original.


Clear as mud?