Re[12]: По просьбам трудящихся: Delphi vs C++(VS)
От: FWP Россия  
Дата: 29.09.03 04:41
Оценка:
Здравствуйте, VladD2, Вы писали:

FWP>>Вирт создал не только Pascal. Были еще Modula, Modula-2, Modula-3. TurboPascal и Delphi много чего почерпнули из них.
VD>Врд ли можно что-то почерпнуть из продуктов вышедших позже. Да и слава богу что не почепрнули. Уж очень своеобразное видение ОО у Вирта.
Понятие модулей появилось в TP4.5. Соответственно раздельная компиляция и смартлинкер. Открытые массивы, обрабoтчики исключений в Delphi.
А ООП по Вирту — это действительно своеобразная вещь. Но ведь Вирт, в отличие от WH не только декларирует афоризм Энштейна, но и старается воплощать его в жизнь.
К примеру, Oberon — это почти полностью его разработка. А вот Oberon-2 — делали сотрудники его лаборатории и вернули в язык многие вещи, которые Вирт выбраковал.
Re[12]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 29.09.03 10:09
Оценка:
Здравствуйте, WolfHound, Вы писали:

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

WH>Ага типа я в С++ не могу мыслить виртуально. Вся разница в том что в С++ у меня есть выбор и очень часто шаблон оказывается оптимальным решением, но иногда и виртуальность нужна.
А все твои примеры шаблонные. Кроме всего прочего, не слжно тойже M$ зделать генерилку исходников из шаблонов, и все нетовские проблемы исчезну. А так как мне приходится работать как с ранним так и споздним связыванием, смысла от шаблонов никакого.
WH>struct some
WH>{
WH>//...
WH>};
WH>struct some_dynamic_cmp
WH>{
WH> bool operator()(const some& lhs, const some& rhs)
WH> {
WH> //Тут сравниваем
WH> }
WH>};
WH>void main()
WH>{
WH> std::vector<some> some_vec;
WH> //Заполняем
WH> some_dynamic_cmp cmp;
WH> //Устанавлеваем правила сравнения
WH> std::sort(some_vec.begin(), some_vec.end(), cmp);
WH>}
WH>[/ccode]
WH>Все.
Твой пример из разряда раннего связывания, в отличие от моего. Приведи аналог моего примера с шаблонами.
и солнце б утром не вставало, когда бы не было меня
Re[13]: По просьбам трудящихся: Delphi vs C++(VS)
От: VladD2 Российская Империя www.nemerle.org
Дата: 29.09.03 16:14
Оценка:
Здравствуйте, FWP, Вы писали:

FWP>К примеру, Oberon — это почти полностью его разработка. А вот Oberon-2 — делали сотрудники его лаборатории и вернули в язык многие вещи, которые Вирт выбраковал.

Но не все. При всей недоработанности Дельфий Обераон им в подметки не годится (когда нужно реальный код писать).
... << RSDN@Home 1.1 beta 2 >>
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[43]: По просьбам трудящихся: Delphi vs C++(VS)
От: WolfHound  
Дата: 29.09.03 16:25
Оценка:
Здравствуйте, mihailik, Вы писали:

WH>>Вот именно все должно быть проще. Вот скажи мне какого черта я должен прописать создание десятка объектов (конструктор по умолчению которых мне прекрасно подходит) в конструкторе и удаление всех в деструкторе если я могу их лишь одан раз описать?
M>В конечном счёте для того, чтобы не нужно было заботится о циклических ссылках.

Причем тут циклические ссылки если мне надо например пустой список строк создать?

modified by moderator. _MM_
... << RSDN@Home 1.1 beta 2 >>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[49]: По просьбам трудящихся: Delphi vs C++(VS)
От: WolfHound  
Дата: 29.09.03 16:25
Оценка:
Здравствуйте, mihailik, Вы писали:
M>Это "чего угодно" меня просто веселит. Вы, товарищи крутые программисты, bat-файлы тоже на C++ пишете? Или зашоренность до таких размеров ещё не разрослась?
Только если ты пишешь на дельфе
... << RSDN@Home 1.1 beta 2 >>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[43]: По просьбам трудящихся: Delphi vs C++(VS)
От: WolfHound  
Дата: 29.09.03 16:25
Оценка: +1
Здравствуйте, mihailik, Вы писали:

WH>> Это как?
M>Препроцессор написать. Object Pascal, кстати, очень легко поддаётся синтаксическому разбору. Есть бесплатные реализации.
Сколько можно повторять реализовать шаблоны как в С++ сложнее чем написать компилятор дельфей с нуля.(имеется в виду только front-end)
... << RSDN@Home 1.1 beta 2 >>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[29]: По просьбам трудящихся: Delphi vs C++(VS)
От: WolfHound  
Дата: 29.09.03 16:25
Оценка:
Здравствуйте, mihailik, Вы писали:

