องค์ประกอบอยู่ในเซตหรือไม่? การเรียนรู้เนื้อหาใหม่

ชุดอ็อบเจ็กต์ kset ชุด kset คือคอลเลกชันของอ็อบเจ็กต์ kobject ชุด kset ทำหน้าที่เป็นคลาสคอนเทนเนอร์พื้นฐานสำหรับอ็อบเจ็กต์ เช่น "อุปกรณ์บล็อกทั้งหมด" ชุด kset มีความคล้ายคลึงกับ ktypes มากและมีคำถามเกิดขึ้น: "อะไรคือสองสิ่งที่แตกต่างกัน"

เฟโดเรนโก เซอร์เกย์

การแนะนำ

Delphi ช่วยให้คุณสามารถกำหนดประเภทของวัตถุชุดที่มีองค์ประกอบเป็นค่าประเภทฐานเดียวกัน ประเภทพื้นฐานกำหนดรายการองค์ประกอบทั้งหมดที่สามารถมีอยู่ในชุดที่กำหนด จำนวนองค์ประกอบที่รวมอยู่ในชุดอาจแตกต่างกันได้ตั้งแต่ 0 ถึง 256 (ชุดที่ไม่มีองค์ประกอบเรียกว่าว่างเปล่า)

คำอธิบาย

คำอธิบายของประเภทชุดคือ:

พิมพ์<имя типа>= ชุดของ<базовый тип>;

ที่นี่<имя типа>- ตัวระบุ;<базовый тип>- หนึ่งในประเภทสเกลาร์ ยกเว้นจริง ประเภทฐานจะถูกระบุโดยช่วงหรือการแจงนับ จากประเภทมาตรฐาน สามารถระบุประเภทไบต์ ถ่าน และบูลีนเป็นประเภทพื้นฐานของชุดได้ ประเภทพื้นฐานได้รับการแนะนำผ่านคำจำกัดความเบื้องต้นในส่วนคำอธิบายโปรแกรม หรือผ่านคำสั่งโดยตรงหลังชุดคำในคำอธิบายประเภทชุด ตัวอย่างเช่น:

พิมพ์ตัวอักษร = "a" .. "z"; // คำอธิบายของตัวอักษรชนิดจำกัด
ประเภท SL = ชุดตัวอักษร; // คำอธิบายของ SL หลายประเภทพร้อมตัวอักษรประเภทฐาน

ประเภท SLR = ชุดของ "a" .. "z"; // รวมคำจำกัดความประเภทพื้นฐาน "a .. "z" โดยตรงในคำจำกัดความประเภท SLR หลายประเภท

หากโปรแกรมใช้ตัวแปรที่มีการตั้งค่าไว้ ตัวแปรเหล่านี้จะอธิบายในลักษณะปกติ:

พิมพ์ intset = ชุดของไบต์;
var m1, m2: intset; // อธิบายตัวแปรโดยระบุว่าเป็นของประเภทที่กำหนดไว้ก่อนหน้านี้
var m3: ชุด 1..20; // คำจำกัดความของประเภทของตัวแปรรวมอยู่ในคำอธิบายโดยตรง

คุณสามารถตั้งค่าของตัวแปรประเภทชุดในโปรแกรมโดยใช้ตัวดำเนินการกำหนด ซึ่งทางด้านขวาขององค์ประกอบของชุดจะแสดงอยู่ในวงเล็บเหลี่ยม คั่นด้วยเครื่องหมายจุลภาค (หรือที่เรียกว่าตัวสร้างชุด) ตัวอย่างค่าตัวแปรหลายประเภท:

ชุดเปล่า;
- ชุดที่มีองค์ประกอบ 1, 3, 5, 6, .. 12;
["a" .. "p", "u", "z"] - ชุดที่ประกอบด้วยอักขระที่อยู่ในรายการประเภทถ่าน

