в C++ в STL-совместимые итераторы итераторы
что я пытаюсь сделать
у меня есть метод, который разделяет вещи. Этот метод не сортирует массив полностью; он просто разбивает массив так, чтобы все элементы на одной стороне (некоторого заранее определенного "центра" или "среднего значения"-это не должно приводить к равномерному разбиению) были меньше, чем "центр", а все элементы на другой стороне больше, чем центр. Точка: это не "сорт" в традиционном смысле; это раздел.
когда я разделяю вещи, мне нужно сохранить ключ; так что, когда вещи меняются местами, ключ меняется; и если в какой-то момент в будущем я хочу отменить раздел, я могу переставить вещи на основе ключа.
очевидно, чтобы переставить вещи на основе ключевого значения, I мог бы сделайте что-нибудь вроде
std::vector< std::pair< std::size_t , my::thingie > > vp;
std::vector< std::size_t >::iterator itKey( key.begin() );
// itThingie_begin and itThingie_end exist; I don't have direct access to the container
my::thingie::iterator itThingie( itThingie_begin );
for (; itKey != key.end(); ++itKey; ++itThingie ) vp.push_back( *itKey, *itThingie );
std::sort( vp.begin() , vp.end() , &comp_pair_first );
itThingie = itThingie_begin;
for ( std::vector< std::pair< std::size_t , my::thingie > >::const_iterator p=vp.begin(); p!=vp.end(); ++p, ++itThingie ) *itThingie = p->second;
Смысл, Я мог бы скопируйте все ключи и данные в пару; и отсортируйте пару по ее первому значению ( key), используя пользовательский предикат сравнения (или с boost::bind); а затем скопируйте все данные обратно. Я это понимаю. Это не идеально, потому что у меня, вероятно, есть пара сотен мегабайт вещей, и вышеупомянутый подход включает копирование этого во временное, сортировку временного, а затем копирование его обратно.
Это также не идеально, потому что мой метод раздела, как он существует в настоящее время, нуждается в итераторах начала и конца ключа и thingie (потому что он должен поменять оба каждый раз, когда он меняет местами). Более того,- и вот Кикер - я должен переписать свой метод раздела, если есть два набора вещей; у меня есть ключ, вещь, которая решает сторону раздела, и другая вещь багажа, которая имеет другую информацию, которую я хочу использовать для других алгоритмов.
Теперь, очевидно, я не хочу переписывать метод раздел каждый раз Я хочу включить какой-то другой итератор для замены "в tandom" с разделом. Так что, как и раньше, я мог скопируйте все это во временную пару std:: (или вложенные пары, если мне нужно поменять больше вещей в тандеме), а затем разделите ее, посмотрев на std:: pair:: first, а затем скопируйте временные данные обратно... Но это чрезвычайно расточительно, потому что каждая дополнительная "багажная" вещь, которую я добавляю, также, вероятно, сотни мегабайт.
Я знаю, я мог бы сделать это таким образом. Я не хочу делать это таким образом, потому что это слишком интенсивная память.
как я хочу сделать это
проблема, которую я описал выше, - это просто одна из операций на итераторах в тандеме. Поэтому я хотел бы иметь коллекцию итераторов, которая абстрагирует содержимое этой коллекции.
Я хочу иметь коллекцию итераторы. Я называю эту коллекцию Питером (это пара итераторов). Когда один обменивает два Питера, один действительно делает std:: iter_swap на своих первых итераторах (а также их вторых итераторах).
Я хочу чтобы иметь итератор Питера (называемый питератором), который имеет все характеристики итератора, но когда он увеличивается и уменьшается, он увеличивает и уменьшает первый и второй итераторы Питера. При разыменовании питератора он должен возвращать ссылку на Питер, который является коллекцией итераторов. Все расстояния могут быть измерены первой составляющей Питера. Или в более общем плане, если есть какой-либо вопрос, на который нужно ответить, и неясно, что итератор должен ответить на него, затем первый итератор Питера должен ответить на него.
Если я хочу создать питератор, который может в-tandom итератор более итераторов, я могу создать питератор, Питер которого содержит итератор (первый) и другой питератор (второй).
Итак, вот что я пробовал (я также пытался использовать boost:: iterator_facade, но у меня в конечном итоге та же проблема - как описано ниже.)
#include <vector>
#include <iostream>
#include <algorithm>
#include <utility>
#include <iterator>
//
// pair of iterators
//
template <typename T,typename U>
struct piter : public std::pair<T,U>
{
piter() : std::pair<T,U>() {};
piter( T const & l , U const & r ) : std::pair<T,U>(l,r) {};
piter( std::pair<T,U> const & p ) { this->first = p.first; this->second = p.second; };
//piter( std::pair<T,U> const p ) { this->first = p.first; this->second = p.second; };
template <typename OT, typename OU>
piter( piter<OT,OU> const & p ) : std::pair<T,U>::first(p.first), std::pair<T,U>::second(p.second) {}
piter<T,U> & operator=( piter<T,U> const & rhs )
{
if( &rhs != this ) { *this->first = *rhs.first; *this->second = *rhs.second; }
return *this;
};
friend void swap( piter<T,U> & lhs, piter<T,U> & rhs )
{
using std::swap;
std::cout << "piter::swap; WAS: " << *lhs.first << " <-> " << *rhs.first << std::endl;
std::iter_swap(lhs.first,rhs.first);
std::iter_swap(lhs.second,rhs.second);
std::cout << "piter::swap; NOW: " << *lhs.first << " <-> " << *rhs.first << std::endl;
};
};
//
// iterator of pair of iterators
//
template <typename T, typename U>
class piterator : public std::iterator< std::random_access_iterator_tag,
piter<T,U>,
std::ptrdiff_t,
piter<T,U> *,
piter<T,U> & >
{
typedef piterator<T,U> iter;
public: // Traits typedefs, which make this class usable with algorithms which need a random access iterator.
typedef std::random_access_iterator_tag iterator_category;
typedef piter<T,U> value_type;
typedef std::ptrdiff_t difference_type;
typedef piter<T,U> * pointer;
typedef piter<T,U> & reference;
public:
piterator() {};
piterator( iter const & rhs ) { this->mp.first = rhs.mp.first; this->mp.second = rhs.mp.second;};
piterator( pointer rhs ) { this->mp.first = rhs->first; this->mp.second = rhs->second; };
//piterator( reference const rhs ) { this->mp.first = rhs.first; this->mp.second = rhs.second; };
piterator( value_type const rhs ) { this->mp.first = rhs.first; this->mp.second = rhs.second; };
iter & operator=( iter const & rhs )
{
if ( &rhs != this ){ this->mp.first = rhs.mp.first; this->mp.second = rhs.mp.second; };
return *this;
}
friend void swap( iter & lhs , iter & rhs )
{
using std::swap;
std::cout << "piterator::swap; WAS: lhs " << *lhs->first << " rhs " << *rhs->first << std::endl;
swap(lhs.mp,rhs.mp);
std::cout << "piterator::swap; NOW: lhs " << *lhs->first << " rhs " << *rhs->first << std::endl;
}
public: // Comparison
// Note: it's an error to compare iterators over different files.
bool operator< ( iter const & rhs ) const { return mp.first < rhs.mp.first; }
bool operator> ( iter const & rhs ) const { return mp.first > rhs.mp.first; }
bool operator==( iter const & rhs ) const { return mp.first == rhs.mp.first; }
bool operator!=( iter const & rhs ) const { return mp.first != rhs.mp.first; }
public: // Iteration
iter & operator++() { ++mp.first; ++mp.second; return *this; }
iter & operator--() { --mp.first; --mp.second; return *this; }
iter operator++(int) { iter tmp(*this); ++(*this); return tmp; }
iter operator--(int) { iter tmp(*this); --(*this); return tmp; }
public: // Step
iter & operator+=( difference_type n ) { mp.first += n; mp.second += n; return *this; }
iter & operator-=( difference_type n ) { mp.first -= n; mp.second -= n; return *this; }
iter operator+ ( difference_type n ) { iter result(*this); return result += n; }
iter operator- ( difference_type n ) { iter result(*this); return result -= n; }
public: // Distance
difference_type operator-( iter & rhs ) { return mp.first - rhs.mp.first; }
public: // Access
reference operator*() { return mp; }
reference operator[]( difference_type n ) { return *(*this+n); }
pointer operator->() { return ∓ };
private: // State
value_type mp;
};
template<class T,class U>
bool proxy_comp( piter<T,U> left, piter<T,U> right )
{
std::cout << "proxy_comp: " << *(left.first) << " > " << *(right.first) << " ?=? " << ( *(left.first) > *(right.first) ) << std::endl;
return *left.first > *right.first;
}
int main()
{
std::vector<double> dv(3);
std::vector<int> iv(3);
dv[0] = -0.5; dv[1] = -1.5; dv[2] = -2.5;
iv[0] = 10; iv[1] = 20; iv[2] = 3;
typedef piterator< std::vector<int>::iterator , std::vector<double>::iterator > PAIR_ITER;
typedef PAIR_ITER::value_type PAIR_REF;
PAIR_ITER pair_begin( PAIR_REF( iv.begin() , dv.begin() ) );
PAIR_ITER pair_end( PAIR_REF( iv.end() , dv.end() ) );
std::cout << "paired arrays now:" << std::endl;
for ( PAIR_ITER p = pair_begin; p != pair_end; ++p )
std::cout << *p->first << " " << *p->second << std::endl;
std::cout << "swap 1st and 3rd elements..." << std::endl;
swap(*pair_begin,*(pair_begin+2));
std::cout << "paired arrays now:" << std::endl;
for ( PAIR_ITER p = pair_begin; p != pair_end; ++p )
std::cout << *p->first << " " << *p->second << std::endl;
std::cout << "calling sort..." << std::endl;
std::sort( pair_begin , pair_end , &proxy_comp<std::vector<int>::iterator , std::vector<double>::iterator> );
std::cout << "paired arrays now:" << std::endl;
for ( PAIR_ITER p = pair_begin; p != pair_end; ++p )
std::cout << *p->first << " " << *p->second << std::endl;
return 0;
}
ПРОБЛЕМА Питер и питератор, кажется, работает, когда я пытаюсь использовать его, как я использую все другие итераторы, но он не работает правильно с алгоритмами STL.
приведенный выше код показывает, что Питер меняет местами правильно, но он не сортируется правильно.
вывод вышеуказанного кода:
paired arrays now:
10 -0.5
20 -1.5
3 -2.5
swap 1st and 3rd elements...
piter::swap; WAS: 10 <-> 3
piter::swap; NOW: 3 <-> 10
paired arrays now:
3 -2.5
20 -1.5
10 -0.5
calling sort...
proxy_comp: 20 > 3 ?=? 1
proxy_comp: 10 > 3 ?=? 1
paired arrays now:
3 -2.5
3 -2.5
3 -2.5
вопрос:
что мне нужно изменить, чтобы std:: sort (или, в идеале, stl вообще) правильно работал с питераторами?
2 ответов
OK. Проблема связана с тем, как stl перемещает память. Он использовал swap() все время, тогда все было бы хорошо, но иногда это так (от stl_algo от GNU.х __вставки_вроде)
if (__comp(*__i, *__first))
{
// COPY VALUE INTO TEMPORARY MEMORY
typename iterator_traits<_RandomAccessIterator>::value_type __val = _GLIBCXX_MOVE(*__i);
// MOVE MEMORY AROUND
_GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
// COPY TEMPORARY VALUE BACK
*__first = _GLIBCXX_MOVE(__val);
}
Итак, мы видим, что итератор:: value_type должен хранить значение. Само по себе оно не может быть указателем. Если это был указатель, то он полностью аннулирует подход псевдо-свопа, показанный выше.
поэтому нам нужно создать вспомогательный класс, который представляет собой коллекцию Значения, в отличие от коллекции итераторов. Мы можем вернуть этот вспомогательный класс, когда оператор разыменования питератора постоянен, например,
value_type operator*() const { return helper_class_value_collection_ctor( _args_ ); };
таким образом, мы можем хранить ценности в новой памяти.
кроме того, нам нужно создать еще один вспомогательный класс, который является коллекцией итераторов, в отличие от значений, так что выражения, такие как
*piterator_a = *piterator_b
действительны. Если *piterator_a возвращается по-значению, то установка этих значений бессмысленна, потому что возвращаемое значение является временным. Итак, в этом случае нам нужен оператор разыменования для возврата ссылочного типа (коллекции итераторов), который будет храниться как частная переменная-член питератора.
reference operator*() { return private_reftype_variable; };
таким образом, положить это в целом приводит к следующему.
#include <vector>
#include <iostream>
#include <utility>
#include <iterator>
#include <algorithm>
// forward decl
template <typename T,typename U> struct piterator_iterators;
template <typename T,typename U>
struct piterator_values
{
// This class holds memory; it is a value_type
// It only serves the purpose of
// allowing the stl to hold temporary values when moving memory around.
// If the stl called sort(), then this class wouldn't be necessary.
//
// Note that the memory may be set by a piterator_iterators class,
// which is a pseudo-value_type that points at memory, instead of holding memory.
//
// YOU NEED THIS SO THAT
// typename piterator<T,U>::value_type Tmp = *piterator_a
// PLACES THE VALUES INTO SOME (ACTUAL) TEMPORARY MEMORY, AS OPPOSED
// TO CREATING A NEW POINTER TO EXISTING MEMORY.
typedef typename T::value_type first_value;
typedef typename U::value_type second_value;
first_value first;
second_value second;
piterator_values() {};
piterator_values( first_value const & first , second_value const & second ) : first(first), second(second) {};
piterator_values( piterator_values<T,U> const & rhs ) : first(rhs.first), second(rhs.second) { };
piterator_values( piterator_iterators<T,U> const & rhs ) : first(*rhs.first), second(*rhs.second) { };
piterator_values<T,U> & operator=( piterator_values<T,U> const & rhs )
{
if( &rhs != this )
{
first = rhs.first;
second = rhs.second;
}
return *this;
};
piterator_values<T,U> & operator=( piterator_iterators<T,U> const & rhs )
{
if( &rhs != this )
{
first = *rhs.first;
second = *rhs.second;
}
return *this;
};
friend void swap( piterator_values<T,U> & lhs, piterator_values<T,U> & rhs )
{
using std::swap;
swap(lhs.first,rhs.first);
swap(lhs.second,rhs.second);
};
};
template <typename T,typename U>
struct piterator_iterators
{
T first;
U second;
// This class does not hold memory; it points at existing memory.
// It is a pseudo-value_type. When the piterator dereferences, it
// will return a piterator_iterators object IF it is a nonconst reference.
// This class is used as a "reference" for an actual iterator,
// so assignment operators change the value of the thing pointed at,
// as opposed to reseting the address of what is being pointed at.
//
// YOU NEED THIS SO THAT
// *piterator_a = *piterator_b
// MAKES SENSE.
// IF THE DEREFERENCE PASSED A piterator_values,
// THEN IT WOULD ONLY MODIFY A TEMPORARY, NOT THE ACTUAL THING
//
piterator_iterators() {};
piterator_iterators( T const & first , U const & second ) : first(first), second(second) {};
piterator_iterators( piterator_iterators<T,U> const & rhs ) : first(rhs.first), second(rhs.second) {};
piterator_iterators<T,U> & operator=( piterator_iterators<T,U> const & rhs )
{
if( &rhs != this )
{
*first = *rhs.first;
*second = *rhs.second;
}
return *this;
};
piterator_iterators<T,U> & operator=( piterator_values<T,U> const & rhs )
{
*first = rhs.first;
*second = rhs.second;
return *this;
};
friend void swap( piterator_iterators<T,U> & lhs, piterator_iterators<T,U> & rhs )
{
using std::swap;
std::iter_swap(lhs.first,rhs.first);
std::iter_swap(lhs.second,rhs.second);
};
};
//
// iterator of pair of iterators
//
template <typename T, typename U>
class piterator : public std::iterator< std::random_access_iterator_tag, piterator_values<T,U>, std::ptrdiff_t, piterator_iterators<T,U> *, piterator_iterators<T,U> & >
{
typedef piterator<T,U> iter;
public:
typedef std::random_access_iterator_tag iterator_catagory;
typedef typename piterator<T,U>::value_type value_type;
typedef typename piterator<T,U>::difference_type difference_type;
typedef typename piterator<T,U>::pointer pointer;
typedef typename piterator<T,U>::reference reference;
typedef piterator_iterators<T,U> value_of_reference;
//typedef typename piterator_iterators<T,U> & reference;
public:
piterator() {};
piterator( iter const & rhs ) { mp.first = rhs.mp.first; mp.second = rhs.mp.second; };
piterator( value_of_reference const rhs ) { mp.first = rhs.first; mp.second = rhs.second; };
piterator( T const first, U const second ) { mp.first = first; mp.second = second; };
iter & operator=( iter const & rhs )
{
if ( &rhs != this )
{
mp.first = rhs.mp.first;
mp.second = rhs.mp.second;
};
return *this;
}
friend void swap( iter & lhs , iter & rhs )
{
using std::swap;
swap(lhs.mp,rhs.mp);
}
public: // Comparison
bool operator< ( iter const & rhs ) const { return mp.first < rhs.mp.first; }
bool operator> ( iter const & rhs ) const { return mp.first > rhs.mp.first; }
bool operator==( iter const & rhs ) const { return mp.first == rhs.mp.first; }
bool operator!=( iter const & rhs ) const { return mp.first != rhs.mp.first; }
public: // Iteration
iter & operator++() { ++(mp.first); ++(mp.second); return *this; }
iter & operator--() { --(mp.first); --(mp.second); return *this; }
iter operator++(int) { iter tmp(*this); ++(*this); return tmp; }
iter operator--(int) { iter tmp(*this); --(*this); return tmp; }
public: // Step
iter & operator+=( difference_type n ) { mp.first += n; mp.second += n; return *this; }
iter & operator-=( difference_type n ) { mp.first -= n; mp.second -= n; return *this; }
iter operator+ ( difference_type n ) { iter result(*this); return result += n; }
iter operator- ( difference_type n ) { iter result(*this); return result -= n; }
difference_type operator+ ( iter const & rhs ) { return mp.first + rhs.mp.first; }
difference_type operator- ( iter const & rhs ) { return mp.first - rhs.mp.first; }
public: // Distance
difference_type operator-( iter & rhs ) { return mp.first - rhs.mp.first; }
public: // Access
// reference if on the lhs of the eq.
reference operator*() { return mp; }
// value if on the rhs of the eq.
value_type operator*() const { return value_type(*mp.first,*mp.second); }
reference operator[]( difference_type n ) { return *( (*this) + n ); }
pointer operator->() { return ∓ };
private: // State
value_of_reference mp;
};
вот основная программа, отделенная от выше, чтобы увидеть, как используется выше....
////////////////////////////////////////////////////////////////
template<class T,class U>
bool proxy_comp( piterator_values<T,U> left, piterator_values<T,U> right )
{
return left.first < right.first;
}
///////////////////////////////////////////////////////////////
int main()
{
std::vector<double> dv1(3);
std::vector<double> dv2(3);
std::vector<int> iv(3);
dv1[0] = -0.5; dv1[1] = -1.5; dv1[2] = -2.5;
dv2[0] = 10.5; dv2[1] = 11.5; dv2[2] = 12.5;
iv[0] = 10; iv[1] = 20; iv[2] = 3;
//
// EXAMPLE 1: PAIR OF ITERATORS
//
typedef piterator< std::vector<int>::iterator , std::vector<double>::iterator > PAIR_ITER;
PAIR_ITER pair_begin( iv.begin() , dv1.begin() );
PAIR_ITER pair_end( iv.end() , dv1.end() );
std::cout << "paired arrays now:" << std::endl;
for ( PAIR_ITER p = pair_begin; p != pair_end; ++p )
std::cout << *p->first << " " << *p->second << std::endl;
std::cout << "swap 1st and 3rd elements..." << std::endl;
swap(*pair_begin,*(pair_begin+2));
std::cout << "paired arrays now:" << std::endl;
for ( PAIR_ITER p = pair_begin; p != pair_end; ++p )
std::cout << *p->first << " " << *p->second << std::endl;
std::cout << "calling sort..." << std::endl;
std::sort( pair_begin , pair_end , &proxy_comp<std::vector<int>::iterator , std::vector<double>::iterator> );
std::cout << "paired arrays now:" << std::endl;
for ( PAIR_ITER p = pair_begin; p != pair_end; ++p )
std::cout << *p->first << " " << *p->second << std::endl;
//
// EXAMPLE 2: TRIPLET (PAIR OF PAIR)
//
typedef piterator< std::vector<double>::iterator , std::vector<double>::iterator > DOUBLET_ITER;
typedef piterator< std::vector<int>::iterator , DOUBLET_ITER > TRIPLET_ITER;
TRIPLET_ITER triplet_begin( iv.begin(), DOUBLET_ITER( dv1.begin() , dv2.begin() ) );
TRIPLET_ITER triplet_end( iv.end(), DOUBLET_ITER( dv1.end() , dv2.end() ) );
std::cout << "tripleted arrays now:" << std::endl;
for ( TRIPLET_ITER p = triplet_begin; p != triplet_end; ++p )
std::cout << *p->first << " "
<< *p->second->first << " "
<< *p->second->second << std::endl;
std::cout << "iter_swap 1st and second elements..." << std::endl;
std::iter_swap( triplet_begin , triplet_begin+1 );
std::cout << "tripleted arrays now:" << std::endl;
for ( TRIPLET_ITER p = triplet_begin; p != triplet_end; ++p )
std::cout << *p->first << " "
<< *p->second->first << " "
<< *p->second->second << std::endl;
std::cout << "calling sort..." << std::endl;
std::sort( triplet_begin, triplet_end, &proxy_comp< std::vector<int>::iterator , piterator< std::vector<double>::iterator , std::vector<double>::iterator > > );
std::cout << "tripleted arrays now:" << std::endl;
for ( TRIPLET_ITER p = triplet_begin; p != triplet_end; ++p )
std::cout << *p->first << " "
<< *p->second->first << " "
<< *p->second->second << std::endl;
return 0;
}
вот результат вышеуказанной программы
paired arrays now:
10 -0.5
20 -1.5
3 -2.5
swap 1st and 3rd elements...
paired arrays now:
3 -2.5
20 -1.5
10 -0.5
calling sort...
paired arrays now:
3 -2.5
10 -0.5
20 -1.5
tripleted arrays now:
3 -2.5 10.5
10 -0.5 11.5
20 -1.5 12.5
iter_swap 1st and second elements...
tripleted arrays now:
10 -0.5 11.5
3 -2.5 10.5
20 -1.5 12.5
calling sort...
tripleted arrays now:
3 -2.5 10.5
10 -0.5 11.5
20 -1.5 12.5
прежде всего, вы должны понимать, что std::nth_element уже делает разделение, которое вы описываете. Он находит Nth элемент, точно так же, как вы ожидали, но он также разбивает данные на две части-все элементы меньше, чем элемент, который вы нашли, будут в нижних местоположениях в коллекции, и все большие элементы справа от него.
лично я думаю, что сделал бы все немного по-другому: если вам все еще нужен исходный порядок данных, но также нужно отсортировать его в другом порядке, создать отсортированный индекс и оставить исходные данные в покое. Учитывая, что ваши исходные данные (по-видимому) находятся в std::vector, Я бы лично просто поместил индексы в индекс (добавление новых элементов в конец вектора не сделает их недействительными, как итераторы).
std::vector<int> index(data.size());
template <class T>
struct cmp {
T const &data;
public:
cmp(T const &array) : data(array) {}
bool operator()(int a, int b) { return data[a] < data[b]; }
};
for (int i=0; i<index.size(); i++)
index[i] = i;
std::sort(index.begin(), index.end(), cmp(your_data));
затем, чтобы использовать данные в исходном порядке, вы просто индексируете исходный массив / вектор, например your_data[i]. Чтобы использовать данные в отсортированном порядке, вы используете что-то вроде your_data[index[i]] вместо.
вы можете, конечно, построить все это в индексный класс, поэтому вы просто используете индексный класс'operator[] фактически индексировать в исходные данные в отсортированном порядке. The cmp класс выше уже показывает, как сделать большую часть этого.