Thread: Health...

I refer you to your reference material - you want to look at
constructors - they initialise the members of a class whenever
you create an instance of one.

There are two methods of initialising members - one is covered
here, and the other here. Ignore the stuff about inheritance
for the moment, just look at the syntax for the member initialisation
list in that second one.

Don't want to sound rude, but I'm not on call as a reference,
so only ask questions that you cant answer or about concepts
you cant grasp properly - I won't have the time to teach you
everything you'll need to do this task.

Actually all the data members are private in Richie's class declaration, which meand that the variables are only accessable by the class itself, and not any other functions, like main() or other classes. That's why Richie declared getter functions. This is good because it protects your data from unauthorized change.

These getter functions make it so that the data is made available to other parts of the program in a safe way. They look something like this:

Code:

// This function returns whatever Health is declared as. Say, an int.
int Fighter::GetHealth(void) const {
    return Health;
}

Somehow missed that last post!

Exactly as citizen said, the variables are private. The reason?
Data encapsulation is one of the principles of good object
oriented design, the idea that the object is a fully self sufficient
entity - the only way to manipulate it being through methods
coded by the programmer. Thats why OOP is so popular in
industry - a class should contain carefully designed methods
so that the code can be reused without need to tinker with the
class's inards. Thats the main difference between classes and
structs - in a struct, all variables are accessible (if an instance is
in scope). In a class, anything under private can only be seen
and changed by the class itself (or friend objects/functions, but
thats another matter). Public means that they are visible to
everyone, so thats why we normally put methods under public.
Protected then has to do with inheritance - where we want
the variables to be restricted like private, but classes
that inherit from this class will inherit variables under protected
as well.