Delphi 7 по сравнению с 2009 г. (и 2010 г.) Рекордные размеры

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

Если значения по умолчанию для заполнения байтов изменились между Delphi 7 и Delphi 2009, выясните, какие значения по умолчанию были в D7, и установите те же значения по умолчанию в Delphi 2009.

Также проверьте упаковку массива по умолчанию. Не помню, есть ли для этого отдельная настройка.

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

Если ничего из этого не помогает, создайте временный тип упакованной записи в D2009 и вручную вставьте поля байтового заполнения между фактическими полями данных до тех пор, пока размер записи и выравнивание полей не будут соответствовать макету D7. Дело не только в размере, это в выравнивании полей. Прочтите ваш старый файл данных, используя эту временную упакованную запись. Затем перенесите данные поле за полем в ваш «настоящий» тип записи в D2009 и запишите новый файл.

И пока вы это делаете, упакуйте этот тип записи в D2009, чтобы этого больше не повторилось.

Я считаю, что вы попали в функцию!. Я не смог получить разумный размер вашего TToTry с D2007, поэтому мне пришлось искать адреса полей с помощью отладчика;

Во-первых, размер записи ниже,

{$A8}
type
  TToTry = record
    j: array[1..3] of Extended;
    k: array[1..3] of Extended;
    l: array[1..3] of Extended;
    m: array[1..3] of Extended;
  end;

равно 128 (32 * 4). Это ожидается, поскольку Extended составляет 10 байтов, 30 байтов будут выровнены по 32 байтам.

Но размер этой записи,

{$A8}
type
  TToTry = record
    j, k, l, m: array[1..3] of Extended;
  end;

равно 120 (30 * 4). Это определенно неожиданно - поля все равно должны быть выровнены по 8-байтовой границе.

(У меня нет D7 для проверки, но я так думаю :)
Итак, теперь мы знаем, что сгруппированные поля упакованы, из этого следует, что выравнивание на D7 составляет 8 байтов, а ваша запись почти упакована;

TToTry = Record 
 a,b,c,d : Extended;    // 40 bytes (8*5)
 e,f,g,h : Extended;    // 40 bytes (8*5)
 i : String[15];        // 16 bytes (8*2)
 j,k,l,m,n,o,p,q,r,s,t: Array[1..3] of Extended; // 330 bytes
End; 

Компилятор добавляет 6 байтов к последней группе, чтобы она была кратна 8, и тогда вы получите 40 + 40 + 16 + 336 = 432 байта.

В D2009 / D2010 вы либо объявляете каждое поле - без их группировки, либо поведение изменяется. В любом случае упакуйте свою запись и добавьте в конец фиктивное поле массива из 6 байтов, и все будет в порядке.

Если это не сработает, посмотрите адреса полей вашей записи с помощью D7, затем создайте точный дубликат на D2009, используя упакованную запись и при необходимости используя фиктивные поля, после того как вы импортировали сохраненные данные, вы можете удалить фиктивные поля. .

-
Я никогда не сталкивался с таким поведением и нигде не могу найти его документально. Тем не менее, это настолько похоже на функцию, что я не решаюсь назвать это ошибкой. Я не знаю, как обстоят дела с D2009 или D2010, проверьте, так ли это. Если это так, чтобы получить ожидаемые результаты - не иметь наполовину упакованных записей - не поленитесь и объявляйте каждое поле отдельно для незапакованных записей.

Я знаю, что это старый пост, но вчера я столкнулся с той же проблемой с Delphi XE2. У меня есть несколько типизированных файлов, которые были записаны с помощью приложения Turbo Delphi 2006, и я также совершил ошибку, не используя упакованные записи. Моя ситуация усугублялась тем, что я использовал записи переменной длины (так мы называем их в мире z / OS, а не на 100% уверены в термине Delphi), поэтому неправильное выравнивание приводило к тому, что теги ключей записи не попадали в правильное поле, что приведет к тому, что ни одна из подзаписей не окажется в нужном месте, что сделает весь файл бесполезным.

Я обнаружил, что вы можете поместить директивы компилятора выравнивания только вокруг определенного блока кода. Наряду с этим, я также обнаружил эту маленькую жемчужину: {$OLDTYPELAYOUT ON}

{$OLDTYPELAYOUT ON}
 RMasterRecord = Record       
    mKey       : word;
    mDeleted   : boolean;
    case mType : ANSIChar of
       'V' : //Info
          (Vers : RVersionLayout);
       […]
{$OLDTYPELAYOUT OFF}

Я помещаю директиву только вокруг основной записи, которая записывается и читается в файл, а не вокруг определений подзаписей. Это решило мою проблему, и теперь я могу скомпилировать в XE2 и прочитать файлы TD2006. В следующий раз я воспользуюсь упакованными записями (а еще лучше - SQLite). Но я думал, что поделюсь этим, так как этот сайт неизмеримо помогал мне в течение многих лет.

Вы можете узнать больше о $ OLDTYPELAYOUT здесь: http://docwiki.embarcadero.com/RADStudio/XE5/en/Internal_Data_Formats#Record_Types. Кстати, первым, кто исправил это, был {$A4}, но когда я обнаружил {$OLDTYPELAYOUT ON}, я переключил его на использование этого, поскольку это более очевидно.

Я считаю, что выравнивание по умолчанию было расширено. Задайте выравнивание 4 в более поздних версиях и посмотрите, получится ли оно так, как вы хотите.

На будущее вы должны убедиться, что любая запись, которая будет записана на диск, хранится в упакованном виде, чтобы вы не сгорели таким образом.

Изменить: поскольку ни одно из выравниваний не работает (что меня удивляет), я бы вернулся к оригиналу и выяснил, как он действительно выровнен. Заполните запись чем-то вроде $ FF, введите данные и запишите их - посмотрите, где выжили $ FF. Возьмите новую запись, упакуйте ее и добавьте наполнители, чтобы они соответствовали заполнению в старой записи.

Одно: действительно ли это всего лишь одна запись? Раньше я использовал объекты как поддельные записи с наследованием - упс, в момент наследования применялось нормальное выравнивание, и я не мог его остановить. В конечном итоге мне пришлось заполнить данные перед данными, чтобы принудительное выравнивание не нарушило мои данные. (Речь шла о API, это БЫЛО, чтобы быть правым, я не мог обрабатывать поля независимо.)

Применение директивы {$ A8} не означает, что все поля записи выровнены по 8-байтовой границе - компилятор использует другую стратегию выравнивания. Например, размер

{$A8}
type
  TToTry = record
    a: byte;
    b: word;
    c: longword;
  end;

составляет 8 байтов в Delphi 2009, потому что компилятор выравнивает 2-байтовое значение по 2-байтовой границе, 4-байтовое значение по 4-байтовой границе, а единственное фактическое выравнивание в приведенном выше примере - это поле b, выровненное по 2-байтовой границе.

Что касается исходного вопроса, что изменилось между Delphi 7 и Delphi 2009 - прочитайте ответ Sertac Akyuz и мой комментарий к нему.