Collections: Difference between revisions
Content added Content deleted
(→{{header|Wren}}: Added syntax highlighting.) |
MaiconSoft (talk | contribs) No edit summary |
||
Line 841: | Line 841: | ||
assert(5 in array); // returns a pointer, by the way |
assert(5 in array); // returns a pointer, by the way |
||
if (auto ptr = 6 in array) writefln(*ptr); // 20</lang> |
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}}== |
=={{header|E}}== |
||