Здравствуйте, DOOM, Вы писали:
DOO>Вы всегда массив одинаковыми значениями заполняете? DOO>std::fill — готов поспорить из memcpy слеплена. В Дельфи есть Move, Copy, FillChar
Во первых почитай в MSDN про memcpy...
Во вторых
Здравствуйте, WolfHound, Вы писали:
WH>Здравствуйте, Serginio1, Вы писали:
S>> Вопрос тебе сортировку массивов элементарных типов или сложных структур. WH>И тех и других в одном флаконе. S>>Иногда легче применять ссылочные массивы с функцией сравнения или при динамической сортировке применять Б деревья. WH>Типа std::map и std::set это из другой оперы у меня есть массив хочу его отсортировать. S>>Все о чем ты говришь с применением шаблонов легко решается с помощью Replace или заменой типа соответсвенно скопировав модуль и переименовав его. Не очень сложная задача. WH>cope/paste это не решение это проблема. S>>Можно вспомнить про GetIdsOfNames и Invoke, MakeCreateInstace. Несовместимост Дельфийных и Сишных классов. Суть в совместимости. И почему сишники пишут на Delphi совмещаяя с С++????? А их огромное множество. WH>Ни чего не понял.
Почти на чистейшем Виртовском Паскале.
unit SortAnyArray;
interface
Type
TCompareProc= Function(Var Item1,Item2):Integer;
TSwapProc= Procedure(Var Item1,Item2);
Procedure SortArray3(Var a; Len:Integer; CompareProc:TCompareProc;SwapProc:TSwapProc);// Для несовсем ленивыхProcedure SortArray( Var a; Len:Integer; CompareProc:TCompareProc); // для ленивыхimplementation
Procedure SortArray(Var a; Len:Integer; CompareProc:TCompareProc);
Var TempBuffer:Pointer;
BeginArray:Cardinal;
MidlVar:Pointer;
procedure QuickSort(L, R: Integer);
var
I, J: Integer;
begin
I :=L;
J :=R;
Move(Pointer(BeginArray +((((L+R-BeginArray-BeginArray) div len) shr 1)* len ))^,MidlVar^,Len);
repeat
while CompareProc(Pointer(I)^, MidlVar^) < 0 do
Inc(I,Len);
while CompareProc(Pointer(J)^, MidlVar^) > 0 do
Dec(J,len);
if I <= J then
begin
Move(Pointer(I)^,TempBuffer^,Len);
Move(Pointer(J)^,Pointer(I)^,Len);
Move(TempBuffer^,Pointer(J)^,Len);
Inc(I,Len);
Dec(J,Len);
end;
until I > J;
if L < J then
QuickSort(L,J);
if R>I then
QuickSort(I,R);
end;
Begin
GetMem(TempBuffer,2*Len);
MidlVar:=Pointer(Cardinal(TempBuffer)+len);
BeginArray:=PCardinal(@a)^;
QuickSort(BeginArray,BeginArray+(PCardinal(BeginArray-4)^-1)*len);
Dispose(TempBuffer);
End;
Procedure SortArray3(Var a; Len:Integer; CompareProc:TCompareProc;SwapProc:TSwapProc);
Var TempBuffer:Pointer;
BeginArray:Cardinal;
MidlVar:Pointer;
procedure QuickSort(L, R: Integer);
var
I, J: Integer;
begin
I :=L;
J :=R;
Move(Pointer(BeginArray +((((L+R-BeginArray-BeginArray) div len) shr 1)* len ))^,MidlVar^,Len);
repeat
while CompareProc(Pointer(I)^, MidlVar^) < 0 do
Inc(I,Len);
while CompareProc(Pointer(J)^, MidlVar^) > 0 do
Dec(J,len);
if I <= J then
begin// Move(Pointer(I)^,TempBuffer^,Len);
// Move(Pointer(J)^,Pointer(I)^,Len);
// Move(TempBuffer^,Pointer(J)^,Len);
SwapProc(Pointer(I)^,Pointer(J)^);
Inc(I,Len);
Dec(J,Len);
end;
until I > J;
if L < J then
QuickSort(L,J);
if R>I then
QuickSort(I,R);
end;
Begin
GetMem(TempBuffer,2*Len);
MidlVar:=Pointer(Cardinal(TempBuffer)+len);
BeginArray:=PCardinal(@a)^;
QuickSort(BeginArray,BeginArray+(PCardinal(BeginArray-4)^-1)*len);
Dispose(TempBuffer);
End;
end.
//=================================================Type
TType = packed record
d:Double;
b:Byte;
end;
function CmpDoubleByte(var item1, item2): Integer;
var
i1: TType absolute item1;
i2: Ttype absolute item2;
r: Double;
begin
r := i1.d-i2.d;
if (Abs(r) < 1.0E-100) then
Result := 0
else if (r < 0) then
Result := -1
else
Result := 1;
If Result:=0 Then
Begin
Result:=i1.B;
Dec(result,i2.B
end;
end;
Procedure SwapDoubleByte(Var Item1,Item2);
var I1:TType absolute Item1;
I2:TType absolute Item2;
Temp:TType;
Begin
Temp:=i1;
i1:=i2;
i2:=temp;
end;
///====================================================Var a:Array of TType;
begin//.................
SortArray3(a,SizeOf(TType),CmpDoubleByte,SwapDoubleByte);
// или
SortArray3(a,SizeOf(TType),CmpDoubleByte); // но в 2 раза медленнееend;
и солнце б утром не вставало, когда бы не было меня
Hello, DOOM!
You wrote on Mon, 08 Sep 2003 07:59:58 GMT:
DOO>>> Пожалуйста: WH>> Ага проверяем параметры и если не правильные то создаем частично WH>> инициализированый объект. Очень крутая логика.
D> Естественно дальше предполагалось кидать Exception
Тогда тут весь вопрос в том, что это за условия. Я лично вижу 2 варианта:
1) невыполнение условий не позволяет создать TAnotherClass. Ну и проверяем их в конструкторе TAnotherClass, при невыполнении — кидать Exception. Проверка их в TMyClass — нарушение инкапсуляции.
2) невыполнение условий не позволяет создать TMyClass. Создаем TAnotherClass, проверяем условия, принимаем решение о создании TMyClass. Отложенный вызов конструктора родителя не требуется.
Best regards,
Sergey.
Posted via RSDN NNTP Server 1.7 beta
Одним из 33 полных кавалеров ордена "За заслуги перед Отечеством" является Геннадий Хазанов.
.
А ведь сортировка это очень примитивный пример но и на нем пришлось ТАК извращаться.
Ну и кто еще после этого осмелится говорить что на дельфе писать проще?
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
.
WH>А ведь сортировка это очень примитивный пример но и на нем пришлось ТАК извращаться. WH>Ну и кто еще после этого осмелится говорить что на дельфе писать проще?
Не понял в чем сложность???? Обычный QuickSort. Что может быть легче?????
Прошу QuickSort на C++ и сравним.
и солнце б утром не вставало, когда бы не было меня
И вообще, в стандартной библиотеке более 50-ти функций для работы с
последовательостями. ПричTм эти последовательности могут быть любыми
(массив, vector, deque и т.д.), и этим функциям без разницы с элементами
какого типа (int, float, bool, class) они работают.
D> std::fill — готов поспорить из memcpy слеплена.
Ничего подобного.
AD>> Не забывай, что кроме std::vector в STL еще есть std::deque, AD>> std::list, std::map, std::stack, std::set и т.д. Что тебе нужно, то и
применяешь.
D> А в Дельфи есть еще TStack, TQueue и т.п.
Они наверное похожи на TList?
Я вообще не понимаю, зачем программист должен писать лишний код (например,
приведение типов, удаление объектов, постоянный try-finnaly), когда можно
обойтись и без этого. Мне например, платят не за размер кода, а за результат
работы, который выражается в том, что доволен или недоволен заказчик
программным продуктом.
Хехе чем то смахивает на пузырьковую сортироку. Просто мне стыдно такой алгоритм на Паскале писать. Уверяю Вас Нет ничего лешче переписть и по количеству кода будет индентичным
для пузырьковой сртировки без применения индексов зато бысрее на 30% (если смотреть ассемблерный код то доступ идет как АдрессМассива+индекс*размерЭлемента).
WH>А ведь сортировка это очень примитивный пример но и на нем пришлось ТАК извращаться. WH>Ну и кто еще после этого осмелится говорить что на дельфе писать проще?
. Кроме всего прочего данный код не разбухает от применения шаблонов (Copy-Paste-Replace);
И на 10 милионном массиве время сортировки массива интежеров 4.5 сек (на специальном алгоритме под массив интежеров 2 сек без применения индексов). А сколько на Вашем алгоритме???
Кроме всего пользовательский вызов ничем очень даже прост.
Ну а если для Вас это очень сложно, то .....
и солнце б утром не вставало, когда бы не было меня
Здравствуйте, Serginio1, Вы писали:
S> . Кроме всего прочего данный код не разбухает от применения шаблонов (Copy-Paste-Replace); S> И на 10 милионном массиве время сортировки массива интежеров 4.5 сек (на специальном алгоритме под массив интежеров 2 сек без применения индексов).
Афигеть. В два раза медленнее, зато код не разбухает. А если хочется в два раза быстрее — вперед copy-paste-replace, код так же разбухнет, но, в отличие от С++, заодно и исходник.
Чем ты там занимаешься, что размер бинарника настолько важнее скорости работы? Однократная инициализация таблицы в 64k intro на дельфи?
Здравствуйте, desperado_gmbh, Вы писали:
_>Здравствуйте, Serginio1, Вы писали:
S>> . Кроме всего прочего данный код не разбухает от применения шаблонов (Copy-Paste-Replace); S>> И на 10 милионном массиве время сортировки массива интежеров 4.5 сек (на специальном алгоритме под массив интежеров 2 сек без применения индексов).
_>Афигеть. В два раза медленнее, зато код не разбухает. А если хочется в два раза быстрее — вперед copy-paste-replace, код так же разбухнет, но, в отличие от С++, заодно и исходник.
_>Чем ты там занимаешься, что размер бинарника настолько важнее скорости работы? Однократная инициализация таблицы в 64k intro на дельфи?
Покажи код на С++. Это только маленький пример. Такого кода с размерными типами может набраться и поболее. А в два раза быстрее за счет не применения функции сравнения, но на 30% быстрее чем с применением индексов. Опять же давай сравним код шаблонов С++ и мой со сравнением по нескольким полям и вынесем на всеобщее обсуждение какой код сложнее. По моему легче не бывает.
И поясни "Однократная инициализация таблицы в 64k intro на дельфи".
и солнце б утром не вставало, когда бы не было меня
Здравствуйте, Serginio1, Вы писали:
S> Покажи код на С++.
Код уже лежит в vs2003\vc7\include\algorithm. Здесь я не даю make_heap, sort_heap — они вызываются для клинического случая, если quicksort тормозит. Еще нет всяких сервисных функций типа rotate и iter_swap.
В этом коде нет ни одной нетипизированной операции (CmpDoubleByte(var item1, item2) и absolute в твоем примере).
S> И поясни "Однократная инициализация таблицы в 64k intro на дельфи".
Есть такой жанр — 64k intros. В них действительно важнее размер кода, но про эффективность тоже нельзя забывать, поэтому такие в два раза более медленные решения годятся там разве что для однократного выполнения. А вот сэкономить несколько десятков и даже сотен килобайт бинарника в рендеринге или шахматах, замедлив работу в два раза, — смерти подобно.
// TEMPLATE FUNCTION sort WITH PREDtemplate<class _BidIt,
class _Pr> inline
void _Insertion_sort(_BidIt _First, _BidIt _Last, _Pr _Pred)
{ // insertion sort [_First, _Last), using _Predif (_First != _Last)
for (_BidIt _Next = _First; ++_Next != _Last; )
if (_Pred(*_Next, *_First))
{ // found new earliest element, rotate to front
_BidIt _Next1 = _Next;
std::rotate(_First, _Next, ++_Next1);
}
else
{ // look for insertion point after first
_BidIt _Dest = _Next;
for (_BidIt _Dest0 = _Dest; _Pred(*_Next, *--_Dest0); )
_Dest = _Dest0;
if (_Dest != _Next)
{ // rotate into place
_BidIt _Next1 = _Next;
std::rotate(_Dest, _Next, ++_Next1);
}
}
}
template<class _RanIt,
class _Pr> inline
void _Med3(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
{ // sort median of three elements to middleif (_Pred(*_Mid, *_First))
std::iter_swap(_Mid, _First);
if (_Pred(*_Last, *_Mid))
std::iter_swap(_Last, _Mid);
if (_Pred(*_Mid, *_First))
std::iter_swap(_Mid, _First);
}
template<class _RanIt,
class _Pr> inline
void _Median(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
{ // sort median element to middleif (40 < _Last - _First)
{ // median of nineint _Step = (_Last - _First + 1) / 8;
_Med3(_First, _First + _Step, _First + 2 * _Step, _Pred);
_Med3(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
_Med3(_Last - 2 * _Step, _Last - _Step, _Last, _Pred);
_Med3(_First + _Step, _Mid, _Last - _Step, _Pred);
}
else
_Med3(_First, _Mid, _Last, _Pred);
}
template<class _RanIt,
class _Pr> inline
pair<_RanIt, _RanIt> _Unguarded_partition(_RanIt _First, _RanIt _Last,
_Pr _Pred)
{ // partition [_First, _Last), using _Pred
_RanIt _Mid = _First + (_Last - _First) / 2;
_Median(_First, _Mid, _Last - 1, _Pred);
_RanIt _Pfirst = _Mid;
_RanIt _Plast = _Pfirst + 1;
while (_First < _Pfirst
&& !_Pred(*(_Pfirst - 1), *_Pfirst)
&& !_Pred(*_Pfirst, *(_Pfirst - 1)))
--_Pfirst;
while (_Plast < _Last
&& !_Pred(*_Plast, *_Pfirst)
&& !_Pred(*_Pfirst, *_Plast))
++_Plast;
_RanIt _Gfirst = _Plast;
_RanIt _Glast = _Pfirst;
for (; ; )
{ // partitionfor (; _Gfirst < _Last; ++_Gfirst)
if (_Pred(*_Pfirst, *_Gfirst))
;
else if (_Pred(*_Gfirst, *_Pfirst))
break;
else
std::iter_swap(_Plast++, _Gfirst);
for (; _First < _Glast; --_Glast)
if (_Pred(*(_Glast - 1), *_Pfirst))
;
else if (_Pred(*_Pfirst, *(_Glast - 1)))
break;
else
std::iter_swap(--_Pfirst, _Glast - 1);
if (_Glast == _First && _Gfirst == _Last)
return (pair<_RanIt, _RanIt>(_Pfirst, _Plast));
if (_Glast == _First)
{ // no room at bottom, rotate pivot upwardif (_Plast != _Gfirst)
std::iter_swap(_Pfirst, _Plast);
++_Plast;
std::iter_swap(_Pfirst++, _Gfirst++);
}
else if (_Gfirst == _Last)
{ // no room at top, rotate pivot downwardif (--_Glast != --_Pfirst)
std::iter_swap(_Glast, _Pfirst);
std::iter_swap(_Pfirst, --_Plast);
}
else
std::iter_swap(_Gfirst++, --_Glast);
}
}
template<class _RanIt,
class _Diff,
class _Pr> inline
void _Sort(_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
{ // order [_First, _Last), using _Pred
_Diff _Count;
for (; _ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal; )
{ // divide and conquer by quicksort
pair<_RanIt, _RanIt> _Mid =
_Unguarded_partition(_First, _Last, _Pred);
_Ideal /= 2, _Ideal += _Ideal / 2; // allow 1.5 log2(N) divisionsif (_Mid.first - _First < _Last - _Mid.second) // loop on larger half
_Sort(_First, _Mid.first, _Ideal, _Pred), _First = _Mid.second;
else
_Sort(_Mid.second, _Last, _Ideal, _Pred), _Last = _Mid.first;
}
if (_ISORT_MAX < _Count)
{ // heap sort if too many divisions
std::make_heap(_First, _Last, _Pred);
std::sort_heap(_First, _Last, _Pred);
}
else if (1 < _Count)
_Insertion_sort(_First, _Last, _Pred); // small, insertion sort
}
template<class _RanIt,
class _Pr> inline
void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
{ // order [_First, _Last), using _Pred
_Sort(_First, _Last, _Last - _First, _Pred);
}
Здравствуйте, Serginio1, Вы писали:
S>Хехе чем то смахивает на пузырьковую сортироку.
Я же сказал мне лень. S>Просто мне стыдно такой алгоритм на Паскале писать.
Ой какие мы надменные. S>Уверяю Вас Нет ничего лешче переписть и по количеству кода будет индентичным
Ты дурочку не валяй. Та прекрасно понимаешь о чем я.
S> Еще раз очень хочется посмотреть на QuickSort в шаблонах C++ и сравнить с http://www.rsdn.ru/Forum/Message.aspx?mid=377407&only=1
template<class Iter, class Cmp>
void qsort_sort(Iter begin, Iter end, const Cmp& cmp)
{
std::iterator_traits<Iter>::value_type midl=*(begin+(end-begin)/2);
Iter begin_=begin;
Iter end_=end;
--end_;
do
{
while(cmp(*begin_, midl)&&(begin_<=end_))
++begin_;
while(cmp(midl, *end_)&&(begin_<=end_))
--end_;
if(begin_<=end_)
{
std::iter_swap(begin_, end_);
++begin_;
--end_;
}
}while(begin_<end_);
++end_;
if(begin<end_)
qsort_sort(begin, end_, cmp);
if(begin_<end)
qsort_sort(begin_, end, cmp);
}
template<class Iter>
void qsort_sort(Iter begin, Iter end)
{
qsort_sort(begin, end, std::less<std::iterator_traits<Iter>::value_type>());
}
S> . Кроме всего прочего данный код не разбухает от применения шаблонов (Copy-Paste-Replace);
И кого это волнует? S> И на 10 милионном массиве время сортировки массива интежеров 4.5 сек (на специальном алгоритме под массив интежеров 2 сек без применения индексов). А сколько на Вашем алгоритме???
А это смотря на какой тачке. На работе 2.5, а дома я так думаю быстрее раза в два будет.
AD>Мне например, платят не за размер кода, а за результат работы, который выражается в том, что доволен или недоволен AD>заказчик программным продуктом.
Вот именно! Главное программный продукт. И вот тут-то получается, что на Delphi быстрее и надежнее.Несмотря на все template, smartpointer и т.д.
Я не хочу вдаваться в полемику . Скажу одно в Delphi нет Inline, нет Шаблонов нет перегрузки операторов. Плохо, но есть много много другого. Кроме всего прочего эти препятствия легко обходятся. Мой пример тому доказательство (меня просили показать я показал). По поводу типизации ее легко сделать обвернув код одной типизированной функцией, но так как код достоверен то применение небезопасного кода оправдано. По поводу повторенного тобой скорости в 2 раза это относится только к Интежерам он особый тип, ко всем другим типам эта разница будет практически сведена к 0.
Опять же повторюсь мне намного больше нравится Net чем Native языки.
Там по поводу шаблонов идут поиски, перегрузка операторов тоже не такая огульная, зато продуманность классов и структур во много раз выше.
И в итоге скажу главное уметь программировать а на чем не важно.
Я голосую за Net (в том числе С# и Delphi.Net). А там сортировка массива встроена в сам объект Array.
и солнце б утром не вставало, когда бы не было меня
Здравствуйте, Serginio1, Вы писали:
S> Опять же повторюсь мне намного больше нравится Net чем Native языки. S> Там по поводу шаблонов идут поиски, перегрузка операторов тоже не такая огульная, зато продуманность классов и структур во много раз выше.
Вот с появлением generics в .NET и отпадут проблемы, аналогичные дельфийским: 17 классов System.Data.Common.XXXStorage, почти копия System.Collections.Hashtable в System.Windows.Forms.NativeWindow (хранить забоксенные хэндлы окон накладно), постоянные реализации с нуля наследников ICollection и IList (только в System.Windows.Forms.ListView их шесть штук), четыре копии двоичного поиска в System.Windows.Forms (Menu.FindMergePosition, PropertyStore.LocateIntegerEntry, PropertyStore.LocateObjectEntry и TreeNode.AddSorted) и бессчетное повторение линейного поиска, бесконечные if(array.Length = count){T[] newarray = new T[2*count];Array.Copy(array, 0, newarray, 0, count;array = newarray;} там, где не устраивает производительность ArrayList.
S> Я голосую за Net (в том числе С# и Delphi.Net). А там сортировка массива встроена в сам объект Array.
Там она именно такая, как у тебя на дельфи — на виртуальном вызове.
Здравствуйте, Serginio1, Вы писали:
S> Ну а если для Вас это очень сложно, то .....
ДА!!! Понтов-то, понтов... А я например в своей программе использую множество различных массивов с разными типами данных и мне надо сортировать их. Я так понимаю, что нормальным подходом для тебя будет использование твоего собственного примера скоприванного в 10ке вариантах. И в каждом варианте путем замены ты будешь править тип данных. Когда же код достигнет внушительных размеров и сотен файлов, то при обнаружении ошибки в алгоритме сортировки ты будешь лопатить файлы в поисках этих копий алгоритма с целью исправления ошибки. Если это так тебе нравится то наверно тебе не нужны шаблоны.
Что касается сортировки, то это просто элементарный пример, а вот что ты скажешь если придется писать например какой нить интерпритатор но не только для тривиального посимвольного текста, а например для какого нить потока данных где атомом является нечто более сложное, чем символ. Да к примеру хотябы слово или предложение, а затем более крупные единици. Во всех случаях возможно использовать один алгоритм, но типы данных разные. При последовательном применении данных анализаторов к тексту можно получить весьма сильные вещи, да и в случае ошибок их не придется искать в каждом отдельном случае. Вот я бы посмотрел на твой код при размере алгоритма > 500 строк и количестве модулей больше 5ти.
ЗЫ Я не раз видел подобные решения при задачах типа уравнений мат физики, которые реализовывались для нескольких типов данных одновременно. ИЗВРАТ.
Здравствуйте, LaptevVV, Вы писали:
LVV>Здравствуйте, DOOM, Вы писали:
DOO>>Теперь ваща очередь... LVV> Давайте не путать язык, компилятор и IDE. LVV>1. Язык. С++ ИМНО богаче будет. Как раз за счет перегрузки операций и шаблонов. В остальном ИМХО — совпадают. LVV>Но!!! STL, как ни крути, стандарт С++! до чего Дельфям топать и топать. LVV>2. IDE — ИМХО дело вкуса. LVV>3. Компилер — тут, без сомнения, дельфи по скорости давит все с++компилеры.
LVV>Кто возразит?
Дык их сравнивать нельзя в дельфе компилятор однопроходной, а в C++ двухпроходной...
Поэтому в делфе и можно абстрактные классы создавать, это костыль для имитирования поддержки ООП.
В этом плане паскаль вообще пример еще тот, так как все механизмы ООП в него "вдавливали", кто во что горазд... т.к. стандарта языка не было.
Procedure SortArray3(Var a; Len:Integer; CompareProc:TCompareProc;SwapProc:TSwapProc);
Var TempBuffer:Pointer;
BeginArray:Cardinal;
MidlVar:Pointer;
procedure QuickSort(L, R: Integer);
var
I, J: Integer;
begin
I :=L;
J :=R;
// Move(Pointer(BeginArray +((((L+R-BeginArray-BeginArray) div len) shr 1)* len ))^,MidlVar^,Len);
// Спасибо четого с мозгами стало, но проверь у себя на невыровненных данных по 4
Move(Pointer(L+(((R-l) div len) shr 1)*len)^,MidlVar^,Len);
repeat
while CompareProc(Pointer(I)^, MidlVar^) < 0 do
Inc(I,Len);
while CompareProc(Pointer(J)^, MidlVar^) > 0 do
Dec(J,len);
if I <= J then
begin
SwapProc(Pointer(I)^,Pointer(J)^);
Inc(I,Len);
Dec(J,Len);
end;
until I > J;
if L < J then
QuickSort(L,J);
if R>I then
QuickSort(I,R);
end;
Begin
GetMem(TempBuffer,2*Len);
MidlVar:=Pointer(Cardinal(TempBuffer)+len);
BeginArray:=PCardinal(@a)^;
QuickSort(BeginArray,BeginArray+(PCardinal(BeginArray-4)^-1)*len);
Dispose(TempBuffer);
End;
end.
не в Моем примере было
Type
TType = packed record
d:Double;
b:Byte;
end;
function CmpDoubleByte(var item1, item2): Integer;
var
i1: TType absolute item1;
i2: Ttype absolute item2;
r: Double;
begin
r := i1.d-i2.d;
if (Abs(r) < 1.0E-100) then
Result := 0
else if (r < 0) then
Result := -1
else
Result := 1;
If Result:=0 Then
Begin
Result:=i1.B;
Dec(result,i2.B
end;
end;
Procedure SwapDoubleByte(Var Item1,Item2);
var I1:TType absolute Item1;
I2:TType absolute Item2;
Temp:TType;
Begin
Temp:=i1;
i1:=i2;
i2:=temp;
end;
WH>///==================================================== WH>Var a:Array of TType; WH>begin WH>//................. WH> SortArray3(a,SizeOf(TType),CmpDoubleByte,SwapDoubleByte);
WH>end; WH>[/pascal] WH>и WH>
WH>>>Ты от ответа не уходи ты функцию напиши.
M>>TList.Sort — вот эта функция.
WH>Ты ручками сортировку написать можешь?
А зачем писать сам алогритм сортировки? Ты что, сомневаешься, что TList.Sort правильно сортирует?
Смысл этого примера в том, что компаратор (указатель на функцию сортировки) передаётся в метод TList.Sort, который при помощи компаратора сортирует список.
Type
TMyComparableObj = class
private
i: integer;
end;
functionCompareObjects(Item1, Item2: Pointer): Integer;
begin
Result := CompareValue((Item1 as TMyComparableObject).i, (Item1 as TMyComparableObject).i);
end;
var List1: TList;
begin
List1:=TList.Create;
// заполнение List1...
List1.Sort(@CompareObjects)
end.
Здравствуйте, DrMom, Вы писали:
DM>Здравствуйте, Serginio1, Вы писали:
S>> Ну а если для Вас это очень сложно, то .....
DM>ДА!!! Понтов-то, понтов... А я например в своей программе использую множество различных массивов с разными типами данных и мне надо сортировать их. Я так понимаю, что нормальным подходом для тебя будет использование твоего собственного примера скоприванного в 10ке вариантах. И в каждом варианте путем замены ты будешь править тип данных. Когда же код достигнет внушительных размеров и сотен файлов, то при обнаружении ошибки в алгоритме сортировки ты будешь лопатить файлы в поисках этих копий алгоритма с целью исправления ошибки. Если это так тебе нравится то наверно тебе не нужны шаблоны.
DM>Что касается сортировки, то это просто элементарный пример, а вот что ты скажешь если придется писать например какой нить интерпритатор но не только для тривиального посимвольного текста, а например для какого нить потока данных где атомом является нечто более сложное, чем символ. Да к примеру хотябы слово или предложение, а затем более крупные единици. Во всех случаях возможно использовать один алгоритм, но типы данных разные. При последовательном применении данных анализаторов к тексту можно получить весьма сильные вещи, да и в случае ошибок их не придется искать в каждом отдельном случае. Вот я бы посмотрел на твой код при размере алгоритма > 500 строк и количестве модулей больше 5ти.
DM>ЗЫ Я не раз видел подобные решения при задачах типа уравнений мат физики, которые реализовывались для нескольких типов данных одновременно. ИЗВРАТ.
Был поставлен вопрос. Дано решение http://www.dotsite.ru/Publications/PublicationDetails.aspx?ID=115
И слабо отличающийся по коду от шаблонов С++
Будет следующий вопрос тоже будет найдено решение вплоть до генерации исходного кода.
Но опять же повторюсь пока нет шаблонов в Delphi и Inline , перегрузки и что помирать что ли. Зачем переходить на С++ может лучше на С#. Borland выйдет в конце года с новыми решениями как в Net так и в Native компилятором. Все идет все меняется.
А насчет "понтов " это ответ на аналогичные высказывания по теме выше, не относящиеся к ВАМ лично.
и солнце б утром не вставало, когда бы не было меня
