MOOC清华《面向对象程序设计》第7章：统计考试及格率v5.0（某科及格线不是60分）

//main.cpp

#include <iostream>
#include <cstdlib>
#include "ArrayCollection.h"
#include "LinkedListIterator.h"
#include "LinkedListCollection.h"
#include "Score.h"
using namespace std;

template <class _Iterator>
bool isPass(const _Iterator& p){
	return (p->value[0] >= 70 && p->value[1] >= 60 && p->value[2] >= 60);
}//注意：这个isPass的实现是有缺陷的，只适合于Score类型 

template <class _iterator>
void analyze(_iterator begin, _iterator end, bool (*isPass)(const _iterator&)){
	int passed = 0, count = 0;
	for(_iterator p = begin; p != end; p++){
		if(isPass(p))
			passed++;
		count++;
	}
	cout << "passing rate = " << (float)passed / count << endl;
}

int main(int argc, char** argv) {
	Score sarray[3];
	sarray[0] = Score(60, 60, 60);
	sarray[1] = Score(70, 70, 70);
	sarray[2] = Score(50, 80, 80);
	
	ArrayCollection<Score> collection3(3, sarray);
	LinkedListCollection<Score> collection4;
	for(int i = 0; i < 3; i++)
		collection4.addFirst(sarray[i]);
	
	analyze(sarray, sarray + 3, isPass<Score*>);
	analyze(collection3.begin(), collection3.end(), isPass<Score*>);
	analyze(collection4.begin(), collection4.end(), isPass<LinkedListIterator<Score>>);
	
	system("PAUSE");
	return EXIT_SUCCESS;
}

//Score.h

#ifndef Score_h
#define Score_h

#include <iostream>
using namespace std;

struct Score{
	float value[3];
	Score(){}
	Score(float f1, float f2, float f3){
		value[0] = f1;
		value[1] = f2;
		value[2] = f3;
	}
	Score& operator=(const Score& s){
		value[0] = s.value[0];
		value[1] = s.value[1];
		value[2] = s.value[2];
		return *this;
	}
	bool operator>=(float pass){
		return (value[0] >= pass && value[1] >= pass && value[2] >= pass);
	}
};

ostream& operator<<(ostream& out, const Score& s){
	out << '{' << s.value[0] << ',' << s.value[1] << ',' << s.value[2] << '}';
	return out;
}//注意这个流运算符重载不在类Score的内部定义，而要拿到外面来 

#endif

//ArrayCollection.h

#ifndef ArrayCollection_h
#define ArrayCollection_h

template <class T>
class ArrayCollection{
	T* _data;
	int _size;
public:
	ArrayCollection():_size(10){
		_data = new T[_size];
	}
	ArrayCollection(int size):_size(size){
		_data = new T[_size];
	}
	ArrayCollection(int size, T* data):_size(size){
		_data = new T[_size];
		for(int i = 0; i < size; i++)
			*(_data + i) = *(data + i);
	}
	~ArrayCollection(){
		delete[] _data;
	}
	T* begin(){
		return _data;
	}
	T* end(){
		return (_data + _size);
	}
};

#endif

//LinkedListIterator.h

#ifndef LinkedListIterator_h
#define LinkedListIterator_h

template <class T>
struct LinkedListNode{
	T _data;
	LinkedListNode *_next;
	LinkedListNode():_next(NULL){}
	LinkedListNode(T data):_data(data), _next(NULL){}
	LinkedListNode(T data, LinkedListNode<T>* next):_data(data), _next(next){}
	//注意上面这一行的第二个形参，其类型必须是LinkedListNode<T>*，否则
	//将与 LinkedListCollection::addFirst(T&) 中的_head的类型不匹配，编译器会报错！ 
};

template <class T>
struct LinkedListIterator{
	LinkedListNode<T> *pointer;
	LinkedListIterator(LinkedListNode<T> *p):pointer(p){}
	LinkedListIterator(const LinkedListIterator<T>& it):pointer(it.pointer){}
	LinkedListIterator<T>& operator++(){
		pointer = pointer->_next;
		return *this;
	}
	const LinkedListIterator<T> operator++(int){
		LinkedListIterator<T> temp = *this;
		pointer = pointer->_next;
		return temp;
	}
	T& operator*() const{
		return pointer->_data;
	}
	T* operator->() const{
		return &(pointer->_data);
	}
	bool operator!=(const LinkedListIterator<T> &other){
		return pointer != other.pointer;
	}
	bool operator==(const LinkedListIterator<T> &other){
		return pointer == other.pointer;
	}
};

#endif

//LinkedListCollection.h

#ifndef LinkedListCollection_h
#define LinkedListCollection_h

template <class T>
class LinkedListCollection{
	LinkedListNode<T>* _head;
public:
	LinkedListCollection():_head(NULL){}
	~LinkedListCollection(){clear();}
	
	bool empty(){return (_head == NULL);}
	
	void addFirst(const T& data){
		_head = new LinkedListNode<T>(data, _head);
	}
	bool removeFirst(){
		if(_head != NULL){
			LinkedListNode<T>* p = _head;
			_head = _head->_next;
			delete p;
			return true;
		}
		else{
			return false;
		}
	}
	
	T* getFirst(){
		return (_head != NULL) ? &(_head->_data) : NULL;
	}
	
	LinkedListNode<T>* lastNode(){
		LinkedListNode<T>* p;
		for(p = _head; p->_next != NULL; p = p->_next) ;
		return p;
	}
	
	void addLast(const T& data){
		if(_head != NULL){
			lastNode()->_next = new LinkedListNode<T>(data);
		}
		else{
			_head = new LinkedListNode<T>(data);
		}
	}
	
	T* getLast(){
		return (_head != NULL) ? &(lastNode()->_data) : NULL;
	}
	
	bool removeLast(){
		if(_head != NULL){
			if(_head->_next != NULL){
				LinkedListNode<T>* p;
				for(p = _head; p->_next != NULL; p = p->_next) ;
				delete p->_next;
				p->_next = NULL;
				return true;
			}
			else{
				delete _head;
				_head = NULL;
				return true;
			}
		}
		else
			return false;
	}
	
	void clear(){
		while(removeFirst()) ;
	}
	
	LinkedListIterator<T> begin(){
		return LinkedListIterator<T>(_head);
	}
	LinkedListIterator<T> end(){
		return LinkedListIterator<T>(NULL);
	}
};

#endif