A few things to learn from [WayBack] delphi – Constant array of cardinal produces error ‘Constant expression violates subrange bounds” – Stack Overflow:
- Delphi XE7 introduced compiler support for
const dynamic arrays.
- Compiler errors can completely put you in the wrong direction.
- Command-line compilers indicate BDS versions which can confuse you for the exact product versions (thanks Rudy Velthuis for correcting that).
Sets
In this case, Delphi XE6 and below regard the [...] construct for constants as a set of Byte of which the maximum value is 255.
So this already fails with E1012 Constant expression violates subrange bounds, even though 257 perfectly fits the subrange of Cardinal:
const
CardinalArray: array of Cardinal = [257];
The documentation (which has not changed since Delphi 2007) puts you in a totally different direction: [WayBack] x1012: Constant expression violates subrange bounds
x1012: Constant expression violates subrange bounds
The alternative is to use a non-dynamic array that uses parenthesis instead of square brackets for initialisation:
const
CardinalArray: array[0..0] of Cardinal = (257);
Dynamic arrays
Const initialisation of dynamic arrays only made a tick mark on the box in [Archive.is] What’s New in Delphi and C++Builder XE7 – RAD Studio: String-Like Operations Supported on Dynamic Arrays, but in fact this code works in Delphi XE7 and up just fine:
program Cardinals;
{$APPTYPE CONSOLE}
uses
System.SysUtils;
const
CardinalArray: array of Cardinal = [257]; // fails until Delphi XE6 with "E1012 Constant expression violates subrange bounds"
const
ANSICOLORS: array of Cardinal = [
$000000,//0
$800000,//1, compilation error starts with this value
$008000,//2
$808000,//3
$000080,//4
$800080,//5
$008080,//6
$D0D0D0,//7
$3F3F3F,//8
$FF0000,//9
$00FF00,//A
$FFFF00,//B
$0000FF,//C
$FF00FF,//D
$00FFFF,//E
$FFFFFF];//F
var
AnsiColor: Cardinal;
begin
try
for AnsiColor in AnsiColors do
Writeln(Format('$%6.6x', [AnsiColor]));
except
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
end;
end.
Output:
$000000
$800000
$008000
$808000
$000080
$800080
$008080
$D0D0D0
$3F3F3F
$FF0000
$00FF00
$FFFF00
$0000FF
$FF00FF
$00FFFF
$FFFFFF
Note that dynamic arrays are unlike regular arrays, which for instance means that nesting them can get you into a different uncharted territory when using multiple dimensions.
Unlike an array, a dynamic array has notice of length. Which means it needs extra memory for it.
So where regular multi-dimensional arrays are blocks of memory. Multi-dimensional dynamic arrays are a dynamic array on each dimension level, which means extra length keeping, and the seemingly odd Copy behaviour described in [WayBack] Things that make you go ‘urgh’… | Delphi Haven:
What’s the flaw in this test code?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
program Project1;
{$APPTYPE CONSOLE}
var
Arr1, Arr2: array of array of Integer;
I, J: Integer;
begin
SetLength(Arr1, 5, 5);
for I := 0 to 4 do
for J := 0 to 4 do
Arr1[I, J] := I * J;
Arr2 := Copy(Arr1);
for I := 0 to 4 do
for J := 0 to 4 do
if Arr2[I, J] <> Arr1[I, J] then
begin
WriteLn('Nope');
Break;
end;
Write('Press ENTER to exit...');
ReadLn;
end.
|
with these comments
Rudy Velthuis:
Dynarrays are single-dimensional. One can get the illusion of multi-dimensionality because the Delphi syntax lets you access them using a[5,6] syntax, and SetLength takes more than one dimension parameter, and indeed, the docs even mention multi-dimensional, but that doesn’t change anything. You don’t have a multi-dimensional dynarray, you have a dynarray than contains other dynarrays. Each of these is one-dimensional. IOW, you don’t have one array, you have a cluster of dynarrays.
Copy() handles dynarrays. These are one-dimensional, so it only does one dimension (what else?). IOW, the behaviour is correct and actually well known.
Franćois:
I’m with you Chris. I don’t think this is “well known”, maybe because mono-dimensional dynamic arrays are probably used much more than multidimensional ones.
And also, the documentation is blaringly silent on this behavior. (credit to DelphiBasics to mention it: http://www.delphibasics.co.uk/RTL.asp?Name=Array)
The more visibility it gets, the less bugs we’ll have to deal with.
IMO, I don’t see why “copy” would not behave recursively and copy each sub-array as well. It seems that it is the intuitive behavior people tend to expect in the 1st place. (either nothing at all like Arr1:=Arr2, or a full recursive copy)
But since it’s been like that for some time, I doubt it can change for compatibility reasons (breaking code relying explicitly on this behavior).
Chris:
Thanks for the support! On my reading, the help strongly implies the behaviour I was expecting, and therefore, implies the actual behaviour to be a bug. Specifically, the entry for Copy (http://docwiki.embarcadero.com/VCL/en/System.Copy) includes the line:
Note: When S is a dynamic array, you can omit the Index and Count parameters and Copy copies the entire array.
What could ‘the entire array’ mean? According to Rudy, this can’t mean more than one dimension because dynamic arrays aren’t multidimensional. And yet, the Delphi Language Guide talks of ‘multidimensional dynamic arrays’ quite clearly (http://docwiki.embarcadero.com/RADStudio/en/Structured_Types#Multidimensional_Dynamic_Arrays). See also the docs for SetLength (http://docwiki.embarcadero.com/VCL/en/System.SetLength).
–jeroen
Today exactly 20 years ago, a futurist indicated “The Internet will not become a mass medium”.
The Wiert Corner - irregular stream of stuff 