Делаю так:

class abc {
    char buff[1024];
public:
    abc(const char *p) { 
        strcpy(buff, p); 
    }
};

set<abc> s;

int main()
{
    s.insert("aaa");

    return 0;
}

но компилятор выдаёт кучу ошибок, почему? И как правильно это сделать?

Здравствуйте, Аноним, Вы писали:

А>но компилятор выдаёт кучу ошибок, почему? И как правильно это сделать?

Думаю, что стоит посмотреть на то, что пишет компилятор.
А пишет он тебе наверняка что-то про оператор '<', который ты не определил.

А>но компилятор выдаёт кучу ошибок, почему? И как правильно это сделать?

свой класс в set-е в данном случае совершенно ненужен. зачем делать какие-то буферы,
если можно хранить только указатели в сете, и написать свою функцию сравнения?

#include <set>
#include <functional>
typedef const char* CHARP;
struct less_char : std::binary_function<CHARP, CHARP, bool>
{
   bool operator()(const CHARP& lhs, const CHARP& rhs) const
   {
       return strcmp(lhs, rhs) < 0;
   }
};

    // other shit

    set<CHARP,less_char> myset;

    myset.insert("Christine");
    myset.insert("Paul");

Мне просто хочется узнать как можно свой класс туда засунуть.

Майерс пишет что такая специализация стандартного алгоритма — вполне приемлема.

#include <functional>
#include <set>

class abc {
    friend struct std::less<abc>;
    char buff[1024];
public:
    abc(const char *p) { 
        strcpy(buff, p); 
    }
};


namespace std
{
    template<>
    struct less<abc> : public binary_function<abc, abc, bool>
    {
        bool operator()(const abc& Left_, const abc& Right_) const
        {
            for (size_t i = 0; i < sizeof(Left_.buff); ++i)
            {
                if (Left_.buff[i] < Right_.buff[i])
                    return true;
                if (Left_.buff[i] > Right_.buff[i])
                    break;
            }
            return false;
        }
    };
}


std::set<abc> s;

int main()
{
    s.insert("aaa");

    return 0;
}

Здравствуйте, Аноним, Вы писали:

А>Мне просто хочется узнать как можно свой класс туда засунуть.
1. Определить operator< для своего класса:

#include <set>

class abc {
    char buff[1024];
public:
    abc(const char *p) { 
        strcpy(buff, p); 
    }

    bool operator< (const abc& rhs) const
    {
        return strcmp(buff, rhs.buff) < 0;
    }
};

int main()
{
    std::set<abc> s;
    s.insert("aaa");

    return 0;
}

2. Предоставить функтор-компаратор для объектов типа abc, и указать его при объявлении:

#include <set>
#include <functional>

class abc {
    char buff[1024];
public:
    abc(const char *p) { 
        strcpy(buff, p); 
    }

    const char* get_buff_ptr() const { return buff; }
};

struct abc_cmp : public std::binary_function<bool , abc, abc>
{
    bool operator() (const abc& lhs, const abc& rhs) const
    {
        return strcmp(lhs.get_buff_ptr(), rhs.get_buff_ptr()) < 0;
    }
};

int main()
{
    std::set<abc, abc_cmp> s;
    s.insert("aaa");
    std::set<abc, abc_cmp>::iterator it = s.begin();

    return 0;
}

Здравствуйте, Bell, Вы писали:

B>2. Предоставить функтор-компаратор для объектов типа abc, и указать его при объявлении:

B>struct abc_cmp : [b]public std::binary_function<bool , abc, abc>

это уже лишнее. Достаточно, чтобы abc_cmp мог выступить в роли бинарного предиката (естественно, с аксиоматикой строгого порядка). А уж будет ли он binary_function — неважно.
Быть моделью binary_function необходимо, когда функцию запихивают в различные комбинаторы из <functional>, такие как bind1st. Вот там — информация о сигнатуре operator() пригодится.

Здравствуйте, Кодт, Вы писали:

К>Здравствуйте, Bell, Вы писали:

B>>2. Предоставить функтор-компаратор для объектов типа abc, и указать его при объявлении:
К>

B>>struct abc_cmp : [b]public std::binary_function<bool , abc, abc>
К>

К>это уже лишнее. Достаточно, чтобы abc_cmp мог выступить в роли бинарного предиката (естественно, с аксиоматикой строгого порядка). А уж будет ли он binary_function — неважно.

Тсс...
Сейчас придет Mr.None и скажет, что это совсем не предикат (здесь

Автор: Mr. None
Дата: 14.08.07

), да еще и минусов наставит