WH>>В место Thread.Sleep может быть любая операция прерывающая поток.
WH>>В реальной жизни на сервак который обрабатывает пользователей в отдельных потоках пришла бешеная нагрузка.
M>Ого, ты попробуй там while(true), тоже экстремальные ощущения.
ты чего постоянно дурочку валяешь? Это вполне нормальный код. В реальной жизни просто приперлись одновременно ~2000 клиентов и кирдык. Даже если поток будет отробатывать практически мнгновенно.
... << RSDN@Home 1.1 beta 2 >>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[20]: По просьбам трудящихся: Delphi vs C++(VS)
От: WolfHound  
Дата: 29.09.03 16:25
Оценка:
Здравствуйте, mihailik, Вы писали:

M>Напоминаю, вопрос в том, стоит ли в драйверах использовать C++.
Напоминаю ответ: Почему бы и нет?
... << RSDN@Home 1.1 beta 2 >>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[13]: Некоторые итоги:
От: WolfHound  
Дата: 30.09.03 07:21
Оценка:
Здравствуйте, Serginio1, Вы писали:

S> А все твои примеры шаблонные. Кроме всего прочего, не слжно тойже M$ зделать генерилку исходников из шаблонов, и все нетовские проблемы исчезну. А так как мне приходится работать как с ранним так и споздним связыванием, смысла от шаблонов никакого.
Вот только если они будут только компаил тайм то толку от нх будет мало. Да и они уже есть МС++.

S>Твой пример из разряда раннего связывания, в отличие от моего. Приведи аналог моего примера с шаблонами. 

#include "stdafx.h"
template<class T>
struct dynamic_cmp_t
{
private:
    struct member_ptr_cmp_t
    {
        typedef int T::* member_ptr_t;
        typedef int(*member_cmp_t)(const T&, const T&, member_ptr_t);
        template<class M>
        member_ptr_cmp_t(M T::* member)
            :ptr(reinterpret_cast<member_ptr_t>(member))
            ,cmp(&member_cmp<M>)
        {}
        template<class M>
        static int member_cmp(const T& lhs, const T& rhs, member_ptr_t ptr)
        {
            typedef M T::* member_t;
            member_t member=reinterpret_cast<member_t>(ptr);
            const M& l=lhs.*member;
            const M& r=rhs.*member;
            if(l<r)return -1;
            if(r<l)return 1;
            return 0;
        }
        int compare(const T& lhs, const T& rhs)const
        {
            return cmp(lhs, rhs, ptr);
        }
        member_ptr_t ptr;
        member_cmp_t cmp;
    };
    typedef std::vector<member_ptr_cmp_t>        vector_t;
    typedef typename vector_t::const_iterator    vector_iter_t;
    vector_t vector_;
public:
    void reset()
    {
        vector_.clear();
    }
    template<class M>
    void add(M T::* member)
    {
        vector_.push_back(member_ptr_cmp_t(member));
    }
    int operator()(const T& lhs, const T& rhs)const
    {
        for(vector_iter_t i=vector_.begin(), e=vector_.end();i!=e;++i)
            if(int res=i->compare(lhs, rhs))
                return res;
        return 0;
    }
#define DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(name, op)\
private:\
    struct name##_t\
    {\
        name##_t(const dynamic_cmp_t& cmp)\
            :cmp_(cmp)\
        {}\
        bool operator()(const T& lhs, const T& rhs)const\
        {\
            return cmp_(lhs, rhs) op 0;\
        }\
    private:\
        const dynamic_cmp_t& cmp_;\
    };\
public:\
    name##_t name()const\
    {\
        return name##_t(*this);\
    }\
    bool name(const T& lhs, const T& rhs)const\
    {\
        return name()(lhs, rhs);\
    }
DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(less, <)
DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(greater, >)
DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(less_equal, <=)
DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(greater_equal, >=)
DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(equal, ==)
DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(not_equal, !=)
#undef DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION
};
struct test
{
    test()
        :i1(rand())
        ,f1(rand())
        ,i2(rand())
    {}
    int i1;
    float f1;
    int i2;
};
int main()
{
    test test_arr[100];
    test_arr[2].f1=123;
    test_arr[3].f1=123;
    test_arr[4].f1=123;
    dynamic_cmp_t<test> cmp;
    cmp.reset();
    cmp.add(&test::f1);
    cmp.add(&test::i2);
    cmp.add(&test::i1);
    cmp.less(test_arr[1], test_arr[2]);
    cmp.greater(test_arr[1], test_arr[2]);
    cmp.less_equal(test_arr[1], test_arr[2]);
    cmp.greater_equal(test_arr[1], test_arr[2]);
    cmp.equal(test_arr[1], test_arr[2]);
    cmp.not_equal(test_arr[1], test_arr[2]);
    std::sort(test_arr, test_arr+100, cmp.less());
    std::sort(test_arr, test_arr+100, cmp.greater());
    return 0;
}

Ну и где тут ранние связование? Компатор собирается динамически.
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[14]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 30.09.03 09:16
Оценка:
Здравствуйте, WolfHound, Вы писали:


WH>int main()
WH>{
WH> test test_arr[100];
WH> test_arr[2].f1=123;
WH> test_arr[3].f1=123;
WH> test_arr[4].f1=123;
WH> dynamic_cmp_t<test> cmp;
WH> cmp.reset();
WH> cmp.add(&test::f1);
WH> cmp.add(&test::i2);
WH> cmp.add(&test::i1);
WH> cmp.less(test_arr[1], test_arr[2]);
WH> cmp.greater(test_arr[1], test_arr[2]);
WH> cmp.less_equal(test_arr[1], test_arr[2]);
WH> cmp.greater_equal(test_arr[1], test_arr[2]);
WH> cmp.equal(test_arr[1], test_arr[2]);
WH> cmp.not_equal(test_arr[1], test_arr[2]);
WH> std::sort(test_arr, test_arr+100, cmp.less());
WH> std::sort(test_arr, test_arr+100, cmp.greater());
WH> return 0;
WH>}
WH>[/ccode]
WH>Ну и где тут ранние связование? Компатор собирается динамически.

Обрати внимание на мой код

TType = packed record
d:Integer;
b:Double;
end;
var a:array of Ttype;
ai:Array of integer;
fld:TFld;
Begin
Fld:=TUniversalMultiFld.CreateWithFldClass([TIntegerFld,TDoubleFld]);
Fld.SetCompareFields([Fld.Fields[1],Fld.Fields[0]]); // можно сделать только по индексам
SortArrayFld(a,Fld);

Fld.SetCompareFields([Fld.Fields[0]]); // можно сделать только по индексам
SortArrayFld(a,Fld);

fld.free;
fld:=TIntegerFld.Create;
SortArrayFld(ai,Fld);
Заполнение массивов опускаю.

итд итп.

Но нет китайских иероглифоф. А по писанине то же.
А если структура как в БД насчитывает 100 полей и нужно делать динамическую сортировку по 1, сразу по нескольким полям и нужно как в Ёкселе вывести массив динамически его отсортировать, произвести поиск итд.
и солнце б утром не вставало, когда бы не было меня
Re[15]: Некоторые итоги:
От: WolfHound  
Дата: 30.09.03 11:52
Оценка: +2
Здравствуйте, Serginio1, Вы писали:

S> Обрати внимание на мой код
А что твой код? Изврат редкостный. Не типизировано. Те если будет 100 записае и у одной изменился тип мне придеться лиш перекомпилировать, а тебе бегать по всей программе и выискивать что не так. К томуже использовать индексы полей это тоже плохо ибо опятьже структура может измениться.
А мой код можно на раз переделать в
    dynamic_cmp_t<test> cmp;
    cmp.reset()
        (&test::f1)
        (&test::i2)
        (&test::i1)
    ;
    std::sort(test_arr, test_arr+100, cmp.less());
    cmp.reset()
        (&test::i1)
        (&test::i2)
        (&test::f1)
    ;
    std::sort(test_arr, test_arr+100, cmp.greater());
    cmp.reset();
    if(some1)cmp(&test::i1);
    if(some2)cmp(&test::i2);
    if(some3)cmp(&test::f1);
    std::sort(test_arr, test_arr+100, cmp.less());

К томуже std::sort работает с любым рандомакцесс итератором которыми также являются и указатели
S> Но нет китайских иероглифоф. А по писанине то же.
Ну и где ты нашол иероглифы?
К томуже мне не надо следить за порядком полей в структуре, за типами полей, не надо писать TIntegerFld итп и для того чтобы поддерживалась сортировка по полю определенного типа надо чтобы для этого типа был определен оперетор < и все. А он определен для всех базовых типов, для std::string и в общем то для всех типов для которых имеет смысл сравнение.
S> А если структура как в БД насчитывает 100 полей и нужно делать динамическую сортировку по 1, сразу по нескольким полям и нужно как в Ёкселе вывести массив динамически его отсортировать, произвести поиск итд.
Какие проблемы?
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[16]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 30.09.03 12:09
Оценка:
Здравствуйте, WolfHound, Вы писали:

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

WH>К томуже std::sort работает с любым рандомакцесс итератором которыми также являются и указатели
S>> Но нет китайских иероглифоф. А по писанине то же.
WH>Ну и где ты нашол иероглифы?


WH>К томуже мне не надо следить за порядком полей в структуре, за типами полей, не надо писать TIntegerFld итп и для того чтобы поддерживалась сортировка по полю определенного типа надо чтобы для этого типа был определен оперетор < и все. А он определен для всех базовых типов, для std::string и в общем то для всех типов для которых имеет смысл сравнение.
S>> А если структура как в БД насчитывает 100 полей и нужно делать динамическую сортировку по 1, сразу по нескольким полям и нужно как в Ёкселе вывести массив динамически его отсортировать, произвести поиск итд.
WH>Какие проблемы?