องค์ประกอบของประเภทชุดสามารถระบุเป็นนิพจน์ได้ ตัวอย่างเช่น: นิพจน์จะต้องมีค่าจากชุดพื้นฐานที่กำหนดของประเภทลำดับ ช่วงของค่าของตัวแปรหลายประเภทคือชุดของชุดย่อยที่เป็นไปได้ทั้งหมดที่เกิดจากองค์ประกอบของประเภทฐาน

ต่างจากการแจงนับ คุณไม่สามารถพูดถึงเรื่องแรก ครั้งที่สอง ฯลฯ องค์ประกอบของชุด เนื่องจากสำหรับชุด แนวคิดในการสั่งซื้อไม่สมเหตุสมผล หากชุดประกอบด้วยสามองค์ประกอบเท่านั้น จำนวนรวมที่เป็นไปได้ของชุดค่าผสมคือ 2 * 2 * 2 = 8 ชุดคำสงวนสามารถกำหนดชุดที่มีองค์ประกอบได้สูงสุด 256 องค์ประกอบ กล่าวคือ 1.1579208923731619542357098500869e+77 ตัวเลือก ในทางปฏิบัติ ไม่จำเป็นต้องมีตัวเลือกมากมายเช่นนี้ โดยเฉพาะอย่างยิ่งนักพัฒนา Delphi แนะนำให้ใช้ชุดที่มีองค์ประกอบไม่เกิน 16 รายการ

ตั้งค่าการดำเนินการ

การดำเนินการเดียวกันนี้สามารถดำเนินการกับตัวแปรหลายประเภทเช่นเดียวกับชุดทั่วไป:

1. ยูเนี่ยน (+);
2. ทางแยก (*);
3. ความแตกต่าง (-)

นอกจากนี้ การดำเนินการบางอย่างในการตรวจสอบว่าองค์ประกอบเป็นของเซต (ใน) หรือไม่ การตรวจสอบเอกลักษณ์ของเซต (=) ความไม่มีตัวตน เซต (<>) การพิจารณาความเป็นสมาชิก (การซ้อน) ของชุด (>= หรือ<=). Примеры:

1. = // ผลลัพธ์เป็นจริง
2. ["a" .. "z"] = ["a" .. "p"] // ผลลัพธ์เป็นเท็จ
3. <>// ผลลัพธ์เป็นจริง
4. ["ก", "ข", "ค"]<= ["a" .. "z"] // Результат True
5. ["a" .. "k"] >= ["a" .. "z"] // ผลลัพธ์เป็นเท็จ
6. + // ผลลัพธ์
7. * // ผลลัพธ์
8. - // ผลลัพธ์

การดำเนินการช่วยให้คุณสามารถระบุได้ว่าองค์ประกอบใดเป็นของชุดหรือไม่ ตัวถูกดำเนินการตัวแรกทางด้านซ้ายของคำในคือนิพจน์ของประเภทฐาน ตัวถูกดำเนินการตัวที่สองทางด้านขวาของคำใน ต้องมีหลายประเภท เช่น

ใน // ผลลัพธ์ True
2 * 4 นิ้ว // ผลลัพธ์เป็นจริง
"a" + "b" ใน ["ab", "cd", "ef"] // ผลลัพธ์เป็น True
5 นิ้ว // ผลลัพธ์เป็นจริง
5 ใน // ผลลัพธ์เป็นเท็จ

เมื่อใช้ตัวดำเนินการ in ค่าที่กำลังทดสอบสำหรับการเป็นสมาชิกและค่าที่ตั้งไว้ในวงเล็บเหลี่ยม ไม่จำเป็นต้องถูกกำหนดไว้ก่อนหน้านี้ในส่วนการประกาศ เว้นแต่จะระบุเป็นค่าที่เป็นรูปธรรม

ตัวดำเนินการ in ช่วยให้คุณสามารถดำเนินการทดสอบสภาพที่ซับซ้อนได้อย่างมีประสิทธิภาพ ตัวอย่างเช่น แทนที่จะเป็น:

(ค >= "0") และ (ค<= "9") or (c >= "ก") และ (ค<="z");

เขียนง่ายกว่า:

ค ใน ["0" .. "9", "a" .. "z"];

นอกจากนี้การออกแบบหลังจะมีประสิทธิภาพมากขึ้นตามกฎแล้ว

การดำเนินงาน (=) และ (<>) ให้คุณตรวจสอบว่าสองชุดเท่ากันหรือไม่ การใช้ตัวดำเนินการ (>=) และ (<=) можно определить, является ли одно множество подмножеством другого. Пример:

= // ผลลัพธ์เป็นเท็จ
<= // Результат True

หมายเหตุ:
1. เซตว่างคือสับเซตของเซตอื่น โดยไม่คำนึงถึงประเภทขององค์ประกอบพื้นฐาน
2. ชุดตัวถูกดำเนินการสามารถมีประเภทฐานที่ไม่ต่อเนื่องได้ ตัวอย่างเช่น การมีเซต A: ชุด 1 .. 99 และ B: ชุด 100 .. 150 จากการรวม A+B เราจึงสามารถได้ชุดใหม่ที่มีประเภทฐาน 1 .. 150
3. จำเป็นต้องแยกความแตกต่างระหว่างตัวสร้างชุดและส่วนของประเภทลำดับ X .. Y สำหรับ X > Y ในกรณีแรกเรากำลังพูดถึงชุดว่างและในวินาทีที่คอมไพเลอร์จะสร้างข้อผิดพลาด ตัวอย่าง:

["a", "b"] = ["b" .. "a"] // ผลลัพธ์เป็นเท็จ

เมื่อตรวจสอบเซ็ตย่อย การทดสอบจะดำเนินการสำหรับ "น้อยกว่าหรือเท่ากับ" และไม่ใช่แค่การทดสอบสำหรับเซ็ตย่อยของตัวเอง กล่าวคือ โดยไม่มี "เท่ากับ" การดำเนินงาน (<) и (>) ไม่ได้จัดเตรียมไว้ ดังนั้น หากจำเป็น การตรวจสอบเซตย่อยที่เหมาะสมสำหรับเซต A และ B สามารถทำได้ดังนี้:

(ก<= B) and (A >= B) หรือ (A >= B) และ (A<>ข)

ในการระบุลำดับการดำเนินการที่ถูกต้อง เราควรคำนึงถึงลำดับความสำคัญที่ยอมรับ (ลำดับความสำคัญ) ของการดำเนินการในชุด: จุดตัด (*) มีลำดับความสำคัญเช่นเดียวกับการดำเนินการทางคณิตศาสตร์ของการคูณและการหาร ยูเนี่ยน (+) และผลต่าง (-) ครอบครองระดับความสำคัญที่ต่ำกว่าถัดไป คล้ายกับการดำเนินการทางคณิตศาสตร์ของการบวกและการลบ ที่ระดับต่ำสุดจะมีการตั้งค่าการดำเนินการเปรียบเทียบ (=,<>, <=, >=) และตรวจสอบว่าองค์ประกอบเป็นของชุด (ใน) หรือไม่ การดำเนินการที่มีลำดับความสำคัญเท่ากันจะดำเนินการจากซ้ายไปขวา วงเล็บใช้เพื่อเปลี่ยนลำดับการดำเนินการ

การใช้ชุด

อย่างมีประสิทธิภาพมากที่สุด ชุดสามารถใช้เพื่อแทนที่คำสั่ง if ได้ เช่น เพื่อตรวจสอบว่าคำตอบบางอย่างอยู่ในรายการที่อนุญาตหรือไม่ โปรแกรมต่อไปนี้สำหรับการป้อนสตริงอักขระที่มีตัวอักษรละติน ตัวเลข และช่องว่างพร้อมการควบคุมความถูกต้องของอักขระที่ป้อนสามารถใช้เป็นตัวอย่างของการใช้ชุด:

โปรแกรมโปรเจ็กต์1;

($คอนโซลประเภทแอป)

var
STR:สตริง;
L:ไบต์;
เสื้อ: บูลีน;

ใน Delphi โปรแกรมเมอร์มักจะต้องจัดการกับชุดซึ่งเป็นชุดของค่าประเภทเดียวกันเป็นหลัก แต่ละชุดจะมีช่วงค่าของตัวเอง ซึ่งประกอบด้วยชุดของชุดย่อยที่เป็นไปได้ทั้งหมดที่มีองค์ประกอบอยู่ด้วย

หากเราวาดความคล้ายคลึงกับคำศัพท์ทางคณิตศาสตร์ ในการเขียนโปรแกรม แนวคิดของเซตจะมีคุณสมบัติหลายประการ ตัวอย่างเช่น มันมีจำกัด กล่าวคือ เซตไม่สามารถมีองค์ประกอบจำนวนอนันต์ได้ จำนวนอ็อบเจ็กต์ทั้งหมดที่อยู่ในชุดมีตั้งแต่ 0 ถึง 256 หากชุดไม่ได้เป็นขององค์ประกอบเดียว จะเรียกว่าว่างเปล่า

เป็นที่น่าสังเกตว่าในชุด Delphi ไม่สามารถใช้จัดเก็บองค์ประกอบใด ๆ (อักขระตัวเลข) สามารถตอบคำถามได้ว่าองค์ประกอบบางอย่างอยู่ในชุดที่กำหนดหรือไม่

ชุดเดลฟี

ตัวอย่างเช่น:

พิมพ์<имя типа>= ชุดของ<базовый тип>;
ในกรณีนี้<имя типа>ทำหน้าที่เป็นตัวระบุ ก<базовый тип>เป็นหนึ่งในประเภทสเกลาร์ โดยระบุโดยการแจงนับหรือช่วงเฉพาะ ในบรรดาประเภทมาตรฐาน char, byte, boolean สามารถใช้เป็นประเภทพื้นฐานได้ คุณสามารถกำหนดประเภทได้ทั้งในคำอธิบายโปรแกรมและระบุโดยตรงในคำอธิบายชุด

ตัวอย่างเช่น: ตัวเลือกแรก

พิมพ์ abc = "c" .. "q"; // พิมพ์คำอธิบาย abc type FG = ชุดของ abc; // คำอธิบายของ FG หลายประเภทพร้อมประเภทพื้นฐาน abc
ตัวเลือกที่สอง

พิมพ์ FGH = ชุดของ "c" .. "q"; // รวมคำจำกัดความประเภทพื้นฐาน "c' .. "q" โดยตรงในคำจำกัดความหลายประเภทของ FGH
เมื่อพิจารณาฉากใน Delphi เป็นที่น่าสังเกตว่าไม่มีประโยชน์ที่จะพูดถึงการสั่งซื้อ ตัวอย่างเช่น หากชุดหนึ่งมีวัตถุเพียงสามชิ้น จำนวนรวมของรูปแบบที่แตกต่างกันจะเท่ากับแปดชิ้น

เมื่อกำหนดชุดแล้ว จะสามารถดำเนินการต่างๆ กับชุดนั้นได้ ใน Delphi ชุดสามารถรวมและตัดกันได้ นอกจากนี้ยังมีการดำเนินการ เช่น ส่วนต่างและ IN อีกด้วย

เมื่อเปรียบเทียบฉากใน Delphi ไม่มีประโยชน์ที่จะใส่ใจกับลำดับขององค์ประกอบ สองชุดจะเท่ากันหากมีองค์ประกอบเดียวกัน

