4100: Lecture Notes 11 - Classes and Data Abstraction

Data Abstraction

abstraction: seperating the design details from its use (logical properties from the implementation)
just know how to use, not how it works
the definition of the class and its basic operations are the logical properties; the algorithms to perform these operations are the implementation details.
abstract data type: a data type that seperates the logical properties from implementation details (ADT)
each ADT has a name (typename), values (domain) and set of operations (functions)
Use C++ classes to handle ADT's.
How can we define a list as an ADT?

class listType
{
public:
    bool isEmptyList() const;
    bool isFullList() const;
    int search(int searchItem) const;
    void insert(int newElement);
    void remove(int removeElement);
    void destroyList();
    void printList() const;
    listType(); // constructor

private:
    int list[1000];
    int length;
}

struct versus a class

struct can only have data members; but classes may also have functions (including constructor, destructor)
struct data members are all public by default, class data members are private by default. (you can use private specifier in structs, too)
good practice to limit the use of struct, to groupdata members that are all public without any member functions.

information hiding

Is it a good practice to include the specification and implementation details of a class in the program?
If so, then the user has direct access of the definition of the class and its member functions and user can modify them. So nothing is really private.
Better to hide the implementation details. User should only know what works, not how. Good for a bunch of reasons.
Let's put the implementation details into a seperate file!!!
But the user still needs the specifications in order to use it properly, so put the specifications in a header file.
implementation file will only contain

the definitions of the functions to implement the operations of an object.
will not contain a main function, as a C++ program can only have one.
does not have the class definition, so include the header ile.
has the extension cpp

header file

has the extension h
contains the class definition.

the header file (listType.h)

class listType
{
public:
    bool isEmptyList() const;
    // returns true if the list is empty (length=0)
    // returns false if the list is not empty

    bool isFullList() const;
    // returns true if the list is filled up (length=1000)
    // returns false if the list is not filled up yet

    int search(int searchItem) const;
    // returns the index of the list element
    // that is equal to the parameter value.

    void insert(int newElement);
    // inserts a new element to the end of the list.

    void remove(int removeElement);
    // removes the element with the index
    // passed as the parameter value.

    void printList() const;
    // prints the elements of the list

    listType();
    // constructor.

private:
    int list[1000];
    // variable to store the list elements
    int length;
    // variable to store the size of the list at a given instance.
};

the implementation file (listTypeImp.cpp)

#include<iostream>
#include "listType.h"
// angular brackets are for system provided header files
// double quotes for user defined header files.

using namespace std;

bool listType::isEmptyList() const
{
    if (length>0)
        return true;
    else return false;
}

bool listType::isFullList() const
{
    if (length==1000)
        return true;
    else return false;

}

void listType::insert(int newElement)
{
    length++;
    list[length-1] = newElement;
}

listType::listType()
{
    length = 0;
}

void listType::printList() const
{
    for(int i=0;i<length;i++)
    {
        cout<<i<<"th element of the list is"<<list[i]<<endl;
    }
}

void listType::remove(int removeElement)
{
    for(int i=removeElement;i<length;i++)
    {
        list[i] = list[i+1];
    }
    length--;
}

int listType::search(int searchItem) const
{
    for(int i=0;i<length;i++)
    {
        if (list[i]==searchItem)
            return i;
    }
    return -1;
}

the executable file (test.cpp)

#include "listType.h"

void main()
{
    listType newlist = listType();
    listType oldlist;

    newlist.insert(6);
    newlist.insert(5);
    newlist.insert(9);
    newlist.printList();
    newlist.remove(0);
    newlist.printList();
    newlist.insert(37);
    newlist.insert(42);
}

static members of a class

if a local variable of a function is static, it exists between function calls.

similarly a class can have static members, functions or data
static data members come into existence at the beginning of the program and last until the end of the program's run.
NO MATTER HOW MANY OBJECTS OF THAT CLASS ARE CREATED ONLY ONE EXAMPLE OF EACH CLASS OR STATIC VARIABLE IS CREATED.
if a function of a class is static, it is declared using the keyword static in its heading
if a data member of a class is static, it is declared using the keyword static
a public static member, function or data of a class can be accessed using the classname and the scope resolution operator.

Consider the below class definition.

class Student
{
public:

    void print() const;
    static int getStudCount();
     Student();

private:
    static int studCount;
    float gpa;
     string name;
};

Student::Student()
{
    strcpy(name, " New Student");
    gpa = 0.0;
    studCount++;
}

Student::~Student()
{
studCount--;
}

int Student::getStudCount()
{
return studCount;
}

so all below calls are all valid.

Student s1;
cout << "\nThe number of objects is " ;
<< s1.getStudCount();

static data member of a class exists even when no object of that class type exists!!