Давай вспомним комбинаторику, сколько сочетаний возможно уже из 3. А из 4. И для всех них писать свои функции???? А если мне структура записи известна только на этапе выполнения, как с таблицами БД и зачем мне типизация в данном случае.
Честно говоря единственно, что мне в Delphi не хватает Это Inline. Все остальное так же как ит ты пишу заготовки и Copy-Paste-Replase или собственную генерилку объектов на худой конец.
и солнце б утром не вставало, когда бы не было меня
Re[17]: Некоторые итоги:
От: WolfHound  
Дата: 01.10.03 04:44
Оценка: +2
Здравствуйте, Serginio1, Вы писали:

S> Давай вспомним комбинаторику, сколько сочетаний возможно уже из 3. А из 4.
Давай вспомним программирование и подумаем причем тут комбинаторика?
S>И для всех них писать свои функции????
Зачем? Я компатор полностью динамичеки собрать могу.
S>А если мне структура записи известна только на этапе выполнения,
И что? Поставь конкретную задачу получишь конкретный ответ. Но ни каких проблем я не вижу.
S>как с таблицами БД и зачем мне типизация в данном случае.
А кудаж без нее? Внутри программы она лишней не будет.
S> Честно говоря единственно, что мне в Delphi не хватает Это Inline.
Практически безполезная штука единственное он иногда бывает нужет когда не шаблонную функцию описываешь прямо в заголовке.
S>Все остальное так же как ит ты пишу заготовки и Copy-Paste-Replase или собственную генерилку объектов на худой конец.
Да как ты не понимаешь что шаблоны и долбаный CPR не имеют ни чего общего. CPR раздувает код, разносит одну ошибку в десятки мест, создает новые... С шаблонами таких проблем НЕТ И БЫТЬ НЕ МОЖЕТ. К томуже шаблоны могут адаптироваться к типам с которыми они работаю, а код полученый при помощи CPR надо каждый раз править ручками.
А что касается ФИЗИЧЕСКОГО уровня то каму какое дело? Там все лишнее оптимизатор выкинет. Главное что ПРОГРАММИСТ не видит эту гору совершенно безполезного, мусорного кода.
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[18]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 01.10.03 09:41
Оценка:
Здравствуйте, WolfHound, Вы писали:

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

S>> Давай вспомним комбинаторику, сколько сочетаний возможно уже из 3. А из 4.
WH>Давай вспомним программирование и подумаем причем тут комбинаторика?
Честно говоря давно не занимался комбинаторикой, но
из 2=2*1!+2! (количество одинарных и 2 х взаимодействий)=4
из 3=3*1!+3*2!+3!=15
из 4=4*1!+4*2!+4*3!+4!=75
итд.


S>>И для всех них писать свои функции????
WH>Зачем? Я компатор полностью динамичеки собрать могу.

S>>А если мне структура записи известна только на этапе выполнения,
WH>И что? Поставь конкретную задачу получишь конкретный ответ. Но ни каких проблем я не вижу.

из 2=2*1!+2! (количество одинарных и 2 х взаимодействий)=4
из 3=3*1!+3*2!+3!=15
из 4=4*1!+4*2!+4*3!+4!=75
итд.

Задача такая отобразить любую таблицу БД информация о которой известна только на этапе выполнения, отредактировать и отсортировать произвести поиск в любых комбинациях полей. Тоже относится и к любым массивам.
Через филды это лекго делается и шаблоны мне не нужны.
Да и применение очень легко для любого конечного пользователя.
см.
http://www.rsdn.ru/Forum/Message.aspx?mid=396688&amp;only=1
Автор: Serginio1
Дата: 30.09.03


оттуда
WH> std::sort(test_arr, test_arr+100, cmp.less()); /
WH> std::sort(test_arr, test_arr+100, cmp.greater());
WH> return 0;
WH>}
WH>[/ccode]
WH>Ну и где тут ранние связование? Компатор собирается динамически.
У тебя есть одно маленькое премущество, мое ну очень слабое знание шаблонов и C++. Но
Смотрим.
dynamic_cmp_t<test> cmp;

Откуда тебе известна структура Test, если вопрос стоял о позднем связывании?????

И интересно сравнить по скорости.
А как ты не крути с шаблонами, на нижнем уровне все происходит без типов и можно смотреть ассемблерный код. А как мне его добиться мои личные проблемы. А виртуалльные методы позволяют легко добиваться цели при получении типа записи в момент выполнения программы.
И уверяю тебя регулярные выражения, шаблоны, макросы,Редакторы компонентов, SQL к чистому программированию никакого отношения не имеют.
и солнце б утром не вставало, когда бы не было меня
Re[19]: Некоторые итоги:
От: WolfHound  
Дата: 01.10.03 11:11
Оценка:
Здравствуйте, Serginio1, Вы писали:

S>>> Давай вспомним комбинаторику, сколько сочетаний возможно уже из 3. А из 4.
WH>>Давай вспомним программирование и подумаем причем тут комбинаторика?
S> Честно говоря давно не занимался комбинаторикой, но
МЛИН да знаю я комбинаторику. В крайнем случае в справочнике уточню.
Ты на вопрос ответь: Кокого черта ты ее сюда вобще приплел?

S> Задача такая отобразить любую таблицу БД информация о которой известна только на этапе выполнения, отредактировать и отсортировать произвести поиск в любых комбинациях полей.
В чем проблема? В каком виде поступают данные? Как передается информация о типах?
S>Тоже относится и к любым массивам.
К каким еще массивам?
S> Через филды это лекго делается и шаблоны мне не нужны.
Вот только за меня все филды сгенерит компилятор а тебе придется действовать через задницу простите через CPR
S>Да и применение очень легко для любого конечного пользователя.
S>см.
S>http://www.rsdn.ru/Forum/Message.aspx?mid=396688&amp;only=1
Автор: Serginio1
Дата: 30.09.03

Тебе второй раз обьяснить почему для типов известных на стадии компиляции это хреновое решение? А в твоем примере все извено на стадии компиляции.

S> Откуда тебе известна структура Test, если вопрос стоял о позднем связывании?????
Если мне не изменяет память стояла задача динамически менять компатор для какойлибо структуры.

S> А как ты не крути с шаблонами, на нижнем уровне все происходит без типов и можно смотреть ассемблерный код. А как мне его добиться мои личные проблемы. А виртуалльные методы позволяют легко добиваться цели при получении типа записи в момент выполнения программы.
Я не понял мы вобще о чем разговариваем? О том как получить кучу асма? Или о том на коком языке писать проще?
S> И уверяю тебя регулярные выражения, шаблоны, макросы,Редакторы компонентов, SQL к чистому программированию никакого отношения не имеют.
Ну чегоже ты тогда в машинных кодах не пишешь?
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[14]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 01.10.03 15:38
Оценка:
Здравствуйте, WolfHound, Вы писали:

Поясни несколько моментов, так как мои познания в С++ очень поверхностны.
WH>
WH>
WH>#include "stdafx.h"
WH>template<class T>
WH>struct dynamic_cmp_t
WH>{
WH>private:
WH>    struct member_ptr_cmp_t
WH>    {
WH>        typedef int T::* member_ptr_t;
                  Тоесть эту запись нужно воспринмать как ссылка на поле????
                  Почему int???? Или это смещение записи???? Или и тип и смещение вместе взятое.
                    

WH>        typedef int(*member_cmp_t)(const T&, const T&, member_ptr_t);
WH>        template<class M>
WH>        member_ptr_cmp_t(M T::* member)
WH>            :ptr(reinterpret_cast<member_ptr_t>(member))
WH>            ,cmp(&member_cmp<M>) Это ссылка на функцию сравнения???
                    WH>        {}
WH>        template<class M>
WH>        static int member_cmp(const T& lhs, const T& rhs, member_ptr_t ptr)
WH>        {
WH>            typedef M T::* member_t;
WH>            member_t member=reinterpret_cast<member_t>(ptr);
WH>            const M& l=lhs.*member;
WH>            const M& r=rhs.*member;
WH>            if(l<r)return -1;
WH>            if(r<l)return 1;
WH>            return 0;
WH>        }
WH>        int compare(const T& lhs, const T& rhs)const
WH>        {
WH>            return cmp(lhs, rhs, ptr);
WH>        }
WH>        member_ptr_t ptr;
WH>        member_cmp_t cmp;
WH>    };
WH>    typedef std::vector<member_ptr_cmp_t>        vector_t;
WH>    typedef typename vector_t::const_iterator    vector_iter_t;
WH>    vector_t vector_;
WH>public:
WH>    void reset()
WH>    {
WH>        vector_.clear();
WH>    }
WH>    template<class M>
WH>    void add(M T::* member)
WH>    {
WH>        vector_.push_back(member_ptr_cmp_t(member));
             Тобишь вызываем конструктор member_ptr_cmp_t с параметром member

WH>    }
WH>    int operator()(const T& lhs, const T& rhs)const
WH>    {
WH>        for(vector_iter_t i=vector_.begin(), e=vector_.end();i!=e;++i)
WH>            if(int res=i->compare(lhs, rhs))
WH>                return res;
WH>        return 0;
WH>    }
WH>#define DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(name, op)\
WH>private:\
WH>    struct name##_t\
WH>    {\
WH>        name##_t(const dynamic_cmp_t& cmp)\
WH>            :cmp_(cmp)\
WH>        {}\
WH>        bool operator()(const T& lhs, const T& rhs)const\
WH>        {\
WH>            return cmp_(lhs, rhs) op 0;\
WH>        }\
WH>    private:\
WH>        const dynamic_cmp_t& cmp_;\
WH>    };\
WH>public:\
WH>    name##_t name()const\
WH>    {\
WH>        return name##_t(*this);\
WH>    }\
WH>    bool name(const T& lhs, const T& rhs)const\
WH>    {\
WH>        return name()(lhs, rhs);\
WH>    }

 Все что выше для меня вообще поный лес.
WH>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(less, <)
WH>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(greater, >)
WH>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(less_equal, <=)
WH>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(greater_equal, >=)
WH>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(equal, ==)
WH>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(not_equal, !=)
WH>#undef DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION
WH>};
WH>struct test
WH>{
WH>    test()
WH>        :i1(rand())
WH>        ,f1(rand())
WH>        ,i2(rand())
WH>    {}
WH>    int i1;
WH>    float f1;
WH>    int i2;
WH>};
WH>int main()
WH>{
WH>    test test_arr[100];
WH>    test_arr[2].f1=123;
WH>    test_arr[3].f1=123;
WH>    test_arr[4].f1=123;
WH>    dynamic_cmp_t<test> cmp;
WH>    cmp.reset();
WH>    cmp.add(&test::f1);
WH>    cmp.add(&test::i2);
WH>    cmp.add(&test::i1);

 Создаешь спискок классов отвечающие за Поля???
WH>    cmp.less(test_arr[1], test_arr[2]);
WH>    cmp.greater(test_arr[1], test_arr[2]);
WH>    cmp.less_equal(test_arr[1], test_arr[2]);
WH>    cmp.greater_equal(test_arr[1], test_arr[2]);
WH>    cmp.equal(test_arr[1], test_arr[2]);
WH>    cmp.not_equal(test_arr[1], test_arr[2]);
   Не до конца понял.
 
WH>    std::sort(test_arr, test_arr+100, cmp.less());
WH>    std::sort(test_arr, test_arr+100, cmp.greater());
WH>    return 0;
WH>}
WH>

