c++容器无关迭代器

便于实现部分容器无关算法(完全独立于容器不可能, 见effective stl第2条)

 

这是测试

 

 using namespace Scan; using namespace Scan::DataStructure; #include <vector> #include <set> #include <map> #include <hash_set> #include <boost/unordered_set.hpp> #include <ctime> template<typename T> Iterator<int, true> getReverseIterator(T& c) { return Iterator<int, true>(c); } template<typename T> Iterator<const int> getConstIterator(T& c) { return Iterator<const int>(c); } void setRandomReverse(Iterator<int, true> i) { while (i.isExistMore()) { i.getNext() = rand(); } } void print(Iterator<const int> i) { while (i.isExistMore()) { cout << i.getNext() << ','; } cout << endl; } void test1() { srand(time(NULL)); int a1[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; std::vector<int> a2(a1, a1 + 10); std::set<int> a3(a1, a1 + 10); stdext::hash_set<int> a4(a1, a1 + 10); boost::unordered_set<int> a5(a1, a1 + 10); setRandomReverse(getReverseIterator(a1)); setRandomReverse(getReverseIterator(a2)); setRandomReverse(getReverseIterator(a3)); setRandomReverse(getReverseIterator(a4)); // setRandom(getIterator(a5)); 迭代器只读 const int b1[10] = {1, 2, 3}; const std::vector<int> b2(a2); const std::set<int> b3(a3); const stdext::hash_set<int> b4(a4); const boost::unordered_set<int> b5(a5); print(getConstIterator(b1)); print(getConstIterator(b2)); print(getConstIterator(b3)); print(getConstIterator(b4)); print(getConstIterator(b5)); typedef std::map<int, int> Map; typedef Map::value_type MapValue; Map mp; for (int i = 0; i < 10; ++i) { mp[i] = (i + 1) * (i + 1); } Iterator<MapValue, true> i(mp); while (i.isExistMore()) { MapValue &p = i.getNext(); cout << p.first << '=' << p.second << ','; } cout << endl; } void test2() { std::vector<int> v(1 << 20); for (;;) { int times = 0; cout << "输入要操作的次数(单位百万), 以结束/n" ; cin >> times; if (times == 0) { break; } clock_t c = clock(); for (int i = 0; i < times; ++i) { int *p = &v[0]; int *end = p + v.size(); while (p != end) { *p = i + i; ++p; } } cout << "裸指针耗时: " << (clock() - c) / 1000.0 << "秒" << endl; c = clock(); for (int i = 0; i < times; ++i) { std::vector<int>::iterator iter = v.begin(), end = v.end(); while (iter != end) { *iter = i + i; ++iter; } } cout << "标准迭代器耗时: " << (clock() - c) / 1000.0 << "秒" << endl; c = clock(); for (int i = 0; i < times; ++i) { Iterator<int> iter(v); while (iter.isExistMore()) { iter.getNext() = i + i; } } cout << "兼容迭代器耗时: " << (clock() - c) / 1000.0 << "秒" << endl; } } int main() { test1(); test2(); return 0; }

 

在我的老机器上输出:

 

1,2,3,0,0,0,0,0,0,0,
24566,30046,9725,20619,11985,162,29172,9116,4089,20568,
8843,18161,18930,27842,19338,14715,28922,9720,5688,29372,
1178,2865,27526,13355,2940,26430,3723,2522,8572,26199,
1,2,3,4,5,6,7,8,9,10,
0=1,1=4,2=9,3=16,4=25,5=36,6=49,7=64,8=81,9=100,
输入要操作的次数(单位百万), 以0结束
100
裸指针耗时: 0.266秒
标准迭代器耗时: 0.266秒
兼容迭代器耗时: 1.5秒

 

 

 

关于性能问题: 上测试中这个兼容迭代器与标准迭代器相差1.3秒, 其中0.9秒是由于要兼容各种容器和数组的多态虚函数开销, 另外就是由于失去了stl函数inline效果等

这两部分开销测试如下

 

虚函数开销

class FakeIteartor: public IIterator<int>{public: FakeIteartor(std::vector<int>& v): m_size(v.size()){} virtual bool isExistMore() const{return m_size != 0;} virtual int& getNext(){ --m_size; return m_value; } virtual int& peekNext() const{ return m_value; } virtual IIterator* copy() const { return new FakeIteartor(*this); }private: size_t m_size; mutable int m_value;};class BaselineTestIterator: public IIterator<int>{public: BaselineTestIterator(IIterator<int> *iter): m_iter(iter){} ~BaselineTestIterator(){delete m_iter; } virtual bool isExistMore() const{return m_iter->isExistMore(); } virtual int& getNext(){ return m_iter->getNext(); } virtual int& peekNext() const{ return m_iter->peekNext(); } virtual IIterator* copy() const { return new BaselineTestIterator(*this); }private: IIterator<int> *m_iter;}; c = clock(); for (int i = 0; i < times; ++i) { BaselineTestIterator iter(new FakeIteartor(v)); while (iter.isExistMore()) { iter.getNext() = i + i; } } cout << "兼容迭代器虚函数调用耗时: " << (clock() - c) / 1000.0 << "秒" << endl;

 

