Un adaptateur d'itérateur C ++ qui enveloppe et cache un itérateur interne et convertit le type itéré

N'a pas l'air trop compliqué. Vous pouvez définir l'itérateur à l'extérieur. Vous pouvez également utiliser des typedefs. Quelque chose comme ce serait bon, je pense. Notez qu'il serait beaucoup plus propre si que MagicIterator serait pas gratuitement un modèle, mais un membre de l'Élément, typedefed dans le Conteneur peut-être. Comme il est maintenant, il est cyclique de référence, qui en font necassary à écrire moches, code solution de contournement.

namespace detail {
template<typename T, typename U>
struct constify;
template<typename T, typename U>
struct constify<T*, U*> {
typedef T * type;
};
template<typename T, typename U>
struct constify<T*, U const*> {
typedef T const * type;
};
}
template<typename DstType, 
typename Container,
typename InputIterator>
struct MagicIterator;
class Container
{
private:
struct Item
{
Object* pObject;
};
std::list<Item> m_items;
public:
//required by every Container for the iterator
typedef std::list<Item> iterator;
typedef std::list<Item> const_iterator;
//convenience declarations
typedef MagicIterator< IInterface*, Container, iterator > 
item_iterator;
typedef MagicIterator< IInterface*, Container, const_iterator > 
const_item_iterator;
item_iterator Begin();
item_iterator End();
};
template<typename DstType, 
typename Container = Container,
typename InputIterator = typename Container::iterator>
struct MagicIterator : 
//pick either const T or T, depending on whether it's a const_iterator.
std::iterator<std::input_iterator_tag, 
typename detail::constify<
DstType, 
typename InputIterator::value_type*>::type> {
typedef std::iterator<std::input_iterator_tag, 
typename detail::constify<
DstType, 
typename InputIterator::value_type*>::type> base;
MagicIterator():wrapped() { }
explicit MagicIterator(InputIterator const& it):wrapped(it) { }
MagicIterator(MagicIterator const& that):wrapped(that.wrapped) { }
typename base::value_type operator*() {
return (*wrapped).pObject->GetInterface();
}
MagicIterator& operator++() {
++wrapped;
return *this;
}
MagicIterator operator++(int) {
MagicIterator it(*this);
wrapped++;
return it;
}
bool operator==(MagicIterator const& it) const {
return it.wrapped == wrapped;
}
bool operator!=(MagicIterator const& it) const {
return !(*this == it);
}
InputIterator wrapped;
};
//now that the iterator adepter is defined, we can define Begin and End
inline Container::item_iterator Container::Begin() {
return item_iterator(m_items.begin());
}
inline Container::item_iterator Container::End() {
return item_iterator(m_items.end());
}

Maintenant, commencer à l'utiliser:

for(MagicIterator<IInterface*> it = c.Begin(); it != c.End(); ++it) {
//...
}

Vous pouvez également utiliser un itérateur mixin fournis par boost, qui fonctionne comme la version d'entrée de boost::function_output_iterator. Il appelle votre itérateur est operator() qui renvoie alors la valeur appropriée, de faire ce que nous faisons ci-dessus dans notre operator* en principe. Vous le trouverez dans random/detail/iterator_mixin.hpp. Ce serait sans doute de moins en moins de code. Mais elle exige aussi de wrack jusqu'à notre cou pour assurer l'ami-stuff car l'Article est privé et l'itérateur n'est pas définie à l'intérieur de l'Élément. De toute façon, bonne chance 🙂

Cela dépend vraiment de la Containerparce que les valeurs de retour de c.Begin() et c.End() sont définis par l'implémentation.

Si une liste de Containers est connu pour MagicIteratorune classe wrapper peut être utilisé.

template<typename T>
class MagicIterator
{
public:
MagicIterator(std::vector<T>::const_iterator i)
{
vector_const_iterator = i;
}
//Reimplement similarly for more types.
MagicIterator(std::vector<T>::iterator i);
MagicIterator(std::list<T>::const_iterator i);
MagicIterator(std::list<T>::iterator i);
//Reimplement operators here...
private:
std::vector<T>::const_iterator vector_const_iterator;
std::vector<T>::iterator       vector_iterator;
std::list<T>::const_iterator   list_const_iterator;
std::list<T>::iterator         list_iterator;
};

La facile moyen serait d'utiliser un modèle qui accepte Container's type:

//C++0x
template<typename T>
class Iterator :
public T::iterator
{
using T::iterator::iterator;
};
for(Iterator<Container> i = c.begin(); i != c.end(); ++i)
{
//...
}

Plus d'informations ici.

J'ai maintenant trouvé une solution qui est mieux pour mon premier but. Je ne l'aime toujours pas bien 🙂

La solution consiste à MagicIterator être modélisé sur IInterface* et d'être construit à la fois avec un void* pour un itérateur, la taille en octets de dit itérateur, et un tableau de pointeurs de fonctions qui effectuent standard itération des fonctions en dit void* comme incrémenter, décrémenter, déréférencement, etc. MagicIterator suppose qu'il est sécuritaire de le memcpy le itérateur dans une mémoire tampon interne, et met en œuvre ses propres membres par le passage de sa propre mémoire tampon comme un vide,* les fonctions comme si c'était l'original de l'itérateur.

Récipient de a à mettre en œuvre statique itération des fonctions qui jettent de retour fourni de void* vers une std::list::iterator. Conteneur::begin() et Conteneur::end (), il suffit de construire une std::list::iterator, passer un pointeur dans un MagicIterator avec un tableau de ses fonctions itératives, et le retour de la MagicIterator.

C'est un peu dégoûtant, et me brise d'origine de la règle concernant les "pas de memcpy()", et fait des hypothèses sur le fonctionnement interne de la itérateurs en question. Mais il évite d'allocation de tas, garde de la Collection internes (y compris la Poste) privé, rend MagicIterator entièrement indépendant de la collection en question et de IInterface*, et, en théorie, permet MagicIterators de travailler avec toute la collection (à condition que son itérateurs peuvent être en toute sécurité memcopy()'d).