• Organization:
  • A class consists of distinct declarations and definitions/implementations
  • Normally, they are even kept in separate files
  • (This is very different from Java)
• Visibility/Accessibility:
  • Variables and methods can be either public, private, or protected
  • (The syntax is very different from Java)

• Purpose:
  • Initialize the attributes of an object
• Declaration:
  • No return type
  • Same name as the class

• The Default Constructor:
  • If no constructor is specified, a public constructor (with no parameters) is provided
• The Copy Constructor:
  • A public constructor that is passed an object (really a reference) of the type of the class and constructs a copy
  • A default implementation is provided by the compiler (but it will only work properly for simple classes)
  • (More on this after we discuss references)

• An Observation:
  • The compiler is allowed to make one implicit conversion when matching actual and formal parameters
• A Consequence:
  • This can lead to unintended consequences with constructors, especially those that have only one parameter
• A Common Practice:
  • Declare one-parameter constructors to be explicit

An Encapsulation of a Shopper in a "Shopping Club"

cppexamples/oopbasics/shopping/Shopper.h

        #ifndef edu_jmu_cs_Shopper_h
#define edu_jmu_cs_Shopper_h

/**
 * A shopper in a shopping club.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
class Shopper {
 private:
  double fee, purchases;
  int account;

 protected:
  /**
   * Set the annual fee for this member.
   *
   * @param annualFee  The annual fee
   */
  void setFee(double annualFee);

 public:
  /**
   * Explicit Value Constructor.
   *
   * @param accountNumber   The account number
   */
  explicit Shopper(int accountNumber);

  /**
   * Increase the total value of purchases made by this Shopper.
   *
   * @param amount   The amount of the new purchase
   */
  void addToPurchases(double amount);

  /**
   * Get the total value of purchases made by this Shopper.
   *
   * @return   The total value of purchases made to date
   */
  double getPurchases(void);
};

#endif
        

The Implementation of the Shopper

cppexamples/oopbasics/shopping/Shopper.cpp

        #include "Shopper.h"

Shopper::Shopper(int accountNumber) {
  account = accountNumber;
  setFee(45.00);
  purchases = 0.00;
}

void Shopper::addToPurchases(double amount) {
  purchases += amount;
}

double Shopper::getPurchases(void) {
  return purchases;
}

void Shopper::setFee(double annualFee) {
  fee = annualFee;
}

        

Using a Shopper

cppexamples/oopbasics/shopping/Driver1.cpp

        #include <iostream>
#include <string>

#include "Shopper.h"

using namespace std;