非inline开销

class NoinlineIterator{public: NoinlineIterator(std::vector<int>::iterator iter): m_iter(iter) {} bool operator != (const NoinlineIterator& o); NoinlineIterator& operator ++ (); operator int* ();private: std::vector<int>::iterator m_iter ;};bool NoinlineIterator::operator != (const NoinlineIterator& o){ return m_iter != o.m_iter; }NoinlineIterator::operator int* (){ return &*m_iter; }NoinlineIterator& NoinlineIterator::operator ++ (){ ++m_iter; return *this; } c = clock(); for (int i = 0; i < times; ++i) { NoinlineIterator iter = v.begin(), end = v.end(); while (iter != end) { *iter = i + i; ++iter; } } cout << "兼容迭代器非inline耗时: " << (clock() - c) / 1000.0 << "秒" << endl;

 

恩, 性能测试中, 还有0.2秒左右我没找到... 水平问题

 

 

 

总之, 在非性能受限处使用以上迭代器是可行的

 

使用方法:

1,
Iterator<int>　　　　　
正向迭代, 返回int引用; 目标容器或数组(new int[n]不行, 必须是数组)必须有int* begin()的声明
 
2,
Iterator<const int>　
正向迭代, 要求目标至少有const int* begin()
 
3,
Iterator<int, true>
逆向迭代
 
4,
Iterator::bindTo
重新绑定新的容器
 
5,
Iterator<int>和Iterator<const int>已经尽量符合iterator和const_iterator的关系
Iterator本身也已经像一般迭代器(指针)一样, 可传值

 

6,

Iterator<ValueType>中的类型必须是容器返回的类型

如测试中, 对于map<FirstType, SecondType>, 如果手工编码的话是Iterator<std::pair<const FirstType, SecondType>>, 因为map的键不允许修改; 所以还是直接使用Container::value_type比较方便

 

 

迭代器代码见下载, 0资源分(我下载频道没分了, 见谅:p)

 http://download.csdn.net/source/2192301 (旧版本)

 

 

 

