Russian Qt Forum

Добрый день

Структура имеет оператор <, но в др контейнере (напр std::map) надо xранить не саму структуру, а указатель на нее. Приходится как-то так

C++ (Qt)
struct MyPtr {
  MyPtr( MyStruct * ptr = 0 ) : MPtr(ptr) {}
 
  bool operator < ( const MyPtr & sec ) const
  {
    if (!mPtr) return sec.mPtr != 0;  // указатели могут быть NULL
    if (!sec.mPtr) return false;
 
    return *mPtr < *sec.mPtr;
  }
 
  MyStruct * mPtr;
};

Конечно можно перекрывать сравнения в контейнерах (хранящих указатели), но это не выгоднее. Нет ли удобного стандартного решения?

Спасибо

не совсем понятен вопрос...

покажите в коде где и что вы сравниваете, и как хотелось бы

Пример

C++ (Qt)
std::map <MyStruct *, int> theMap;

Так будут сравниваться указатели и для каждого MyStruct храниться свое значение int. А надо чтобы одно значение хранилось для всех одинаковых MyStruct

А что понимается под "одинаковыми" структурами? Их указатели или содержимое? Все равно не понимаю вопроса.
Скорее всего вы не совсем полностью описали что хотите получить или входные данные. Так как я читаю и в упор не вижу проблемы.

Так кажется я начал понимать. Вам нужно что бы ваши структуры выступали в качестве ключей в мапе и по ним шла сортировка? Я так понимаю?

Да, ты правильно понял. И чтобы сравнивались не указатели, а внутренние данные.

Совершенно верно. Но сами структуры при этом хранятся в др месте и копированию не подлежат. Пример: удалить повторяющиеся эл-ты из контейнера не меняя при этом порядок оставшихся

Содержимое, как это определено оператором < для структуры

Храните в мапе не указатели, а обёртки, для которых определяйте операторы:

C++ (Qt)
template <class T>
class pointer_wrapper
{
public:
    pointer_wrapper(const T * p) : ptr(p) {}
 
    template <class R>
    friend bool operator<(const pointer_wrapper<R> &, const pointer_wrapper<R>&);
 
private:
    const T * ptr;
};
 
template <class R>
bool operator<(const pointer_wrapper<R> & x, const pointer_wrapper<R> & y)
{
    return *(x.ptr) < *(y.ptr);
}
 
 
std::map <pointer_wrapper<MyStruct> , int> theMap;
 

 

Главное - сунуть template, а там хоть трава не расти :'(  Как же мне достучаться до ptr? (хоть бы оператор -> перекрыли). С какой радости он const? И как помещать его в контейнер без конструктора по умолчанию? Имя pointer_wrapper лишено всякой определенности. А проверяться на NULL нам недосуг - надо ж бежать что-то еще "обобщать"

Да уж, "техника на грани фантастики" - простую идею оформить не можем. Но неужели такой простой вещи нет в бусте  ??? ??? Не верю, наверное плохо смотрели

ну если это вызывает такие сложности..

Это просто пример, иллюстрирующий мысль.. const он или не const уже вам решать.. Я предположил, что если он используется в качестве ключа в мапе, то логичнее сделать указатель константным, в противном случае, если вы через ключ пытаетесь и данные его поменять, то это уже что-то нечто.. (хотя чему я удивляюсь..)


Проверяйте, это не сложно..

А как вы ключ-значение в мап добавляете?

C++ (Qt)
MyStruct * myStruct;
theMap[myStruct] = 1;
...
 
theMap[pointer_wrapper(myStruct)] = 1;
...
 

какие здесь могут проблемы возникнуть?

Тебе дали идею, а ты придираешься к реализации. Нафига человеку все реализовывать, чтобы показать саму идею?

А зачем pointer_wrapper() если есть конструктор принимающий такой тип?

Если хотели "дать идею" то можно было напр так
А если приводить код - так уж приводить, пусть неполный но без ляпов на каждом шагу.

Да, но ведь это "велосипед" - а я хочу стандартными средствами  :)

А вот интересно.
Что у нас будет с мэпом, когда мы возьмем и по неконстантному указателю модифицируем объект?
Загнется?

Что считать "загнется"? :)
Может перестать находить значение по "новому" ключу.

А на вставку и нахождение других значений никак не повлияет?

Необязательно загнется, но при вставках/удалениях начнет лупить как попало. Когда сортируем функтором/лямбдой (вместо оператора <) - имеем те же "шансы на успех"  :)

А константность здесь не к месту. напр

C++ (Qt)
std::vector <CComparedPtr<MyStruct> > vec;
..
std::sort(vec.begin(), vec.end()); 

И теперь нельзя менять содержимое - придется const_cast

Не придумывайте, константность здесь не помешает. Сортироваться будут враперы (которые не константные), а вовсе не константные указатели.

C++ (Qt)
template <class T>
class pointer_wrapper
{
public:
	pointer_wrapper( const T * p ) : ptr( p ) {}
 
	const T		operator*() const { return *ptr; }
 
	template <class R>
	friend bool operator<( const pointer_wrapper<R> &, const pointer_wrapper<R> & );
 
private:
	const T * ptr;
};
 
template <class R>
bool operator<( const pointer_wrapper<R> &x, const pointer_wrapper<R> &y )
{
	return *(x.ptr) < *(y.ptr);
}
 
typedef pointer_wrapper<int>	Value;
 
int main( int argc, char *argv[] )
{
	std::vector<Value> vec;
 
	vec.push_back( Value( new int( 9 ) ) );
	vec.push_back( Value( new int( 1 ) ) );
	vec.push_back( Value( new int( 7 ) ) );
	vec.push_back( Value( new int( 2 ) ) );
	vec.push_back( Value( new int( 5 ) ) );
 
	foreach( const Value &v, vec )
		qDebug() << *v;
 
	std::sort( vec.begin(), vec.end() );
 
	foreach( const Value &v, vec )
		qDebug() << *v;
 
	return 0;
}
 

Будут, но что потом делать с отсортированным?
Ой  :)

Вы хотели получить из указателя ключ, предполагаю, что вы будете смотреть порядок этих ключей.