Class Definitions

• Overview of OOP
• Why OOP?
          What problem were we trying to solve? Mostly complexity and re-use.
          People noticed that code that was grouped together with the data it
          manipulated was easier to follow. Also, complex data problems could be simplified by making a graph of them.
• Software re-use
               Code is hard to re-use since everyone codes the interfaces slightly differently.
               At least differently than you want them to be. C++ classes allow a developer to present an interface to the user so
               they can access the data without messing with the internals.
• Control of complexity
               Systems with a large number of related but different data objects were hard to understand.
               Inheritance and access control makes that easier.
              Magic number 7 + or - 2.
               People can only hold about 7 things in their head at the same time.
               So if you can lump things together, you can hold more of the program in your head.
• Code understanding
               Similar problem. Break code into smaller modules to ease understanding.
• Definitions and principles
• Encapsulation
                    Data and code together
                    Object data can only be used by object code
                    Attached code called methods
                    Also known as member functions
                    Like C structures with code fields
• Polymorphism
               Multiple functions with the same name. Allows more natural function naming. Most data objects have a print operation.
               Now all can be called print(). Also can overload operators like plus(+) so that string concatenation can look like arithmetic.
•  Inheritance
               There is often a natural hierarchy to data objects. All rooms have some things in common like walls and doors.
               But some rooms have windows. Some rooms have plumbing. Some walls go to the ceiling and some don't.
               Rather than describe everything for each kind of room,
               create a generic room object and have the special rooms add to that, subtract from that or overload that.
• Client/server model

An object in an object-oriented system encapsulates all we know about a kind of data. If we have a person class that contains a persons name, address, etc. as well as methods that change these fields, link people together into groups, etc., we can view the person class as a server. All other programs that use a person object are clients of it, They make requests, using the methods, and the objects completes t hem and give the results back to the client. This is similar, without the networking, to the way a web browser talks to a web server.


A class is like a structure but it includes fields that are functions. These are called member functions. Some of the fields are public and some are private. Private functions and data are only available to other functions inside the class. Public functions and data are available to outside code. Try to put the public stuff first. Makes it clearer what the user can use. Need member functions to read and set the private data as outside functions won't be able to.

        class list {
        public:
        private:
        }; // list

class and struct are almost interchangeable. In a class, the default is private. In a struct, the default is public. If you don't use the keywords, all methods are public and all data is private. The above is the declaration of a class.

        list joe;

is the definition of an instance called joe. Each instance of a class has a new instantiation of the private variables. If a private variable is declared static, then all the instances share the value of that variable.

Functions and Member functions

Functions must be declared before use. Could be in class definition or simple prototypes.
• Overloading

Function names and operators can be overloaded. That is, multiple versions of a function can exist with the same name. They are usually differentiated by the arguments. Operators like + can also be overloaded. They get turned into a function call with the operand(s) as arguments. Overloading can be used in functions that aren't part of a class.
• Constructors

Called when a variable of that type is declared. Has the same name as the class. Usually several are defined. The simplest takes no args, others take args to help in initialization. The constructor without args is called the default constructor. The default constructor is used when arrays of a class are defined.
• Destructors

Called when an instance of a class goes out of scope. This means it can't be seen anymore and so can be destroyed. The destructor de-allocates storage and any other housekeeping needed. It is called implicitly.
• Member functions (methods)

Defined either inline in the class definition or outside. The outside member functions must indicate the class they are part of. The 'Class_name::' part is called the scope resolution operator It tells the compiler that this function is part of the class class_name.

                Return type
                Class_name::function_name

Member functions don't have to specify the private members of the class. For example, in the C version of a function that examined the value of an element in a structure, the structure was passed as a pointer to the function.

        void
        foo(struct martha * one) {
           printf("%d",one->item);
        }

In C++, the pointer is implicit and the elements can be simple variables in the private part of the class. so

        void
        foo() {
           printf("%d",item);
        }

item can be treated as a parameter to the function. There is a pointer to the data in the class instance available called this. So the variable above was usable as

        this->item;

There is a more complete example here. A version with detailed commentary is here.