С# - Delphi

← →
novichek (2014-03-13 13:16) [0]

помогите пожалуйста перевести код на дельфи:

в с#

private int[] ParseKey(string key) { int result = 0; int length = key.Length; int num3 = 8; List<int> list = new List<int>(5); for (int i = 0; i < length; i += 8) { if ((i + 8) > length) { num3 = key.Length - i; } string s = key.Substring(i, num3); if (int.TryParse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out result)) { list.Add(result); } else { for (int j = 0; j < s.Length; j++) { result = s[j++]; if (j < s.Length) { result |= s[j] << 0x10; } list.Add(result); } } } return list.ToArray(); }
в VB

Private Function ParseKey(ByVal key As String) As Integer() Dim result As Integer = 0 Dim length As Integer = key.Length Dim num3 As Integer = 8 Dim list As New List(Of Integer)(5) Dim i As Integer = 0 Do While (i < length) If ((i + 8) > length) Then num3 = (key.Length - i) End If Dim s As String = key.Substring(i, num3) If Integer.TryParse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture, result) Then list.Add(result) Else Dim j As Integer For j = 0 To s.Length - 1 result = s.Chars(j++) If (j < s.Length) Then result = (result Or (s.Chars(j) << &H10)) End If list.Add(result) Next j End If i = (i + 8) Loop Return list.ToArray End Function

← →
Rouse_ © (2014-03-13 20:37) [1]

Помогите - это за деньги.
Мошт подсказать с непонятными моментами?

← →
novichek (2014-03-13 20:44) [2]

- List<int> list = new List<int>(5);
я так понимаю тут фиксированный размер в 5 элементов массива?

- result = s[j++];
это s[j+1] ?

чисто для проверки, не думая про оптимизацию и т.п. набросал:

myArray = array of Integer;

function ParseKey(key: String): myArray;
var
_result: Integer;
_length: Integer;
_num3 : Integer;

i: Integer;
s: String;
j: Integer;

lenResult: Integer;

procedure addResult(val: Integer);
begin
inc(lenResult);
SetLength(result, lenResult);
result[lenResult-1]:= val;
end;

begin

lenResult:= 0; _num3:= 8;
_length:= system.Length(key);
i:= 0;
while i < _length do begin

if ( (i + 8) > _length) then _num3 := _Length - i;

s:= system.Copy(key, i, _num3);
_result:= StrToIntDef("$"+s, -1);

if (_result <> -1) then addResult(_result)
else begin

for j:= 1 to s.Length - 1 do begin

_result := ord(s[j+1]);

if (j < s.Length) then _result:= _result or ord(s[j]) shl 16;

addResult(_result);
end;
end;

i:= i + 8;
end;

end;

где-то так?

← →
Ega23 © (2014-03-13 21:06) [3]

> - List<int> list = new List<int>(5);
> я так понимаю тут фиксированный размер в 5 элементов массива?
>

Это не массив, это дженерик-лист.
var list: TList<Integer>; begin list := TList<Integer>.Create; try list.Capacity := 5; .... finally list.Free; end; end;

procedure addResult(val: Integer); begin inc(lenResult); SetLength(result, lenResult); result[lenResult-1]:= val; end;

Это - лишнее, да и неправильно.

← →
novichek (2014-03-13 21:24) [4]

спасибо, пришло время столкнуться с дженериками. пошел гуглить.

и с циклом что-то не могу разобраться

for (int j = 0; j < s.Length; j++)
{
result = s[j++];

если у них строка с 0, то s[j++] если я понимаю это [j+1] куда будет ссылаться при j = s.Length - 1 ?

← →
Inovet © (2014-03-13 21:30) [5]

> [4] novichek (13.03.14 21:24)

Это потом +1 будет, а так перед ++j

← →
novichek (2014-03-13 21:44) [6]

простите, вообще запутался )

result = s[j++]; как будет на дельфи?