/**
 * An example that illustrates the use of the Shopper and
 * ExecutiveShopper classes.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
int main(void) {
  Shopper alice = Shopper(1001);

  cout << "Alice's purchases (before): " << alice.getPurchases() << "\n";
  alice.addToPurchases(154.60);
  cout << "Alice's purchases (after):  " << alice.getPurchases() << "\n";

  return 1;
}
        

• Member Initializers:
  • Shopper(int accountNumber): purchases(0.00)
• One constructor can't call another constructor (so move common construction tasks to another method)
• A class's constructor can not have arguments of the class's own type but you can pass a reference (more on this after we discuss references)

• The Idea:
  • A mechanism for making the private attributes and methods of a class available to some, but not all, classes or functions
• A Motivating Example:
  • We have a Car class with some private attributes and we have a Garage class that has an array of Car objects

An Example

    class Car {   
      private:

        int     year;
	char    *make, *model; 

      public:

        .
        . Some member functions
        .

	friend class Garage;
    };
    

An Example (cont.)

    class Garage {

       .
       . Some member variables and functions
       .

    };
  

• Recall:
  • In general, a member is associated with an instance of an object rather than with a class
  • Sometimes, however, we want to be able to have variables or methods associated with the class itself
• A Motivating Example:
  • You are building an order entry system that automatically assigns order numbers

The Motivating Example - One Approach that Won't Work

    class Order {
      public:
        int    accountNumber, orderNumber, productNumber;
    };
    

The Motivating Example - One Approach that Won't Work (cont.)

    void main(void) {

        Order   jmuOrder;


	jmuOrder.accountNumber = 1001;
	jmuOrder.productNumber =    5;

	// Use the next available order number

        ++jmuOrder.orderNumber;     // This doesn't do what we want
    }
    

The Motivating Example - Another Approach that Won't Work

    class Order {
      public:

        int    accountNumber, orderNumber, productNumber;
	int    lastOrderNumber;
    };
    

The Motivating Example - Another Approach that Won't Work (cont.)

    int main(void) {

        Order   jmuOrder;

	jmuOrder.accountNumber = 1001;
	jmuOrder.productNumber =    5;

	// Use the next available order number

        ++jmuOrder.lastOrderNumber;             // This still
	jmuOrder.orderNumber = lastOrderNumber; // won't work!
    }
    

The Motivating Example - Using a Static Attribute

    class Order {
      public:
        int          accountNumber, orderNumber, productNumber;
	static int   lastOrderNumber;
    };
    

The Motivating Example - Using a Static Attribute (cont.)

    int main(void) {
        Order   jmuOrder;

	jmuOrder.accountNumber = 1001;
	jmuOrder.productNumber =    5;

	// Use the next available order number

        ++Order::lastOrderNumber;
	jmuOrder.orderNumber = Order::lastOrderNumber;
    }
    

One Detail - Initialization of Static Attributes

• Non-constant static attributes must be initialized in the implementation file:
  • int Order::lastOrderNumber = 0;
• Constant static attributes can be initialized in the header file:
  • static const int LEFT = 0;
  • static const int RIGHT = 0;

• Recall:
  • Sometimes you want a method to be associated with a class rather than instances of the class
• An Important Note:
  • Static member functions can only use static member variables because a static member function can be used even when no instances of its class exist

Continuing the Above Eample

    class Order {
      public:
       int    accountNumber, orderNumber, productNumber;
       static int getOrderNumber(void);

      private:
	  static int    lastOrderNumber;
    };
    

• Keeping track of the number of objects of a particular class that have been instantiated
• Class-specific constants
• A library of methods (e.g., mathematical functions). (Though one can use C-style functions which often results in code that is more readable.)

• The "is-a" relationship:
  • An object of class A "is-an" object of class B if A is/does everything that B is/does and more
• Other Terminology:
  • Superclass -- Subclass
  • Parent Class -- Child Class
  • Base Class -- Derived Class

• Inheritance:
  • The child class inherits the attributes of the parent
  • The child class inherits the methods of the parent
• Visibility/Accessibilty:
  • The child class cannot access private attributes
  • The child class cannot use private methods

• Specialization Syntax:
  • class child: modifier parent [, modifier parent ]...
• Scope Operator Syntax:
  • classname::member

• public:
  • private members remain private
  • protected members remain protected
  • public members remain public
• protected:
  • private members remain private
  • protected members remain protected
  • public members become protected
• private:
  • private members remain private
  • protected members become private
  • public members become private

• Construction Order:
  • The constructor in the parent class is called (automatically) before the constructor in the child
• Calling a Parent's Constructor:
  • Can only be done using a member initializer

An Encapsulation of an ExecutiveShopper in a "Shopping Club"

cppexamples/oopbasics/shopping/ExecutiveShopper.h

        #ifndef edu_jmu_cs_ExecutiveShopprt_h
#define edu_jmu_cs_ExecutiveShopprt_h

#include "Shopper.h"

/**
 * An executive shopper member in a shopping club
 * (i.e., a member that receives cash back on purchases).
 *
 * @author  Prof. David Bernstein, James Madison University
 */
class ExecutiveShopper : public Shopper {
 private:
  double rate;

 public:
  /**
   * Explicit Value Constructor.
   *
   * @param accountNumber   The account number
   * @param cashbackRate    The cash back rate
   */
  ExecutiveShopper(int accountNumber, double cashbackRate);

  /**
   * Get the current cash back payment for
   * this ExecutiveShopper
   *
   * @return   The cash back payment
   */
  double getCashback(void);
};

#endif
        

Implementation of ExecutiveShopper

cppexamples/oopbasics/shopping/ExecutiveShopper.cpp

        #include "ExecutiveShopper.h"

ExecutiveShopper::ExecutiveShopper(int accountNumber, double cashbackRate)
    : Shopper(accountNumber) {
  setFee(100.00);
  rate = cashbackRate;
}

double ExecutiveShopper::getCashback(void) {
  return rate * getPurchases();
}