WH>Ну и где тут ранние связование? Компатор собирается динамически.
Если я все правильно понял, то разницы в моем коде и твоем никакой. Правда в твоем случае без виртуальных классов только за счет функции сравнения member_cmp_t. Кроме
cmp.add(&test::f1);
WH> cmp.add(&test::i2);
WH> cmp.add(&test::i1);
По сути ты записываешь описание полей?????
В паскале пришлось бы делать с твоей аналогией
cmp.add(@test.f1,TypeOf(test.f1)); Забыл как в RTTI TypeOf, но на C# прямо из типа я могу получить всю информацию о записи и соотвественно прописать все филды.

Но как быть если у тебя не известна структура test на этапе компиляции.
Конечно не разобрался но по сути твой и мой код индентичны.
Слишком много иероглифоф.
Врага надо знать в лицо (С++). Будь добр ответь на ламерские вопросы.
и солнце б утром не вставало, когда бы не было меня
Re[20]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 01.10.03 15:46
Оценка:
Здравствуйте, WolfHound, Вы писали:

S>> Откуда тебе известна структура Test, если вопрос стоял о позднем связывании?????
WH>Если мне не изменяет память стояла задача динамически менять компатор для какойлибо структуры.
В том числе было понятие позднее связываие. Это когда данные о структуре получаешь во время выполнения программы.

S>> А как ты не крути с шаблонами, на нижнем уровне все происходит без типов и можно смотреть ассемблерный код. А как мне его добиться мои личные проблемы. А виртуалльные методы позволяют легко добиваться цели при получении типа записи в момент выполнения программы.
WH>Я не понял мы вобще о чем разговариваем? О том как получить кучу асма? Или о том на коком языке писать проще?
На Delphi проще при достижении тех же результатов. (Для меня лично)
S>> И уверяю тебя регулярные выражения, шаблоны, макросы,Редакторы компонентов, SQL к чистому программированию никакого отношения не имеют.
WH>Ну чегоже ты тогда в машинных кодах не пишешь?
Только на заре моей юности. Но мой код ближе к человеческому, а не аналог регулярных выражений.

Лучше ответь на другой вопрос, что бы не повторяться здесь. Немного поначалу не разобрался, поэтому и комбинаторику вспомнил. Поэтому большая просьба ответить.
и солнце б утром не вставало, когда бы не было меня
Re[20]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 01.10.03 16:02
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Тебе второй раз обьяснить почему для типов известных на стадии компиляции это хреновое решение? А в твоем примере все извено на стадии компиляции.

Но применять я могу как посчитаю нужным. Но при сортировке по полям ты по сути приходишь к тем же виртуальным методам. И твой код не отличается от моего.

S>> А как ты не крути с шаблонами, на нижнем уровне все происходит без типов и можно смотреть ассемблерный код. А как мне его добиться мои личные проблемы. А виртуалльные методы позволяют легко добиваться цели при получении типа записи в момент выполнения программы.
WH>Я не понял мы вобще о чем разговариваем? О том как получить кучу асма? Или о том на коком языке писать проще?
В итоге получить кучу асма. И в С++ ее (кучи) при активном применении шаблонов окажется намного больше. А Проще писать на Родном Языке.
На данном этапе я доказываю, что без шаблонов дышится очень легко, а ты обратное а в итоге приходим к одному и томуже. Ладно закрываю этот разговор. Ответь пожалуйста только на вопросы по синтаксису С++. Я даже книгу из-за тебя по С++ купил 900 стр. Правда за 2 дня прочитал, но информации мало.
и солнце б утром не вставало, когда бы не было меня
Re[20]: Некоторые итоги:
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 01.10.03 16:27
Оценка:
Здравствуйте, WolfHound, Вы писали:


S>> Задача такая отобразить любую таблицу БД информация о которой известна только на этапе выполнения, отредактировать и отсортировать произвести поиск в любых комбинациях полей.
WH>В чем проблема? В каком виде поступают данные? Как передается информация о типах?

А ты ни разу даже с ДБФ файлами не работал???? Заголовочная часть в том числе включает информацию о записи. Или Ёксель сначала идет тип потом данные итд. Тот же Вариант.
А дальше идут последовательно данные по аналогии смассивом, и засасывая в память та же работа как с массивом.
S>>Тоже относится и к любым массивам.
WH>К каким еще массивам?
К последовательному набору записей, он же массив
S>> Через филды это лекго делается и шаблоны мне не нужны.
WH>Вот только за меня все филды сгенерит компилятор а тебе придется действовать через задницу простите через CPR

Один раз извини через задницу (В Net сразу позаботились). За то потом на всю жизнь.
и солнце б утром не вставало, когда бы не было меня
Re[15]: Некоторые итоги:
От: WolfHound  
Дата: 02.10.03 04:52
Оценка:
Здравствуйте, Serginio1, Вы писали:

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

S> Поясни несколько моментов, так как мои познания в С++ очень поверхностны.
WH>>
WH>>
WH>>#include "stdafx.h"
WH>>template<class T>
WH>>struct dynamic_cmp_t
WH>>{
WH>>private:
WH>>    struct member_ptr_cmp_t
WH>>    {
WH>>        typedef int T::* member_ptr_t;
S>                  Тоесть эту запись нужно воспринмать как ссылка на поле????
S>                  Почему int???? Или это смещение записи???? Или и тип и смещение вместе взятое.
WH>>

Это указатель на поле типа int. В данном случае пришлось прибегнуть к к небольшому хаку. В С++ размер указатель на поле одного типа всегда равен размеру указателя на поле любого другого типа. Можно было и без хака но тогда пришлось бы использовать динамическую память, а это лишние тормоза.
WH>>
WH>>        typedef int(*member_cmp_t)(const T&, const T&, member_ptr_t);
WH>>        template<class M>
WH>>        member_ptr_cmp_t(M T::* member)
WH>>            :ptr(reinterpret_cast<member_ptr_t>(member))
WH>>

Тут мы говорим компилятору что он должен считать указатель на поле какого либо типа указателем на поле типа int
WH>>
WH>>            ,cmp(&member_cmp<M>) Это ссылка на функцию сравнения???
                    WH>>        {}
WH>>

Да причем создаем функцию для сравнения полей определенного типа.
WH>>
WH>>        template<class M>
WH>>        static int member_cmp(const T& lhs, const T& rhs, member_ptr_t ptr)
WH>>        {
WH>>            typedef M T::* member_t;
WH>>            member_t member=reinterpret_cast<member_t>(ptr);
WH>>

Так как нам известен факлический тип поля возвращаем его указателю.
WH>>
WH>>            const M& l=lhs.*member;
WH>>            const M& r=rhs.*member;
WH>>

Получаем ссылки на конкретные поля(только для удобства компилятор все это выкинет)
WH>>
WH>>            if(l<r)return -1;
WH>>            if(r<l)return 1;
WH>>

Обрати внимание использован только оператор <
WH>>
WH>>            return 0;
WH>>        }
WH>>        int compare(const T& lhs, const T& rhs)const
WH>>        {
WH>>            return cmp(lhs, rhs, ptr);
WH>>        }
WH>>        member_ptr_t ptr;
WH>>        member_cmp_t cmp;
WH>>    };
WH>>    typedef std::vector<member_ptr_cmp_t>        vector_t;
WH>>    typedef typename vector_t::const_iterator    vector_iter_t;
WH>>    vector_t vector_;
WH>>public:
WH>>    void reset()
WH>>    {
WH>>        vector_.clear();
WH>>    }
WH>>    template<class M>
WH>>    void add(M T::* member)
WH>>    {
WH>>        vector_.push_back(member_ptr_cmp_t(member));
S>             Тобишь вызываем конструктор member_ptr_cmp_t с параметром member
WH>>

Да. Сторого говоря в данном случае member_ptr_cmp_t не нужен компилятор может найти его сам ибо контейнер строго типизированый просто я сначала хотел вызывать его с двумя параметрами но потом передумал, а стереть забыл.
WH>>
WH>>    }
WH>>    int operator()(const T& lhs, const T& rhs)const
WH>>    {
WH>>        for(vector_iter_t i=vector_.begin(), e=vector_.end();i!=e;++i)
WH>>            if(int res=i->compare(lhs, rhs))
WH>>                return res;
WH>>        return 0;
WH>>    }
WH>>#define DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(name, op)\
WH>>private:\
WH>>    struct name##_t\
WH>>    {\
WH>>        name##_t(const dynamic_cmp_t& cmp)\
WH>>            :cmp_(cmp)\
WH>>        {}\
WH>>        bool operator()(const T& lhs, const T& rhs)const\
WH>>        {\
WH>>            return cmp_(lhs, rhs) op 0;\
WH>>        }\
WH>>    private:\
WH>>        const dynamic_cmp_t& cmp_;\
WH>>    };\
WH>>public:\
WH>>    name##_t name()const\
WH>>    {\
WH>>        return name##_t(*this);\
WH>>    }\
WH>>    bool name(const T& lhs, const T& rhs)const\
WH>>    {\
WH>>        return name()(lhs, rhs);\
WH>>    }
S> Все что выше для меня вообще поный лес.
WH>>

Это макрос для генерации функций создания компатора и сравнения двух структур
WH>>
WH>>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(less, <)
WH>>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(greater, >)
WH>>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(less_equal, <=)
WH>>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(greater_equal, >=)
WH>>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(equal, ==)
WH>>DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION(not_equal, !=)
WH>>#undef DYNAMIC_CMP_T_DEFINE_CMP_FUNCTION
WH>>};
WH>>struct test
WH>>{
WH>>    test()
WH>>        :i1(rand())
WH>>        ,f1(rand())
WH>>        ,i2(rand())
WH>>    {}
WH>>    int i1;
WH>>    float f1;
WH>>    int i2;
WH>>};
WH>>int main()
WH>>{
WH>>    test test_arr[100];
WH>>    test_arr[2].f1=123;
WH>>    test_arr[3].f1=123;
WH>>    test_arr[4].f1=123;
WH>>    dynamic_cmp_t<test> cmp;
WH>>    cmp.reset();
WH>>    cmp.add(&test::f1);
WH>>    cmp.add(&test::i2);
WH>>    cmp.add(&test::i1);
S> Создаешь спискок классов отвечающие за Поля???
WH>>

Строго говоря ни какие классы тут не создаются. Но создаются функции сравнения для каждого типа поля те в данном случае компилятор создаст две функции сравнения для полей i1 и i2 будут использована одна функция.
WH>>
WH>>    cmp.less(test_arr[1], test_arr[2]);
WH>>    cmp.greater(test_arr[1], test_arr[2]);
WH>>    cmp.less_equal(test_arr[1], test_arr[2]);
WH>>    cmp.greater_equal(test_arr[1], test_arr[2]);
WH>>    cmp.equal(test_arr[1], test_arr[2]);
WH>>    cmp.not_equal(test_arr[1], test_arr[2]);
S>   Не до конца понял.
WH>>

Это так. Стереть забыл. Просто проверял работоспасобность функций сравнения для двух структур.
WH>>
WH>>    std::sort(test_arr, test_arr+100, cmp.less());
WH>>    std::sort(test_arr, test_arr+100, cmp.greater());
WH>>    return 0;
WH>>}
WH>>

