• Ideally, an abstract data type encapsulates everything we need to know to use a data type that someone else has defined.

  For example, a linked list data type might be composed of code and routines that allow us to

  • create a new linked list,
  • insert items into a list,
  • delete items from a list,
  • check the size of a list,
  • search a list to see if it contains a particular item,
  • etc.

• So far the data types we have considered have been used to specify data, but do nothing to explicitly associate operations with the data. E.g.:
  • simple data types (int, char, etc)
  • arrays - blocks of items of the same data type
  • structs - collections of different types of data
  In each case, we can write functions to manipulate the data, but those functions are still not logically grouped with the data.

• C++ classes provide a way to combine functions with data inside a single (more complex) data item

• A class describes a set of data items - very much like a struct - and also allows us to associate a set of functions with the class

• The goal is to provide a simple interface users can access to manipulate the data, while hiding the gory implementation details from the user

• The features of the class - data and functions - are divided into two kinds:
  • public features - that can be used by any functions in any program that includes the class
  • private features - that can only be used by the routines within the class (allowing the hiding of implementation details)

• Example class: a student record
  • A student record will consist of a name, a student number, a course name, and the student's mark for that course
  • The student record class will also provide the functions that allow a user to manipulate the different fields of the class: i.e. to initially create (or construct) a student record, and to get and set the values of each of the fields
  An example of a student record class - we'll discuss the syntax and features afterwards

  class StudentRecord {
  
  public: // define the data and routines that are externally accessible
  
      // a constructor for a class has the same name
      //   as the class type, and no return type
      // it is used to create and initialize a class variable
      StudentRecord();  
  
      // a destructor for a class has the same name as the
      //   class type, but preceded by the tilde
      // it is used to clean up any memory allocations when
      //   one is finished with a class variable
      ~StudentRecord();
  
      // routine to set the student's name
      void SetName(char newname[]);
  
      // routine to set the student's id number
      void SetId(int newid);
  
      // routine to set the student's mark for 
      void SetMark(float newmark);
  
      // routine to get the student's name
      char *GetName();
  
      // routine to get the student's id number
      int GetId();
  
      // routine to get the student's mark
      float GetMark();
  
  private: // define the data and routines that can only
           // be accessed by StudentRecord class routines
  
      char Name[60];
      float Mark;
      int Id;
  };
  
  

  To use the student record class, other functions could declare variables to be of type StudentRecord, then access the functions in much the same way as the fields of structs are accessed:

  int main()
  {
     StudentRecord astudent;  // declare a student record variable,
                              // this automatically results in the
                              // StudentRecord() constructor being called
  
     // call the SetName function to set the student's name
     astudent.SetName("Some Name");
     // call the SetId function to set the student's id number
     astudent.SetId(9301);
     // call the SetMark function to set the student's mark
     astudent.SetMark(84.5);
  
     // use the GetName function to print the name back out
     printf("%s\n", astudent.GetName());
     // use the GetId function to print out the student's id
     printf("%d\n", astudent.GetId());
     // use the GetMark function to print out the student's mark
     printf("%g\n", astudent.GetMark());
     
  }
  

  What we haven't shown so far is how to write the bodies of the class functions.

  For these, we need a special declaration indicating both the function name and which class the function is a part of:

  These routines can access things in the "private" section of StudentRecord, but no other routines can.

  StudentRecord::StudentRecord()  
  // a constructor for a class has the same name
  //   as the class type, and no return type
  // it is used to create and initialize a class variable
  {
     strcpy(Name, " ");
     Mark = 0.0;
     Id = 0;
  }
  
  StudentRecord::~StudentRecord()
  // a destructor for a class has the same name as the
  //   class type, but preceded by the tilde
  // it is used to clean up any memory allocations when
  //   one is finished with a class variable
  {
     strcpy(Name, " ");
     Mark = 0.0;
     Id = 0;
  }
  
  void StudentRecord::SetName(char newname[])
  // routine to set the student's name
  {
     if (strlen(newname) < 1) {
        printf("Empty name string supplied\n");
     } else {
        strcpy(Name, newname);
     }
  }
  
  void StudentRecord::SetId(int newid)
  // routine to set the student's id number
  {
     if (newid < 0) {
        printf("Invalid id supplied: %d\n", newid);
     } else {
        Id = newid;
     }
  }
  
  void StudentRecord::SetMark(float newmark)
  // routine to set the student's mark for 
  {
     if ((Mark < 0) || (Mark > 100)) {
       printf("Invalid mark supplied: %g", newmark);
     } else {
        Mark = newmark;
     }
  }
  
  char *StudentRecord::GetName()
  // routine to get the student's name
  {
     return Name;
  }
  
  int StudentRecord::GetId()
  // routine to get the student's id number
  {
      return Id;
  }
  
  float StudentRecord::GetMark()
  // routine to get the student's mark
  {
     return Mark;
  }
  

And a linked list example

#include <cstdio>
#include <cstdlib>
using namespace std;

class ListItem {
public:

   // available constructors to create new list item
   //   - default has no parameters,
   ListItem();
   //   - alternative version lets you create and initialize
   //     with desired data at the same time
   ListItem(float data, ListItem* next);

   // destructor to free up space once finished
   ~ListItem();

   // functions (aka methods) to get and set data field
   void SetData(float data);
   float GetData();

   // functions to get and set pointer to next item
   void SetNext(ListItem* ptr);
   ListItem *GetNext();

   // function to print list item contents
   void printdata();
   // function to print all following list contents
   void printlist();

private:
   ListItem* nextitem;
   float     listdata;
};

// ============== MAIN ROUTINE ============
int main()
{
  ListItem *head, *itemptr;
  char word[20];
  bool quit = false;

  head = NULL;

  do {
     printf("Enter a positive integer to insert in the list\n,");
     printf("or anything else to quit\n");
     scanf("%20s", word);
     if (atoi(word) <= 0) {
        quit = true;
        printf("Goodbye!\n\n");
     } else {
        itemptr = new ListItem(atoi(word), head);
        head = itemptr;
        printf("The new list contents are:\n   ");
        head->printlist();
        printf("\n\n");
     }
  } while (!quit);

  return 0;
}

// ============= STAND-ALONE FUNCTIONS ===========

// ============= LISTITEM CLASS ROUTINES =========
ListItem::ListItem()
{
   listdata = 0.0;
   nextitem = NULL;
}

ListItem::ListItem(float data, ListItem* next)
{
  listdata = data;
  nextitem = next;
}


ListItem::~ListItem()
{
  if (nextitem != NULL)
     nextitem->~ListItem();
   nextitem = NULL;
   listdata = 0.0;
}


void ListItem::SetData(float data)
{
   listdata = data;
}

float ListItem::GetData()
{
   return listdata;
}

void ListItem::SetNext(ListItem* ptr)
{
   nextitem = ptr;
}

ListItem *ListItem::GetNext()
{
   return nextitem;
}

void ListItem::printdata()
{
   printf("%g\n", listdata);
}

void ListItem::printlist()
{
   printf(" %g", listdata);
   if (nextitem != NULL)
      nextitem->printlist();
}