← →
Inovet © (2014-03-13 22:00) [7]

result = s[j];
Inc(j);

← →
Ega23 © (2014-03-13 22:08) [8]

for (int j = 0; j < s.Length; j++) { result = s[j++];

Вот за такие дела я и не люблю "квази-труъ-сишный стиль".
Зачем такие бубенца выдавать?

← →
Юрий Зотов © (2014-03-13 22:33) [9]

> novichek (13.03.14 21:44) [6]
result = s[j++]; как будет на дельфи?

j++ означает: сначала использовать текущее значение j, затем увеличить j.
На Delphi это так: result = s[j]; j := j+1;

++j означает: сначала увеличить j, затем использовать текущее значение j.
На Delphi это так: j := j+1; result = s[j];

Но странно другое:
for (int j = 0; j < s.Length; j++) { result = s[j++]; ... }

Здесь счетчик цикла изменяется внутри самого цикла - фактически, цикл выполняется с шагом 2. Во-первых, это похоже на ошибку. Но даже если это не ошибка и даже если компилятор такое допускает, я бы так писать не стал, а использовал бы цикл while с явным увеличением на 2.

← →
Ega23 © (2014-03-13 22:43) [10]

> Во-первых, это похоже на ошибку. Но даже если это не ошибка
> и даже если компилятор такое допускает, я бы так писать
> не стал, а использовал бы цикл while с явным увеличением
> на 2.

Вот вроде бы не ошибка. Я, правда, жутко спать хочу и особо не вникал. Но то, что так писать низзя - это да.

← →
novichek (2014-03-13 22:44) [11]

код такой показал net reflector )

а насчет дженерика, подскажите, не могу понять что такое всё же Capacity
и чем оно отличается от Count ?

данная строка return list.ToArray();

всё - таки вернет динамический массив array of Integer ?

← →
Юрий Зотов © (2014-03-13 23:08) [12]

> novichek (13.03.14 22:44) [11]
> что такое всё же Capacity и чем оно отличается от Count ?

Capacity - сколько элементов МОЖЕТ поместиться в списке
Count - сколько элементов УЖЕ есть в списке.

Например, list.Capacity := 5 выделяет память под 5 элементов списка, но при этом Count может быть и меньше 5. Вот аналогия: полка, на которой может поместиться 5 книжек, но на самом деле их там меньше 5.

Так сделано для более эффективной работы с памятью.

← →
Inovet © (2014-03-13 23:23) [13]

> [10] Ega23 © (13.03.14 22:43)
> Вот вроде бы не ошибка.

Ну. Там сначала забираем, потом увеличиваем, потом что-то там делаем и ещё раз увеличиваем. Мозг с трудом осиливает задумку.

← →
novichek (2014-03-13 23:29) [14]

Юрий Зотов, очень доходчиво, спасибо.

последний вопрос, при добавлении элементов я должен корректировать Capacity ?

← →
Ega23 © (2014-03-13 23:31) [15]

> а насчет дженерика, подскажите, не могу понять что такое
> всё же Capacity
> и чем оно отличается от Count ?

Count - сколько элементов реально помещено в список.
Capacity - вместимость, сколько элементов может быть помещено в список, разовое выделение памяти под массив элементов.

← →
Юрий Зотов © (2014-03-13 23:51) [16]

> novichek (13.03.14 23:29) [14]

> последний вопрос

Never say "never".
;o)

> при добавлении элементов я должен корректировать Capacity ?

Не знаю, как там в Шарпе и в современных Дельфях, а в Джаве - не должен. То есть - можно, но не обязательно. Элементы добавляются методом Add, а он сам все корректирует, если надо. Почти уверен, что и в Шарпе, и в современных Дельфях сделано так же. ЕМНИП, и в старых Дельфях список TList тоже так устроен.