ใน Delphi คุณสามารถใช้การดำเนินการเป็นสมาชิกได้ ชุดหนึ่งเป็นของอีกชุดหนึ่งหากองค์ประกอบทั้งหมดรวมอยู่ในอีกชุดหนึ่ง

ตัวอย่างเช่น A >= B จะเป็น True หากสมาชิกทั้งหมดของเซต B อยู่ในเซต A ด้วย

เพื่อจะได้รู้ว่า ไม่ว่าองค์ประกอบใดองค์ประกอบหนึ่งจะเป็นของชุดหรือไม่ก็ตาม ตัวดำเนินการ IN จะถูกนำมาใช้ เมื่อใช้การดำเนินการนี้ คุณสามารถทำการทดสอบเงื่อนไขการเป็นสมาชิกที่ค่อนข้างซับซ้อนได้อย่างมีประสิทธิภาพมาก

นอกเหนือจากที่กล่าวมาทั้งหมดแล้วใน ชุด Delphi สามารถรวมเป็นชุดเดียวได้- เป็นผลให้ได้รับชุดที่สามซึ่งรวมถึงองค์ประกอบจากทั้ง A และ B

การใช้ชุดในการใช้งานโปรแกรมเฉพาะช่วยให้โปรแกรมเมอร์สามารถปรับปรุงความชัดเจนของอัลกอริทึมได้อย่างมาก ลดความซับซ้อนของคำสั่ง if และประหยัดเวลาอีกด้วย การใช้ชุดคำสั่งใน Delphi นั้นง่ายมาก โดยเฉพาะถ้าคุณเปรียบเทียบการดูแลระบบ Linux

เมื่อสร้างโปรแกรมที่จริงจังใด ๆ คุณไม่สามารถทำได้หากไม่มีประเภทข้อมูลเพิ่มเติมที่ซับซ้อนกว่าตัวเลขและสตริง ใน เดลฟีโปรแกรมเมอร์สามารถสร้างชนิดข้อมูลของตนเองเพื่อวัตถุประสงค์ของตนเองได้ หากต้องการแนะนำ (อธิบาย) ชนิดข้อมูลใหม่ให้กับโปรแกรม ให้ใช้โอเปอเรเตอร์พร้อมคีย์เวิร์ด พิมพ์:
พิมพ์ type_name = ประเภท_คำอธิบาย ;

นับได้ประเภทคือประเภทข้อมูลที่มีช่วงของค่าเป็นเพียงชุดของตัวระบุ สามารถใช้ในกรณีที่คุณต้องการอธิบายประเภทข้อมูลที่มีค่าซึ่งแสดงได้ชัดเจนยิ่งขึ้นไม่ใช่ด้วยตัวเลข แต่เป็นคำ ประเภทที่ระบุจะถูกเขียนเป็นลำดับของตัวระบุ - ค่าประเภทนี้คั่นด้วยเครื่องหมายจุลภาคซึ่งอยู่ในวงเล็บ ในกรณีนี้ องค์ประกอบแรกของประเภทจะถือเป็นองค์ประกอบรองเมื่อเปรียบเทียบกับองค์ประกอบที่ตามมา ตัวอย่างเช่น ประเภทที่อธิบายชื่อทีมฟุตบอลอาจสร้างได้ดังนี้

พิมพ์ทีมฟุตบอล = (สปาร์ตัก, ดินาโม, ซีเอสเคเอ, ตอร์ปิโด, โลโคโมทีฟ);
varทีมของฉัน: FootballTeam;
เริ่ม
MyTeam:=สปาร์ตัก;
จบ;

โดยทั่วไปประเภทแจกแจงหมายถึงทุกประเภทที่สามารถกำหนดลำดับของค่าและลำดับความสำคัญได้ ซึ่งรวมถึง:

• จำนวนเต็มทุกประเภทที่สามารถระบุหมายเลขตามหลังหมายเลข N ได้ตลอดเวลา
• ประเภทอักขระ (อักขระ): อักขระ "a" จะต้องตามด้วย "b" เสมอ "0" จะต้องตามด้วย "1" เสมอ และอื่นๆ
• ประเภทบูลีน - ประเภทบูลีนก็เป็นประเภทแจงนับด้วย: พิมพ์บูลีน = (เท็จ จริง);

• อาร์เรย์
• บันทึก
• ชุด

พิมพ์ array_type_name = อาร์เรย์[พิสัย] ขององค์ประกอบ_ประเภท;

พิสัยกำหนดขอบเขตล่างและบนของอาร์เรย์และจำนวนองค์ประกอบในนั้น เมื่อเข้าถึงอาร์เรย์ ดัชนีจะต้องอยู่ภายในช่วงนี้ อาร์เรย์ขององค์ประกอบหนึ่งร้อยชนิดเป็นจำนวนเต็มมีคำอธิบายดังนี้:

พิมพ์ TMyArray= อาร์เรย์ ของจำนวนเต็ม;

ตอนนี้เราสามารถอธิบายตัวแปรประเภท TMyArray ได้:

varก, ข: TMyArray;

แทนที่จะกำหนดประเภท คุณสามารถประกาศตัวแปรเป็นอาร์เรย์ได้อย่างชัดเจน:

varก, ข: อาร์เรย์ ของจำนวนเต็ม;

ในการเข้าถึงองค์ประกอบอาร์เรย์ คุณต้องระบุชื่ออาร์เรย์และดัชนีขององค์ประกอบในวงเล็บเหลี่ยม ดัชนีอาจเป็นตัวเลข ตัวระบุ หรือนิพจน์ ซึ่งค่าจะต้องอยู่ในช่วงที่ระบุเมื่ออธิบายอาร์เรย์:

varยังไม่มีข้อความ: จำนวนเต็ม;
เริ่ม
ไม่มี:= 65;
ก := 101;
อ[N] := 165;
ก := 200;
ข:= ก;
จบ;

บางครั้งก็จำเป็น ค้นหาขอบเขตบนหรือล่างของอาร์เรย์- ฟังก์ชันในตัวใช้สำหรับสิ่งนี้:

สูง()- จะส่งคืนตัวเลขที่เป็นขอบเขตบนของอาร์เรย์
ต่ำ()- จะส่งกลับตัวเลขที่เป็นขอบเขตล่างของอาร์เรย์

คุณต้องใส่ในวงเล็บ อาร์เรย์ที่มีขอบเขตที่คุณต้องการค้นหา.

การแสดงออก ข:= กหมายความว่าแต่ละองค์ประกอบของอาร์เรย์ บีจะเท่ากับองค์ประกอบที่มีดัชนีอาร์เรย์เดียวกัน ก- การกำหนดดังกล่าวจะเป็นไปได้ก็ต่อเมื่อมีการประกาศอาร์เรย์ทั้งสองผ่านประเภทที่มีชื่อหรืออยู่ในรายการเดียวกัน และในกรณี:

varตอบ: อาร์เรย์ ของสตริง;
บี: อาร์เรย์ ของสตริง;

มันเป็นไปไม่ได้ที่จะใช้มัน (แต่การมอบหมายองค์ประกอบ B := A; ฯลฯ เป็นไปได้)

อาร์เรย์สามารถมีได้หลายมิติ โดยคั่นด้วยเครื่องหมายจุลภาค ตัวอย่างเช่น ตารางที่มีสี่คอลัมน์และสามแถว:

พิมพ์ MyTable = อาร์เรย์ของจำนวนเต็ม;
var X: ตารางของฉัน;
Y: จำนวนเต็ม;
เริ่ม
ย:=X;
จบ;

ขณะนี้เป็นผลมาจากการดำเนินการมอบหมาย ยจะเท่ากัน 7 .
ตัวอย่างเช่น อาร์เรย์สองมิติหลายมิติสามารถอธิบายเป็นอาร์เรย์ของอาร์เรย์ได้:

พิมพ์ TMyArray= อาร์เรย์ ของอาร์เรย์ ของจำนวนเต็ม;

ผลลัพธ์จะคล้ายกับตัวอย่างก่อนหน้า
แต่ละมิติของอาร์เรย์หลายมิติสามารถมีประเภทของตัวเองได้ ไม่จำเป็นต้องเป็นจำนวนเต็ม
นอกเหนือจากที่กล่าวมาข้างต้นที่เรียกว่า คงที่อาร์เรย์ที่จำนวนองค์ประกอบคงที่ในหน่วย เดลฟีสามารถใช้ได้ พลวัตอาร์เรย์จำนวนองค์ประกอบที่สามารถเปลี่ยนแปลงได้ขึ้นอยู่กับข้อกำหนดของโปรแกรม สิ่งนี้ช่วยให้คุณประหยัดทรัพยากรคอมพิวเตอร์แม้ว่าการทำงานกับอาร์เรย์ดังกล่าวจะช้ากว่ามากก็ตาม อาร์เรย์แบบไดนามิกมีการอธิบายคล้ายกับอาร์เรย์แบบคงที่ แต่ไม่ได้ระบุช่วงดัชนี:

พิมพ์ TDinArray= อาร์เรย์ของจำนวนเต็ม;
varตอบ: TDinArray;

หลังจากสร้างแล้ว จะไม่มีองค์ประกอบในอาร์เรย์ไดนามิก ขนาดที่ต้องการถูกตั้งค่าในโปรแกรมโดยใช้ขั้นตอนพิเศษ ตั้งค่าความยาว- อาร์เรย์หนึ่งร้อยองค์ประกอบ:

เริ่ม
ตั้งค่าความยาว(A, 100);
จบ;

ขอบเขตล่างของอาร์เรย์ไดนามิกจะเป็นศูนย์เสมอ ดังนั้นดัชนีอาร์เรย์ กอาจจะแตกต่างจาก 0 ก่อน 99 .
หลายมิติอาร์เรย์แบบไดนามิกอธิบายไว้ทุกประการ อาร์เรย์ของอาร์เรย์- ตัวอย่างเช่น สองมิติ:

พิมพ์ T3DinArray= อาร์เรย์ของจำนวนเต็ม;
varตอบ: T3DinArray;

ขั้นแรกโปรแกรมจะกำหนดขนาดตามมิติแรก (จำนวนคอลัมน์):

หากต้องการเพิ่มหน่วยความจำที่จัดสรรให้กับอาร์เรย์แบบไดนามิก คุณต้องกำหนดค่าให้กับอาร์เรย์เป็นจำนวนเต็ม ไม่มี:
ตอบ:= ไม่มี;
คำสำคัญ ไม่มีใน Delphi หมายถึงไม่มีค่า

กระทู้เป็นเครื่องมือที่สำคัญและสะดวกมาก แม้จะไม่ได้ใช้เทคโนโลยีพิเศษ คุณก็สามารถใช้มันเพื่อสร้างของคุณเองได้ ฐานข้อมูล- เรกคอร์ดคือโครงสร้างข้อมูล ซึ่งแต่ละองค์ประกอบจะมีชื่อและประเภทข้อมูลของตัวเอง องค์ประกอบบันทึกจะเรียกว่าอย่างอื่น สนาม- คำอธิบายรายการมีลักษณะดังนี้:
พิมพ์ post_type_name= บันทึก
field_name: field_type;
. . .
field_name: field_type;
จบ;
ชื่อของฟิลด์ที่มีประเภทเดียวกันสามารถระบุในบรรทัดเดียวได้ เช่นเดียวกับในกรณีของคำอธิบายตัวแปร โดยคั่นด้วยเครื่องหมายจุลภาค หากต้องการอ้างอิงถึงฟิลด์บันทึก ขั้นแรกให้ระบุชื่อบันทึก จากนั้นจึงระบุจุด จากนั้นจึงระบุชื่อฟิลด์ ตัวอย่างเช่น ข้อมูลเกี่ยวกับบุคลากรขององค์กรสามารถจัดระเบียบได้โดยใช้บันทึกประเภทนี้:

พิมพ์ทีเพอร์ = บันทึก
ครอบครัว ชื่อ พาร์: สตริง;
ปี: จำนวนเต็ม;
โดย: สตริง;
จบ;
varจำนวนผู้: TPers;
เริ่ม
ท่าน . ครอบครัว:="อีวานอฟ";
ท่าน . ชื่อ:="อีวาน";
ท่าน . พาร์:="อิวาโนวิช";
ท่าน . ปี:=1966;
ท่าน . Dep:="เวิร์คช็อปหมายเลข 1";
จบ;

ตอนนี้สิ่งที่เหลืออยู่คือการเขียนข้อมูลนี้ลงในไฟล์โดยได้ประกาศประเภทไว้ก่อนหน้านี้เป็น ทีเปอร์, และ ฐานข้อมูลพร้อม. พร้อมไฟล์เข้า เดลฟีที่เกี่ยวข้องกันคือตัวแปรที่เรียกว่าตัวแปรไฟล์ซึ่งมีคำอธิบายดังนี้:
วีไฟล์ : ไฟล์ของประเภทไฟล์;
ประเภทนี้สามารถเป็นประเภทที่จำกัดของ Delphi ใดก็ได้ อย่างไรก็ตาม ไม่อนุญาตให้ใช้ประเภทนี้ สตริงเนื่องจากอนุญาตให้มีขนาดตัวแปรได้สูงสุด 2GB จะต้องมีข้อ จำกัด : สตริง[N]โดยที่ N คือจำนวนอักขระ พิมพ์ ทีเปอร์จากตัวอย่างที่แล้วควรอธิบายดังนี้

พิมพ์ทีเพอร์ = บันทึก
ครอบครัว ชื่อ พาร์: สตริง;
ปี: จำนวนเต็ม;
โดย: สตริง;
จบ;

ขณะนี้ตัวแปรประเภทนี้ครอบครองตำแหน่งที่กำหนดไว้อย่างเคร่งครัดในหน่วยความจำและสามารถเขียนลงในไฟล์ได้ วิธีการทำเช่นนี้อธิบายไว้ใน ส่วนที่ 2บทเรียนหมายเลข 7

พวงของเป็นกลุ่มของธาตุรวมกันภายใต้ชื่อเดียว และปริมาณอื่น ๆ ที่สามารถนำมาเปรียบเทียบเพื่อดูว่าองค์ประกอบเหล่านั้นอยู่ในชุดนี้หรือไม่ จำนวนองค์ประกอบในชุดหนึ่งต้องไม่เกิน 256 ชุดมีคำอธิบายดังนี้:

พิมพ์ set_name= ชุดของ set_value_range;

ประเภทใดก็ได้สามารถระบุเป็นช่วงจำนวนองค์ประกอบที่ไม่เกิน 256 ตัวอย่างเช่น

พิมพ์ทีมายเซ็ท= ชุดของ 0 .. 255;
พิมพ์ทีมายเซ็ท= ชุดของไบต์;

ค่าเฉพาะของชุดจะถูกระบุในโปรแกรมโดยใช้รายการองค์ประกอบที่อยู่ในวงเล็บเหลี่ยม ยังสามารถใช้ช่วง:

varชุดของฉัน: TMySet;
เริ่ม
เซ็ตของฉัน:=;
จบ;

หากต้องการตรวจสอบว่าค่าเป็นองค์ประกอบของชุดหรือไม่ ให้ใช้ตัวดำเนินการ ในร่วมกับ มีเงื่อนไขตัวดำเนินการ:

varคีย์: ชาร์;
Str: สตริง;