WH>>Ну и где тут ранние связование? Компатор собирается динамически.
S> Если я все правильно понял, то разницы в моем коде и твоем никакой.
Ну да так по мелочи у меня весь фреймворк для поддержки любых типов меньше чем твой без поддержки типов вобще их еще отдельно прописывать надо.
S>Правда в твоем случае без виртуальных классов только за счет функции сравнения member_cmp_t. Кроме
Что дает некоторое преймущуство в скорости не находишь?
S> cmp.add(&test::f1);
WH>> cmp.add(&test::i2);
WH>> cmp.add(&test::i1);
S> По сути ты записываешь описание полей?????
Я записываю лишь смещения полей в структуре, а компилятор генерит всю инфраструктуру по мере необходимости.
S> В паскале пришлось бы делать с твоей аналогией
S>cmp.add(@test.f1,TypeOf(test.f1));
И все в рантайме, а если новый тип появится?
S>Забыл как в RTTI TypeOf, но на C# прямо из типа я могу получить всю информацию о записи и соотвественно прописать все филды.
.НЕТ это отдельная история там вобще все подругому а тут мы разговариваем не о нем, а о C++ и Delphi

S> Но как быть если у тебя не известна структура test на этапе компиляции.
Надо знать КОНКРТНЫЙ формат информации о типах полей. К томуже в реальной жизни в 99% случаев все извесно компилятору
S> Конечно не разобрался но по сути твой и мой код индентичны.
Ну если не считать то что твой код не типизирован, с ним больше гемороя при поддержке, он в несколько раз больше то можно сказать что да
S> Слишком много иероглифоф.
А у тебя слишком много извратов.
S> Врага надо знать в лицо (С++). Будь добр ответь на ламерские вопросы.
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.