public
Created

BaseMFCIter

  • Download Gist
Test.cpp
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
#include "afxwin.h"
#include "afxtempl.h"
#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;
 
 
 
class myCObject : public CObject
{
public:
myCObject( int val )
{
x = val;
}
int x;
};
#include < iterator >
 
// Define BaseMFCIter as a standard input iterator.
//
// The template arguments are:
// Item: the contained element type
// Cont: the container type
// Key: the access key (defaults to POSITION)
 
template < typename Item, class Cont, class Key = POSITION >
class BaseMFCIter : public std::iterator < std::input_iterator_tag, Item >
{
public:
// Define types for the 2 member functions to be used:
typedef Key (Cont::*GetFirstFunctionPtr) () const;
typedef Item (Cont::*GetNextFunctionPtr) (Key&) const;
 
 
// Default constructor, makes a null iterator, equal to BaseMFCIter::end()
BaseMFCIter() : m_pCont(0), m_Pos(0), m_GetFirstFunc(0), m_GetNextFunc(0), m_End(true) {}
 
// Constructor taking pointer to container and the iteration functions
BaseMFCIter(Cont* pCont, GetFirstFunctionPtr pFF, GetNextFunctionPtr pNF)
: m_pCont(pCont), m_Pos(0), m_GetFirstFunc(pFF), m_GetNextFunc(pNF)
{ init(); }
 
// Copy constructor, initialises iterator to first element
BaseMFCIter(const BaseMFCIter& vi) : m_pCont(vi.m_pCont), m_Pos(0),
m_GetFirstFunc(vi.m_GetFirstFunc), m_GetNextFunc(vi.m_GetNextFunc)
{ init(); }
 
// Assignment operator, initialises iterator to first element
BaseMFCIter& operator=(const BaseMFCIter& vi)
{
m_pCont = vi.m_pCont;
m_GetFirstFunc = vi.m_GetFirstFunc;
m_GetNextFunc = vi.m_GetNextFunc;
init();
return *this;
}
 
bool operator == (const BaseMFCIter& rhs) const
{ return (m_Pos == rhs.m_Pos && m_End == rhs.m_End); }
 
bool operator != (const BaseMFCIter& rhs) const
{ return !operator==(rhs); }
 
BaseMFCIter& operator ++ () { advance(); return *this; }
BaseMFCIter& operator ++ (int) { BaseMFCIter ret(*this); advance(); return ret; }
Item operator * () { return m_Item; }
Item operator -> () { return m_Item; }
 
static BaseMFCIter end () { return BaseMFCIter(); } // end() returns default null iterator
 
private:
Item m_Item; // Current item from container
Cont* m_pCont; // Pointer to container
Key m_Pos; // Key to item in container
bool m_End; // Flag to indicate end of container reached
 
// Pointers to container iteration functions
GetFirstFunctionPtr m_GetFirstFunc;
GetNextFunctionPtr m_GetNextFunc;
 
// Use container GetFirst & GetNext functions to set to first element, or end() if not found
void init()
{
m_Pos = 0;
m_End = true;
 
if (m_pCont && m_GetFirstFunc != 0)
{
m_Pos = (m_pCont->*m_GetFirstFunc)();
advance();
}
}
 
// Use container GetNext function to find next element in container
void advance()
{
m_End = m_Pos ? false : true;
m_Item = (m_Pos && m_pCont && m_GetNextFunc != 0) ?
(m_pCont->*m_GetNextFunc)(m_Pos) : Item();
}
};
 
 
//class ListIter : public BaseMFCIter < CObject, CObList >
//{
//public:
// ListIter( CObject* pObj = 0) : BaseMFCIter< CObject, CObList >
// (pObj, CObList::GetHeadPosition, CObList::GetNext)
// {}
//};
 
//
//class ListIter : public BaseMFCIter < myCObject, CObList >
//{
//public:
// ListIter( CObList* pObj = 0) : BaseMFCIter< myCObject, CObList >
// (pObj, &CObList::GetHeadPosition, &CObList::GetNext)
// {}
//};
 
//class ListIter : public BaseMFCIter < myCObject, CObList >
//{
//public:
// ListIter( CObList* pObj = 0) : BaseMFCIter< myCObject, CObList >
// (pObj, &CObList::GetHeadPosition, &CObList::GetNext )
// {}
//};
 
struct Container : public CObList
{
myCObject* GetNext(POSITION& rPosition) { return dynamic_cast<myCObject*>(CObList::GetNext(rPosition)); }
myCObject const* GetNext(POSITION& rPosition) const { return dynamic_cast<const myCObject*>(CObList::GetNext(rPosition)); }
};
 
 
class ListIter : public BaseMFCIter < const myCObject*, Container, POSITION >
{
public:
ListIter( Container* pObj = 0)
: BaseMFCIter< const myCObject*, Container, POSITION >
(pObj, &CObList::GetHeadPosition, &Container::GetNext)
{
}
};
 
void main( )
{
myCObject* m = new myCObject( 1 );
myCObject* n = new myCObject( 2 );
myCObject* p = new myCObject( 3 );
myCObject* q = new myCObject( 4 );
 
Container cont;
cont.AddHead( m );
cont.AddHead( n );
cont.AddHead( p );
cont.AddHead( q );
 
POSITION pos = cont.GetHeadPosition( );
while (pos != NULL)
{
const myCObject& item = *cont.GetNext( pos );
std::cout << "Oldfashioned: " << item.x << std::endl;
}
for (ListIter it=ListIter(&cont); it!= ListIter(); ++it)
{
std::cout << "Newfangled: " << it->x << std::endl;
}
}

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.