Skyddat (protedted) arv

Följande är ett exempel på ett litet objektorienterat program bestående av fyra klasser; Link, List, Stack och Queue vilka är relaterade till varandra enligt följande.

Förutsättningar:

Filen: list.h

#ifndef LIST_H
#define LIST_H

class Link {
public:
	Link(int v);
	void print() const;
	void setNext(Link * link);
	Link * getNext() const;
private:
	int value;
	Link * next;
};

class List {
public:
	List();
	~List();
	int size() const;
	void print() const;
	void insertFirst(Link * link);
	void insertLast(Link * link);
	Link * removeFirst();
	Link * removeLast();
private:
	Link * head;
	Link * getLast() const;		// 'Hjälp' funktioner, har gjorts privata eftersom
	Link * getSecondLast() const;	// de bara används internt av klassens övriga medlemsmetoder.
};

class Queue : protected List {
public:
	void insert(Link * link);
	Link * remove();
	List::size;	// Tillgänglighetsdeklaration,
	List::print;	// ger medlemmarna size och print synlig (public) tillgänglighet 
};			// eftersom det skyddade (proteted) arvet annars gjort dem skyddade. 

class Stack : protected List {
public:
	void insert(Link * link);
	Link * remove();
	List::size;	// Tillgänglighetsdeklaration,
	List::print;	// ger medlemmarna size och print synlig (public) tillgänglighet 
};			// eftersom det skyddade (proteted) arvet annars gjort dem skyddade. 

#endif

Filen: list.cpp

#include <iostream.h>
#include "list.h"

Link::Link(int v)
{
	value = v;
	next = NULL;
}

void Link::print() const
{
	cout << value;
}

void Link::setNext(Link * link)
{
	next = link;
}

Link * Link::getNext() const
{
	return next;
}

List::List()
{
	head = NULL;
}

List::~List()
{
	Link * temp;
	while (head != NULL)
	{
		temp = head->next;
		delete head;
		head = temp;
	}
}

void List::print() const
{
	cout << "[ ";
	Link * temp = head;
	while (temp != NULL)
	{
		temp->print();
		cout << ' ';
		temp = temp->getNext();
	}
	cout << "]" << endl;
}

int List::size() const
{
	int length = 0;
	Link * temp = head;
	while (temp != NULL)
	{
		length++;
		temp = temp->getNext();
	}
	return length;
}

Link * List::getLast() const
{
	if (head == NULL)
		return NULL;

	Link * temp = head;
	while(temp->getNext() != NULL)
		temp = temp->getNext();
	return temp;
}

Link * List::getSecondLast() const
{
	if (head == NULL) return NULL;
	if (head->getNext() == NULL) return NULL;

	Link * temp = head;
	while (temp->getNext()->getNext() != NULL)
		temp = temp->getNext();
	return temp;
}

void List::insertFirst(Link * link)
{
	link->setNext(head);
	head = link;
}

void List::insertLast(Link * link)
{
	if (head == NULL)
		head = link;
	else
		getLast()->setNext(link);
}

Link * List::removeFirst()
{
	if (head == NULL) 
		return NULL;
	Link * temp = head;
	head = head->getNext();
	return temp;
}

Link * List::removeLast()
{
	if (head == NULL) 
		return NULL;
	Link * last = getLast();
	Link * secondLast = getSecondLast();
	if (secondLast == NULL)
		head = NULL;
	else
		secondLast->setNext(NULL);
	return last;
}
void Queue::insert(Link * link)
{
	insertLast(link);
}

Link * Queue::remove()
{
	return removeFirst();
}

void Stack::insert(Link * link)
{
	insertFirst(link);
}

Link * Stack::remove()
{
	return removeFirst();
}

int main(void)
{
	Link * ptr;
	Stack stack;

	ptr = new Link(1);	// Allokerar ett Link objekt
	stack.insert(ptr);	// Stacken tar över ansvaret för Link objektet

	ptr = new Link(2);
	stack.insert(ptr);

	ptr = new Link(3);
	stack.insert(ptr);

	ptr = new Link(4);
	stack.insert(ptr);

	cout << "Size: " << stack.size() << endl;

	stack.print();

	ptr = stack.remove();	// Vi tar över ansvaret för Link objektet
	delete ptr;		// Avallokerar Link objektet

	ptr = stack.remove();
	delete ptr;

	stack.print();

	return 0;
}				// Destruktorn för klassen Link (Stackens basklass) 
				// anropas och avallokerar minnet för de kvarvarande
				// Link objekten i stacken.