Помощь новичкам

#887

Проверку можно сделать отдельно. Чтоб она проверялась 1 а не 20 (10 раз доступ * 2 проверки, нижняя и верхняя граница):

begin
  var a := new integer[10];
  var n := ReadInteger('Пожалуйста, не вводите число большее 10: ');
  if n > 10 then raise new Exception;
  {$arrptr a}
  {$arrptr for i in a}//это типо значит, что для "a" мы создаём здесь указатель и следующий цикл вместе с изменением "i" будет прибавлять 1 к тому указателю
  for var i:= 0 to n-1 do
    a[i] := i;
end.

Ожидается, что это развернётся во что то такое (конечно, в паскале нет fixed, поэтому это псевдокод)

begin
  var a := new integer[10];
  var n := ReadInteger('Пожалуйста, не вводите число большее 10: ');
  if n > 10 then raise new Exception;
  fixed a do//{$arrptr a}
  begin
    var ptr := @a[0]//{$arrptr for i in a}
    for var i:= 0 to n-1 do
    begin
      ptr^ := i;
      ptr += 1;
    end;
  end;
end.
1 лайк
#888

Ваша идея очень интересная, но всё же было бы проще ввести сначала fixed. Но мне кажется, что в Паскале массивы по умолчанию fixed.

#889

Можно и тут. :smile:

#890

Что за “Дополнительные файлы” в установщике новой сборки?

#891

Предполагается, что там будут все, которые не основные

#892

Если запускать exe’шку как 32-битный процесс, то доступная процессу память будет всегда ограничена ~2ГБ даже на 64-битных ОС. В случае с .NET это делается путем изменения 1 флага в CLR заголовке файла с помощью команды:

CorFlags.exe YourProgram.exe /32BIT+

Имейте в виду, что эта операция нарушает цифровую подпись файла (если она была), и в таком случае файл запускаться перестанет. Но все легко обратимо:

CorFlags.exe YourProgram.exe /32BIT-

А для отладки утечек или для запуска приложения с принудительно ограниченным объемом доступной памяти есть пока уникальная для Windows тулза (и что удивительно, написана она не на C или C++, а на C# с доступом к нативным функциям WinAPI):

Болталка PascalABC.NET
#893

А по какому критерию отделяются основные от не основных?

#894

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

1 лайк
#895 
begin
  var l := Lst(3, 4);
  Swap(l[0], l[1]);// Данный объект не может быть передан как var-параметр
  l.Println;
end.

а почему? и что делать? хотелось бы процедурой

#896

Свойства нельзя передавать как var-параметры

1 лайк
#897

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

type
  t1=class
    property prop1:integer
    read Random(10)
    write writeln(value);
  end;

begin
  var a := new t1;
  writeln(a.prop1);
  a.prop1 := 4;
end.

Или основывать на разных переменных:

type
  t1=class
    i1,i2:integer;
    
    property prop1:integer
    read i1
    write i2;
  end;

begin
  var a := new t1;
  writeln(a.prop1);
  a.prop1 := 4;
end.

В этом случае то что получили из a.prop1 и то куда отослалось 4 - имеют разные адреса в памяти.

А передача через var-параметр - это создания указателя на переданные вами переменные.

То есть это:

procedure MySwap(var i1:integer; var i2:integer);
begin
  var temp := i1;
  i1 := i2;
  i2 := temp;
end;

begin
  var i1 := 5;
  var i2 := 6;
  MySwap(i1,i2);
end.

Заменяется на что то типа следующего (правда, указатели используются более низкоуровневые чем в паскале):

procedure MySwap(i1:^integer; i2:^integer);
begin
  var temp := i1^;
  i1^ := i2^;
  i2^ := temp;
end;

begin
  var i1 := 5;
  var i2 := 6;
  MySwap(@i1,@i2);
end.

Из за того что у свойств значение не обязательно читаются и записывается в одинаковое место в памяти - они не совместимы с var-параметрами.



Что касается “и что делать?” - есть несколько вариантов. Если вам нет дела до производительности - можно использовать картежное присвоение:

begin
  var l := Lst(3, 4);
  (l[0], l[1]) := (l[1], l[0]);
  l.Println;
end.

Это разворачивается в следующее:

begin
  var l := Lst(3, 4);
  var t := Tuple.Create(l[1], l[0]);
  l[0] := t.Item1;
  l[1] := t.Item2;
  l.Println;
end.

Если же вам важна производительность - то только ручками писать:

begin
  var l := Lst(3, 4);
  
  var temp := l[1];
  l[1] := l[0];
  l[0] := temp;
  
  l.Println;
end.

Если так уж не хотите засирать высокоуровневый код переменной temp и всё же хотите процедурой - делайте как то так:

procedure SwapFirst2(l:List<integer>);
begin
  var temp := l[1];
  l[1] := l[0];
  l[0] := temp;
end;

begin
  var l := Lst(3, 4);
  SwapFirst2(l);
  l.Println;
end.

Или более универсальное:

procedure SwapElements<T>(l:IList<T>; i1,i2:integer);
begin
  var temp := l[i2];
  l[i2] := l[i1];
  l[i1] := temp;
end;

begin
  var l := Lst(3, 4);
  SwapElements(l,0,1);
  l.Println;
end.

Ну и, конечно, его промежуточные по универсальности варианты. Что использовать - зависит только от того что вам нужно.

1 лайк
#898

Кто может посоветовать материалы по оптимизации приложений с использованием хэша процессора?

#899

Ребят, че-то я не соображу, а как сделать массив массивов?

т.е. типа:

int[][] masivikus = 
{
    new int[] {1,2,3,4,5},
    new int[] {1,2,3,4},
    new int[] {1,2,5,6,76,7,8,9,9,9}
};

где masivikus[2,2] будет равен 2

#900 
var masivikus: array of array of integer := (
  (1,2,3,4,5),
  (1,2,3,4),
  (1,2,5,6,76,7,8,9,9,9)
);

Недавно исправили баг где такая инициализация не правильно работала, поэтому обновитесь.

1 лайк
#901

array of array of Int32

или

array [,] of Int32

для прямоугольного. Сергей опередил :wink:

#902

понял, спасибо :slight_smile:

#903 
var массив := new array of array of Int32[3];
массив[0] := new Int32[5];
массив[1] := new Int32[4];
массив[2] := new Int32[10];

Заполнять так:

массив[][] := ...
1 лайк
#904

при таком объявлении, что-то не пашет, Серегин вариант работает.

#905

Нет, так не сработает, внешний массив только через SetLength, если не инициализировать всё сразу.

И кроме того, вы не правильно написали. Если через такую запись - new array of integer[3], это должно было бы создать массив массивов, но почему то не работает.

#906

Нет, ну можно ещё так:

begin
  var массив: array of array of integer;
  SetLength(массив,3);
  массив[0] := new integer[5];
  массив[1] := new integer[4];
  массив[2] := new integer[10];
end.