抽象数据类型与类层次（二）

        接上篇，本文主要介绍表征抽象数据类型的几个基础类，包括：Object类（the top of the class hierarchy）、NullObject和Wrapper<T>。

一、Object（点击打开链接）

        Object是类层次中最顶层的抽象类，除Ownership外，该体系中所有其它的类都派生自Object。这种设计的好处是：1）可以通过Object设定公共接口；2）通过指针或引用以及cast实现类型转换（在C#称为装箱和出箱）。

        Object的声明代码如下：

#pragma once
#include <iostream>

class Object
{
public:
    virtual ~Object();
    virtual bool IsNull() const;
    virtual int Compare(Object const &) const;
    //virtual std::hash<Object> Hash() const = 0;
    virtual void Put(std::ostream &)const = 0;

protected:
    virtual int CompareTo(Object const &) const = 0;
};

extern bool operator ==(Object const & left, Object const & right);
extern bool operator !=(Object const & left, Object const & right);
extern bool operator <(Object const & left, Object const & right);
extern bool operator <=(Object const & left, Object const & right);
extern bool operator >(Object const & left, Object const & right);
extern bool operator >=(Object const & left, Object const & right);
extern std::ostream & operator<<(std::ostream & s, Object const & object);

template <typename T>
int Compare(T const & left, T const & right)
{
    int result = 0;

    if (left == right)
        result = 0;
    else if (left > right)
        result = 1;
    else
        result = -1;

    return result;
}

说明：

1，非纯虚的“Compare函数”与纯虚的“CompareTo函数”的设计，采用的就是“non-virtual iterface(NVI)”设计手法。参考《Effective C++》的item 35。这种设计的好处是在“Compare函数”中设定场景，再让“CompareTo函数”去实现多态。“Compare函数”用于各种比较操作符的重载函数。

2，“Put函数”用于流操作符重载函数。

Object的实现代码：

#include "stdafx.h"
#include "Object.h"
#include <typeinfo>        // for typeid
#include <type_traits>    // for std::is_same


Object::~Object()
{
}

bool Object::IsNull() const
{
    return false;
}

int Object::Compare(Object const & object) const
{
    if (typeid(*this) == typeid(object))
        return CompareTo(object);
    else if (typeid(*this).before(typeid(object)))
        return -1;
    else
        return 1;
}

bool operator ==(Object const & left, Object const & right)
{
    return left.Compare(right) == 0;
}

bool operator !=(Object const & left, Object const & right)
{
    return left.Compare(right) != 0;
}

bool operator <(Object const & left, Object const & right)
{
    return left.Compare(right) < 0;
}

bool operator <=(Object const & left, Object const & right)
{
    return left.Compare(right) <= 0;
}

bool operator >(Object const & left, Object const & right)
{
    return left.Compare(right) == 0;
}

bool operator >=(Object const & left, Object const & right)
{
    return left.Compare(right) >= 0;
}

std::ostream & operator<<(std::ostream & s, Object const & object)
{
    object.Put(s);
    return s;
}

注：typeid应于运行时类型识别，type_traits是泛型编程中在编译期类型的识别。

二、The NullObject Singleton Class（点击打开链接）

        NullObject是派生在Object的一个具体类，它表示空，用于占位，使得某些编程操作一致。此外，它采用单例设计模式，方便调用。

#pragma once
#include "Object.h"
class NullObject : public Object
{
public:
    bool IsNull() const;
    //std::hash<Object> Hash() const;
    void Put(std::ostream &)const;

    static NullObject & Instance();

protected:
    int CompareTo(Object const &) const;

private:
    NullObject();
    static NullObject instance;
};

实现代码：

#include "stdafx.h"
#include "NullObject.h"

NullObject NullObject::instance;

NullObject::NullObject()
{
}


bool NullObject::IsNull() const
{
    return true;
}

int NullObject::CompareTo(Object const &) const
{
    return 0;
}

//std::hash<Object> NullObject::Hash() const
//{
//    return 0;
//}

void NullObject::Put(std::ostream & s) const
{
    s << "NullObject";
}

NullObject & NullObject::Instance()
{
    return instance;
}

三、Object Wrappers for the Build-in Types（ 点击打开链接）

        Wrapper是一个包装器，它的作用是包裹内置类型，使内置类型也可像其他Object的派生类一样参与操作。

#ifndef WRAPPER_H
#define WRAPPER_H

#include "Object.h"
#include <algorithm>

template <typename T>
class Wrapper : public Object
{
public:
    Wrapper() : datum() {}
    Wrapper(T const & d) : datum(d) {}

    Wrapper & operator = (T const & d)
    {
        datum = d;
        return *this;
    }

    operator T const &() const { return datum; }
    //std::hash<Object> Hash() const;
    void Put(std::ostream & s) const { s << datum; }

protected:
    int CompareTo(Object const &) const;
    T datum;
};

template <typename T>
int Wrapper<T>::CompareTo(Object const & obj) const
{
    Wrapper<T> const & arg =
        dynamic_cast<Wrapper<T> const &>(obj);
    return ::Compare(datum, arg.datum);
}
#endif // WRAPPER_H

注：这是一个泛型类，支持所有内置类型，包括std::string。

测试代码如下：

#include "Wrapper.h"
#include <string>

typedef Wrapper<int> Int;
typedef Wrapper<char> Char;
typedef Wrapper<double> Double;
typedef Wrapper<std::string> String;
int _tmain(int argc, _TCHAR* argv[])
{
    Int a = 5;
    Int b = -3;
    a.Compare(Int(8));


    String str1("djaojo");
    String str2("doaojo");
    str1.Compare(str2);

	return 0;
}