C++复习，实例复习C++

1、操作符重载、explicit关键字、常函数、未命名命名空间

#include <iostream>

using namespace std;
class DigitalTime{
public:
    DigitalTime(int theHour,int theMinute);
    /*constructor with one parameter should be explicit to prevent auto conversion*/
    explicit DigitalTime(int theHour);
    //with default value 00:00
    DigitalTime();
    //copy constructor
    DigitalTime(const DigitalTime &t);
    /*Destructor should always been declared as virtual function*/
    virtual ~DigitalTime();
    /*const behind the declaration means function don't change member variable*/
    int getHour() const;
    int getMinute() const;
    void advance(int minuteAdded);
    void addvance(int hourAdded,int minuteAdded);
    void add(const DigitalTime &t);
    /*[]必须重载为成员函数，返回引用类型*/
    int& operator [](int index);
    /*operator overload to friend function has advantages*/
    friend const DigitalTime operator+(const DigitalTime &t1,const DigitalTime &t2);
    friend bool operator ==(const DigitalTime &t1,const DigitalTime &t2);
    friend ostream& operator <<(ostream &out,const DigitalTime &t);
    friend istream& operator >>(istream &in,DigitalTime &t);
private:
    int hour,minute;

};
#include <cstdio>
#include <iostream>
#include <cctype>
#include "dtime.h"
using namespace std;
DigitalTime::DigitalTime(int theHour,int theMinute){
    hour = theHour;
    minute = theMinute;
}
DigitalTime::DigitalTime(int theHour){
    hour = theHour;
    minute = 0;
}
DigitalTime::DigitalTime(){
    hour = minute = 0;
}
DigitalTime::DigitalTime(const DigitalTime &t){
    printf("copy constructor\n");
    hour = t.hour;
    minute = t.minute;
}
DigitalTime::~DigitalTime(){

}
int DigitalTime::getHour() const{
    return hour;
}
int DigitalTime::getMinute() const{
    return minute;
}
void DigitalTime::advance(int minuteAdded){
    minute += minuteAdded;
    hour += minute/60;
    minute %= 60;
}
namespace {
    bool readHour(int *hour);
    bool readMinute(int *minute);
    int digitToInt(char c);
}
void DigitalTime::addvance(int hourAdded,int minuteAdded){
    hour += hourAdded;
    advance(minuteAdded);
    hour %= 24;
}
void DigitalTime::add(const DigitalTime &t){
    hour += t.hour;
    minute += t.minute;
}
int& DigitalTime::operator [](int index){
    if(index == 1) return hour;
    if(index == 2) return minute;
    int tmp;
    return tmp;
}
const DigitalTime operator+(const DigitalTime &t1,const DigitalTime &t2){
    return DigitalTime(t1.hour+t2.hour,t1.minute+t2.minute);
}
bool operator ==(const DigitalTime &t1,const DigitalTime &t2){
    return (t1.hour == t2.hour) && (t1.minute == t2.minute);
}
ostream& operator <<(ostream &out,const DigitalTime &t){
    if(t.hour < 10) out << '0';
    out << t.hour << ':';
    if(t.minute < 10)    out << '0';
    out<< t.minute << endl;
    return out;
}
istream& operator >>(istream &in,DigitalTime &t){
    readHour(&(t.hour));
    readMinute(&(t.minute));
    return in;
}

namespace {
    bool readHour(int *hour){
        char c1,c2;
        cin >> c1 >> c2;
        if(isdigit(c1) && isdigit(c2)){
            *hour = digitToInt(c1) * 10 + digitToInt(c2);
            cin >> c1;
            if(c1 != ':') return false;
        }else if(isdigit(c1) && (c2 == ':')){
            *hour = digitToInt(c1);
        }else{
            return false;
        }
        return true;
    }
    bool readMinute(int *minute){
        char c1,c2;
        cin >> c1 >> c2;
        if((c1 >= '0') && (c1 <= '9') && isdigit(c2)){
            *minute = digitToInt(c1);
            *minute = *minute * 10 + digitToInt(c2);
        }else{
            return false;
        }
        return true;
    }
    int digitToInt(char c){
        return (c - '0');
    }
}
2、模板类及其继承