Но полагаться на Add не всегда эффективно. Если мы точно (или хотя бы более-менее точно) знаем, сколько элементов мы собираемся добавить, то лучше сразу увеличить Capacity именно на это число, а уж потом добавлять элементы. Так мы можем избежать многократного перераспределения памяти. Понятно, что метод Add о наших планах не знает ничего и поэтому не может сработать так же хорошо, как программист.

← →
Плохиш © (2014-03-14 01:59) [17]

> а насчет дженерика, подскажите, не могу понять что такое
> всё же Capacity
> и чем оно отличается от Count ?
>

Capacity - начальное резервирование памяти, в данном случае для 5 элементов.
Count - действительное количество элементов.

> данная строка return list.ToArray();
>
> всё - таки вернет динамический массив array of Integer ?

А что есть сомнения?

PS. Неужели в справке не написаны ответы?

← →
clickmaker © (2014-03-14 09:50) [18]

я так подозреваю, что List и последующие увеличения памяти производит на Capacity, а не по одному на каждый Add

← →
MBo © (2014-03-14 10:31) [19]

>clickmaker
Если речь о дельфийском TList - то почти так, при необходимости расширяется на четверть Capacity (не уверен, что так же было в старых версиях, возможно, там на 16 всегда увеличение шло)

← →
Юрий Зотов © (2014-03-14 10:40) [20]

> clickmaker © (14.03.14 09:50) [18]

Конечно не на один (иначе бы и смысла не было). Но и не на Capacity, насколько помню. Там есть еще один параметр (название не помню, что то типа "приращение") - вот он и определяет, на сколько элементов Add должен увеличивать Capacity по дефолту.

> Если речь о дельфийском TList - то почти так, при необходимости
> расширяется на четверть Capacity (не уверен, что так же
> было в старых версиях, возможно, там на 16 всегда увеличение
> шло)

4 - 16 - 64 - далее на четверть от текущего. ЕМНИП.

На Capacity как-то жирно было бы.

> На Capacity как-то жирно было бы.

procedure TList.Grow; var Delta: Integer; begin if FCapacity > 64 then Delta := FCapacity div 4 else if FCapacity > 8 then Delta := 16 else Delta := 4; SetCapacity(FCapacity + Delta); end;

Но Grow - виртуальный, можешь перекрыть под свою задачу.

хм... ради прикола глянул, как в дотнете

private void EnsureCapacity(int min) { if (this._items.Length < min) { int num = (this._items.Length == 0) ? 4 : (this._items.Length * 2); if (num < min) { num = min; } this.Capacity = num; } }

В STL для vector
else if (_Capacity < size() + _Count) { // not enough room, reallocate _Capacity = max_size() - _Capacity / 2 < _Capacity ? 0 : _Capacity + _Capacity / 2; // try to grow by 50% if (_Capacity < size() + _Count) _Capacity = size() + _Count;

← →
novichek (2014-03-14 20:25) [26]

Юрий Зотов, вот точно Never say "never" :)

помогите пожалуйста ещё одну процедурку переписать на дельфи.

internal static unsafe void modopt(CallConvStdcall) test(byte* array, int length, int* key, int keyLength)

непонятны вот эти строки в ней по нарастающей непонятности:

num5 = num[(int) key]
// это num5:= key[num] ?
..
ushort num4 = *((ushort*) ((num2 * 2) + array));
num4:= array[num2 * 2] если array брать integer ?
..
(num2 * 2)[(int) array] = (num4 >> ((ushort) (0x10 - num5))) | ((ushort) (num4 << num5));

то же как Integer array[num2 * 2]:= (num4 shr Word($10 - num5)) or Word(num4 shl num5); ?

голова кипит от такого кода..

← →
novichek (2014-03-15 02:18) [27]

прошу прощения - разобрался.
ужасный язык

Удалено модератором

← →
jack128_ (2014-03-15 13:05) [29]

> ужасный язык

LOL. Декомпилированный код разбираешь и на язык жалуешься.

С# - Delphi Найти похожие ветки