Как преобразовать реляционное сравнение указателей в ошибку?

Мы много раз были укушены следующей ошибкой:

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void print(int* pn) { cout << *pn << " "; }

int main() {
    int* n1 = new int(1);
    int* n2 = new int(2);
    int* n3 = new int(3);

    vector<int*> v;
    v.push_back(n1);
    v.push_back(n2);
    v.push_back(n3);

    sort(v.begin(), v.end());   // Here be dragons!

    for_each(v.begin(), v.end(), print);
    cout << endl;
    delete n1; delete n2; delete n3;
}

Проблема в том, что std:: sort сравнивает целые указатели, а не целые числа, что не то, что планировал программист. Хуже того, вывод может выглядеть корректным и детерминированным (рассмотрите порядок адресов, возвращаемых новыми или выделенных в стеке). Корневая проблема заключается в том, что сорт в конечном итоге вызывает оператор < для T, что редко бывает хорошей идеей, когда T - тип указателя.

Есть ли способ предотвратить это или, по крайней мере, получить предупреждение о компиляторе? Например, существует ли способ создать пользовательскую версию std:: sort, для которой требуется функция сравнения, когда T является указателем?

Ответ 1

Для указателей в целом вы можете сделать это:

    #include <ctime>
    #include <vector>
    #include <cstdlib>
    #include <algorithm>
    #include <functional>
    #include <type_traits>

    namespace util {
        struct sort_pointers {
            bool operator() ( int *a, int *b ) {
                return *a < *b;
            }
        };

        template <typename T, bool is_pointer = !std::tr1::is_pointer<T>::value>
        struct sort_helper {
            typedef std::less<T> wont_compare_pointers;
        };

        template <typename T>
        struct sort_helper<T,false> {
        };

        template <typename Iterator>
        void sort( Iterator start, Iterator end )
        {
            std::sort( start,
                       end,
                       sort_helper
                       <
                            typename Iterator::value_type
                       >::wont_compare_pointers() );
        }

        template <typename Iterator, class Func>
        void sort( Iterator start, Iterator end, Func f ) {
            std::sort( start, end, f );
        }
    }

    int main() {
        std::vector<int> v1;
        std::vector<int*> v2;
        srand(time(0));

        for( int i = 0; i < 10; ++i ) {
            v1.push_back(rand());
        }

        util::sort( v1.begin(), v1.end() );

        for( int i = 0; i < 10; ++i ) {
            v2.push_back(&v1[i]);
        }

        /* util::sort( v2.begin(), v2.end() ); */ //fails.
        util::sort( v2.begin(), v2.end(), util::sort_pointers() );

        return 0;
    }

std::tr1::is_pointer был тем, что он был вызван в Visual Studio 2008, но я думаю, что у Boost тоже есть один, а более новые компиляции могут предоставить его как std::is_pointer. Я уверен, что кто-то сможет написать красивое решение, но это работает.

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

Дополнение:

Вы можете обобщить это немного больше, я думаю, чтобы автоматически выбрать функтор, который будет разыменовывать указатели и сравнивать значения:

namespace util {
    template <typename T>
    struct sort_pointers {
        bool operator() ( T a, T b ) {
            return *a < *b;
        }
    };

    template <typename T, bool is_pointer = !std::tr1::is_pointer<T>::value>
    struct sort_helper {
        typedef std::less<T> compare;
    };

    template <typename T>
    struct sort_helper<T,false> {
        typedef sort_pointers<T> compare;
    };

    template <typename Iterator>
    void sort( Iterator start, Iterator end )
    {
        std::sort( start,
                   end,
                   sort_helper
                   <
                        typename Iterator::value_type
                   >::compare() );
    }
}

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

Ответ 2

IMO, программисты должны знать, что std::sort предполагает, что контейнер сохраняет значения. Если вам нужно другое поведение для сравнения, вы предоставляете функцию сравнения. Например. (Непроверенные):

template<typename T>
inline bool deref_compare(T* t1, T* t2) { return *t1 < *t2; }

//...

std::sort(v.begin(), v.end(), deref_compare<int>);

Edit

FWIW, Ответ Джейкоба ближе всего подходит для непосредственного выполнения того, что вы хотите. Могут быть некоторые способы его дальнейшего обобщения.

Ответ 3

У меня нет хорошего ответа для указателей в целом, но вы можете ограничить сравнение, если используете интеллектуальный указатель любого типа - например boost:: shared_ptr.

#include <boost/shared_ptr.hpp>
using namespace std;

template<class T>
bool operator<(boost::shared_ptr<T> a, boost::shared_ptr<T> b)
{
  return boost::shared_ptr<T>::dont_compare_pointers;
}

int main () {
  boost::shared_ptr<int> A;
  boost::shared_ptr<int> B;
  bool i = A < B;  
}

Вывод:

In function 'bool operator<(boost::shared_ptr<T>, boost::shared_ptr<T>) [with T = int]':
t.cpp:15:   instantiated from here
Line 8: error: 'dont_compare_pointers' is not a member of 'boost::shared_ptr<int>'
compilation terminated due to -Wfatal-errors.

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

#ifdef DEBUG
    #define pointer(x) pointer_wrapper<X>
#else
    #define pointer(x) x*
#endif

Это все еще требует, чтобы ваши программисты использовали его, конечно!