Collections: Difference between revisions
no edit summary
(→{{header|Wren}}: Added syntax highlighting.) |
MaiconSoft (talk | contribs) No edit summary |
||
Line 841:
assert(5 in array); // returns a pointer, by the way
if (auto ptr = 6 in array) writefln(*ptr); // 20</lang>
=={{header|Delphi}}==
===Arrays===
Arrays are collection of values with memory self managed, can be static (size fixed and index not need start in zero) or dynamic (size scaled by user in run time and away start index in zero).
<lang Delphi>
// Creates and initializes a new integer Array
var
// Dynamics arrays can be initialized, if it's global variable in declaration scope
intArray: TArray<Integer> = [1, 2, 3, 4, 5];
intArray2: array of Integer = [1, 2, 3, 4, 5];
//Cann't initialize statics arrays in declaration scope
intArray3: array [0..4]of Integer;
intArray4: array [10..14]of Integer;
procedure
var
// Any arrays can't be initialized, if it's local variable in declaration scope
intArray5: TArray<Integer>;
begin
// Dynamics arrays can be full assigned in routine scope
intArray := [1,2,3];
intArray2 := [1,2,3];
// Dynamics arrays zero-based
intArray[0] := 1;
// Dynamics arrays must set size, if it not was initialized before
SetLength(intArray,5);
// Inline dynamics arrays can be created and initialized routine scope
// only for version after 10.3 Tokyo
var intArray6 := [1, 2, 3];
var intArray7: TArray<Integer> := [1, 2, 3];
end;
</lang>
===List===
Lists are objects and need be release from memory after use.
<lang Delphi>
var
// TLists can't be initialized or created in declaration scope
List1, List2:TList<Integer>;
begin
List1 := TList<Integer>.Create;
List1.Add(1);
list1.AddRange([2, 3]);
List1.free;
// TList can be initialized using a class derivative from TEnumerable, like it self
List1 := TList<Integer>.Create;
list1.AddRange([1,2, 3]);
List2 := TList<Integer>.Create(list1);
Writeln(List2[2]); // 3
List1.free;
List2.free;
// Inline TList can be created in routine scope
// only for version after 10.3 Tokyo
var List3:= TList<Integer>.Create;
List3.Add(2);
List3.free;
var List4: TList<Integer>:= TList<Integer>.Create;
List4.free;
end;
</lang>
===Dictionary===
TDictionary is a generic class.It represents a collection of key/value pairs. Keys must be unique.
It need be release from memory after use.
<lang Delphi>
var
// TDictionary can't be initialized or created in declaration scope
Dic1: TDictionary<string, Integer>;
begin
Dic1 := TDictionary<string, Integer>.Create;
Dic1.Add('one',1);
Dic1.free;
// Inline TDictionary can be created in routine scope
// only for version after 10.3 Tokyo
var Dic2:= TDictionary<string, Integer>.Create;
Dic2.Add('one',1);
Dic2.free;
var Dic3: TDictionary<string, Integer>:= TDictionary<string, Integer>.Create.Create;
Dic3.Add('one',1);
Dic3.free;
end;
</lang>
===Queue===
TQueue is a generic class.It represents a collection of data, stored in fist-in fist-out mode.
It need be release from memory after use.
<lang Delphi>
var
Queue1, Queue2: TQueue<Integer>;
List1:TList<Integer>;
begin
Queue1 := TQueue<Integer>.Create;
Queue1.Enqueue(1);
Queue1.Enqueue(2);
Writeln(Queue1.Dequeue); // 1
Writeln(Queue1.Dequeue); // 2
Queue1.free;
// TQueue can be initialized using a class derivative from TEnumerable, like TList<T>
List1 := TList<Integer>.Create;
List1.Add(3);
Queue2:= TQueue<Integer>.Create(List1);
Writeln(Queue2.Dequeue); // 3
List1.free;
Queue2.free;
// Inline TQueue can be created in routine scope
// only for version after 10.3 Tokyo
var Queue3 := TQueue<Integer>.Create;
Queue3.free;
end;
</lang>
===Stack===
TStack is a generic class.It represents a collection of data, stored in last-in first-out mode.
It need be release from memory after use.
<lang Delphi>
var
Stack1, Stack2: TStack<Integer>;
List1:TList<Integer>;
begin
Stack1:= TStack<Integer>.Create;
Stack1.Push(1);
Stack1.Push(2);
Writeln(Stack1.Pop); // 2
Writeln(Stack1.Pop); // 1
Stack1.free;
// TStack can be initialized using a class derivative from TEnumerable, like TList<T>
List1 := TList<Integer>.Create;
List1.Add(3);
Stack2:= TStack<Integer>.Create(List1);
Writeln(Stack2.Pop); // 3
List1.free;
Stack2.free;
// Inline TStack can be created in routine scope
// only for version after 10.3 Tokyo
var Stack3:= TStack<Integer>.Create;
Stack3.free;
end;
</lang>
===Strings===
String are array of chars, start index is one (not zero like almost languages).
Can store ansichar (one byte char) or widechar (two bytes char), the default for newer versions is widestring;
<lang Delphi>
var
Str1:String; // default WideString
Str2:WideString;
Str3:UnicodeString;
Str4:AnsiString;
Str5: PChar; //PWideChar is the same
Str6: PAnsiChar;
// Strings can be initialized, if it's global variable in declaration scope
Str4: string = 'orange';
begin
Str1 := 'apple';
// WideString and AnsiString can be converted implicitly, but in some times can lost information about char
Str4 := Str1;
// PChar is a poiter to string (WideString), must be converted using type cast
Str5 := Pchar(Str1);
// PChar not must type cast to convert back string
Str2 := Str5;
//In any string, index start in 1 and end on length of string
Writeln(Str1[1]); // 'a'
Writeln(Str1[5]); // 'e'
Writeln(Str1[length(str1)]); // the same above
end;
</lang>
See [[#Pascal]] for more info.
=={{header|E}}==
| |||