注意：

一、模板类声明和实现可以分开，使用时include实现文件而不是头文件，因为模板类使用时接口和定义不能分开。

二、模板类继承中，子类使用父类不依赖于T的函数需要加this引用。

template<class T>
class PFArray {
public:
    /*capacity default to 50*/
    PFArray();
    explicit PFArray(int theCapacity);
    PFArray(PFArray<T> &pfObject);
    void addElement(T elem);
    bool isFull();
    int getCapacity()const;
    int getNumUsed()const;
    void print()const;
    void emptyArray();
    T& operator[](int index);
    /*should return reference type*/
    PFArray<T>& operator=(const PFArray<T> &pfObject);
    virtual ~PFArray();
private:
    T *array;
    int capacity;
    int used;
};

#include <cstdlib>
#include <cstdio>
#include <iostream>
#include "PFArray.h"

template<class T>
PFArray<T>::PFArray():capacity(50),used(0) {
    array = new T[capacity];
}

template<class T>
PFArray<T>::PFArray(int theCapacity):used(0){
    if(theCapacity <= 0){
        printf("error:capacity cann't be less than 0");
        exit(-1);
    }
    capacity = theCapacity;
}

template<class T>
PFArray<T>::PFArray(PFArray<T> &pfObject){
    capacity = pfObject.getCapacity();
    array = new T[capacity];
    used = pfObject.getNumUsed();
    for(int i = 0; i < used; i++){
        addElement(pfObject[i]);
    }
}

template<class T>
void PFArray<T>::addElement(T elem){
    array[used] = elem;
    used++;
}

template<class T>
bool PFArray<T>::isFull(){
    return (used >= capacity);
}
template<class T>
int PFArray<T>::getCapacity()const{
    return capacity;
}
template<class T>
int PFArray<T>::getNumUsed()const{
    return used;
}
template<class T>
void PFArray<T>::print()const{
    std::cout << "capacity:" << capacity << ",used:" << used << std::endl;
    for(int i = 0; i < used; i++)
        std::cout << array[i]<<' ';
    std::cout << std::endl;
}
template<class T>
void PFArray<T>::emptyArray(){
    used = 0;
}
template<class T>
T& PFArray<T>::operator[](int index){
    return array[index];
}

template<class T>
PFArray<T>& PFArray<T>::operator=(const PFArray<T> &pfObject){
    delete []array;
    capacity = pfObject.getCapacity();
    array = new T[capacity];
    used = pfObject.getNumUsed();
    for(int i = 0; i < used; i++){
        addElement(pfObject[i]);
    }
}

template<class T>
PFArray<T>::~PFArray() {
    // TODO Auto-generated destructor stub
    delete array;
}

#include "PFArray.h"
template <class T>
class PFArrayBak: public PFArray<T>{
public:
    PFArrayBak();
    virtual ~PFArrayBak();
    void backup();
    void restore();
    void printBackup();
private:
    T *bakArray;
    int size;
    int used;
};

#include <iostream>
#include "PFArrayBak.h"
using std::cout;
template<class T>
PFArrayBak<T>::PFArrayBak():PFArray<T>(){
    size = used = this->getNumUsed();
    bakArray = new T[size];
}
template<class T>
void PFArrayBak<T>::backup(){
    if(size < this->getNumUsed()) {
        size = this->getNumUsed();
        delete [] bakArray;
        bakArray = new T[size];
    }
    used = this->getNumUsed();
    for(int i = 0; i < used; i++)
        bakArray[i] = this->operator[](i);
}
template<class T>
void PFArrayBak<T>::printBackup(){
    cout<<"size:"<<size<<std::endl;
    for(int i = 0; i < used; i++){
        cout<<bakArray[i]<<' ';
    }
    cout<<std::endl;
}
template<class T>
void PFArrayBak<T>::restore(){
    this->emptyArray();
    for(int i = 0; i < used; i++){
        addElement(bakArray[i]);
    }
}
template<class T>
PFArrayBak<T>::~PFArrayBak(){
    delete [] bakArray;
}