这是10.4.2重构后新版本代码; 速度上比旧版本低百分之几

 namespace Scan { namespace DataStructure { template<typename T> inline void safe_delete(T& p) { delete p; p = NULL; } namespace MPL { template<typename DestType, typename SrcType> void assertTypeCast() { DestType *p = (SrcType*)0; } #define ASSERT_TYPECAST(dest, src) (void(*)())MPL::assertTypeCast<dest, src> /** @brief 去掉类型的const修饰符 */ template<typename T> struct ToNoConst { typedef T Type; }; template<typename T> struct ToNoConst<const T> { typedef T Type; }; /** @brief 容器的特征 */ template<typename ContainerType, bool reverse> struct ContainerTraits { typedef typename ContainerType::value_type ValueType; typedef typename ContainerType::iterator IterType; static IterType begin(ContainerType& c) { return c.begin(); } static IterType end(ContainerType& c) { return c.end(); } static IterType& move(IterType& i, int step = 1) { std::advance(i, step); return i; } }; template<typename ContainerType> struct ContainerTraits<ContainerType, true> { typedef typename ContainerType::value_type ValueType; typedef typename ContainerType::reverse_iterator IterType; static IterType begin(ContainerType& c) { return c.rbegin(); } static IterType end(ContainerType& c) { return c.rend(); } static IterType& move(IterType& i, int step = 1) { std::advance(i, step); return i; } }; template<typename ContainerType> struct ContainerTraits<const ContainerType, false> { typedef typename const ContainerType::value_type ValueType; typedef typename ContainerType::const_iterator IterType; static IterType begin(const ContainerType& c) { return c.begin(); } static IterType end(const ContainerType& c) { return c.end(); } static IterType& move(IterType& i, int step = 1) { std::advance(i, step); return i; } }; template<typename ContainerType> struct ContainerTraits<const ContainerType, true> { typedef typename const ContainerType::value_type ValueType; typedef typename ContainerType::const_reverse_iterator IterType; static IterType begin(const ContainerType& c) { return c.rbegin(); } static IterType end(const ContainerType& c) { return c.rend(); } static IterType& move(IterType& i, int step = 1) { std::advance(i, step); return i; } }; template<typename T, int len> struct ContainerTraits<T[len], false> { typedef T* IterType; typedef T ValueType; static IterType begin(T (&a)[len]) { return a; } static IterType end(T (&a)[len]) { return a + len; } static IterType& move(IterType& i, int step = 1) { i += step; return i; } }; template<typename T, int len> struct ContainerTraits<T[len], true> { typedef T* IterType; typedef T ValueType; static IterType begin(T (&a)[len]) { return a + len - 1; } static IterType end(T (&a)[len]) { return a - 1; } static IterType& move(IterType& i, int step = 1) { i += -step; return i; } }; template<typename T, int len> struct ContainerTraits<const T[len], false> { typedef const T* IterType; typedef const T ValueType; static IterType begin(const T (&a)[len]) { return a; } static IterType end(const T (&a)[len]) { return a + len; } static IterType& move(IterType& i, int step = 1) { i += step; return i; } }; template<typename T, int len> struct ContainerTraits<const T[len], true> { typedef const T* IterType; typedef const T ValueType; static IterType begin(const T (&a)[len]) { return a + len - 1; } static IterType end(const T (&a)[len]) { return a - 1; } static IterType& move(IterType& i, int step = 1) { i += -step; return i; } }; } /** @brief 迭代器接口 */ template<typename ValueType> struct IIterator { virtual bool isExistMore() const = 0; virtual ValueType& getNext() = 0; virtual ValueType& peekNext() const = 0; virtual IIterator& move(int step = 1) = 0; virtual IIterator* copy() const = 0; virtual ~IIterator() = 0 {} }; /** @brief 遍历指定类型容器的迭代器 要求容器支持stl标准 */ template<typename ContainerType, bool reverse> class ContainerIterator: public IIterator<typename MPL::ContainerTraits<ContainerType, reverse>::ValueType> { public: typedef MPL::ContainerTraits<ContainerType, reverse> HelperType; typedef typename HelperType::IterType IterType; typedef typename HelperType::ValueType ValueType; public: ContainerIterator(ContainerType& c): m_con(c) { m_iter = HelperType::begin(m_con); m_end = HelperType::end(m_con); } virtual bool isExistMore() const { return m_iter != m_end; } virtual ValueType& getNext() { ValueType &r = *m_iter; HelperType::move(m_iter); return r; } virtual ValueType& peekNext() const { ValueType &r = *m_iter; return r; } virtual IIterator* copy() const { return new ContainerIterator(*this); } virtual IIterator& move(int step = 1) { HelperType::move(m_iter, step); return *this; } template<typename NewValueType> IIterator<NewValueType>* castTo() { ASSERT_TYPECAST(NewValueType, ValueType); return reinterpret_cast<IIterator<NewValueType>*>(this); } private: ContainerType &m_con; IterType m_iter; IterType m_end; }; /** @brief 能够遍历各种类型stl容器和数组的迭代器 */ template<typename ValueType, bool reverse = false> class Iterator: IIterator<ValueType> { private: typedef IIterator<ValueType>* IterPtr; public: template<typename ContainerType> explicit Iterator(ContainerType& c) { constructDispatch(c); } Iterator() { m_iter = NULL; } ~Iterator() { safe_delete(m_iter); } Iterator(const Iterator& o) { copyConstruct(o); } Iterator& operator = (const Iterator& o) { if (this != &o) { safe_delete(m_iter); if (o.m_iter != NULL) { m_iter = o.m_iter->copy(); } } return *this; } virtual bool isExistMore() const { return m_iter->isExistMore(); } virtual ValueType& getNext() { return m_iter->getNext(); } virtual ValueType& peekNext() const { return m_iter->peekNext(); } virtual IIterator *copy() const { return new Iterator(*this); } virtual IIterator& move(int step = 1) { m_iter->move(step); return *this; } template<typename ContainerType> void bindTo(ContainerType& c) { m_iter = (new ContainerIterator<ContainerType, reverse>(c))->castTo<ValueType>(); } operator Iterator<const ValueType> () { return *reinterpret_cast<Iterator<const ValueType>*>(this); } private: template<typename T> void constructDispatch(T& v) { bindTo(v); } typedef typename MPL::ToNoConst<ValueType>::Type RawValueType; template<> void constructDispatch<Iterator<RawValueType>>(Iterator<RawValueType>& v) { copyConstruct(v); } template<> void constructDispatch<Iterator<const RawValueType>>(Iterator<const RawValueType>& v) { copyConstruct(v); } void copyConstruct(const Iterator& o) { m_iter = NULL; *this = o; } private: IterPtr m_iter; }; } }