#ifndef ___EXAMPLE___
#define ___EXAMPLE___
// The above is actually considered a macro, which means that it is something that
// is done to the code prior to compilation.  The ifndef means if not defined and
// define means to define now.  What it does is prevent your example.h file from been
// copied multiple times by the compiler.  Every time you do a #include the compiler basically
// copies and pastes all the content of the file in #include onto the top of the file that
// does the #include... so this is a way to keep it from doing that many times.  The corresponding
// endif is to finish the if statement in macro, don't use the macros too much, it tends to
// cause the code to be a reading nightmare.  But in this case use it a lot... don't do stuff
// like #if 0 to comment, my friend did that at work and we hate him for it.
#include <string>
using namespace std; //you still need this

// NOTE: all implementations of the example class are found in example.cpp
class example
{
// private objects/functions are not accessible by the user of this class... same as any
// internal variables in the string object
private:
        int data1;
        int data2;
// public objects/functions are accessible by anyone
// a third type of privacy is the protected type, which has to do with inheritance (not talked about)
public:
        // -------Constructors----------
        example(void);  //default constructor, called when you make an example object... implicit
        example(const int a, const int b); // this is the alternate constructor, you may wish to instantiate some variables on construction
       
        // -------Destructor------------
        ~example(void);
        // there is only one destructor, you can only die one way in program (other than exceptions)
        // this is called when you delete or destroy the object, implicit as well.

        // -------Inspector------------
        // inspectors are just things to allow access to the privates in a very safe way.
        // it is good to keep all attributes in the private and have inspectors access it.
        int get_data1() const;
        // NOTE: the const where it is.  It HAS to be in the position that it is.  What it means
        // is that this function will guarantee the compiler to NOT change anything in the object,
        // basically not manipulating any attributes.  When you do this you can actually call this
        // function on a constant instance of this object.  If the function doesn't have that const
        // at the end, you can't call this function if thte instance is a const.

        // another way to look at it is if I ask you for your name... do I need to tell you your
        // name?  Or better, do you want me to tell you your name and change it?  That's what the
        // const is for.

        int get_data2() const;
        // same deal, it is convention to name it get_<data name> or get<data name with capitalized first letter>
        // i.e. get_data2 (like above) or getData2

        // -------Mutators----------------------
        // mutators are just things that allows you to change the properties of the private members
        // or attributes.
        void set_data1(const int data);
        // NOTE: data is constant, because it works this way.  If I ask you to remember a secret
        //              ... would it be cool if I changed that secret?  That's exactly what's going on here.
        //              You are promising the function caller that you are not changing the message.
        void set_data2(const int data);
        // same deal

        // -------Facilitators-----------------------
        // facilitators, for right now, is just a way for you to categorize anything that
        // doesn't fit in the aboved categories... but it's really just a helper method that
        // does cool stuff... use const as appropriate.
        string to_string() const;
        void addMyself();
        // as you can see, to string is like a function in java, just output the stuff in a
        // string
};

#endif