การเขียนโปรแกรม D - การห่อหุ้ม

โปรแกรม D ทั้งหมดประกอบด้วยองค์ประกอบพื้นฐานสองประการต่อไปนี้ -

• Program statements (code) - นี่คือส่วนหนึ่งของโปรแกรมที่ดำเนินการและเรียกว่าฟังก์ชัน

• Program data - เป็นข้อมูลของโปรแกรมที่ได้รับผลกระทบจากการทำงานของโปรแกรม

การห่อหุ้มเป็นแนวคิดการเขียนโปรแกรมเชิงวัตถุที่ผูกข้อมูลและฟังก์ชันที่จัดการข้อมูลเข้าด้วยกันและช่วยให้ทั้งสองปลอดภัยจากการรบกวนภายนอกและการใช้งานในทางที่ผิด การห่อหุ้มข้อมูลนำไปสู่แนวคิด OOP ที่สำคัญของdata hiding.

Data encapsulation เป็นกลไกในการรวมข้อมูลและฟังก์ชันที่ใช้และ data abstraction เป็นกลไกในการเปิดเผยเฉพาะอินเทอร์เฟซและซ่อนรายละเอียดการใช้งานจากผู้ใช้

D สนับสนุนคุณสมบัติของการห่อหุ้มและการซ่อนข้อมูลผ่านการสร้างชนิดที่ผู้ใช้กำหนดซึ่งเรียกว่า classes. เราได้ศึกษาแล้วว่าชั้นเรียนสามารถมีได้private, ป้องกันและ publicสมาชิก. โดยค่าเริ่มต้นรายการทั้งหมดที่กำหนดในคลาสเป็นส่วนตัว ตัวอย่างเช่น -

class Box { 
   public: 
      double getVolume() { 
         return length * breadth * height; 
      } 
   private: 
      double length;      // Length of a box 
      double breadth;     // Breadth of a box 
      double height;      // Height of a box 
};

ตัวแปรความยาวความกว้างและความสูงคือ private. ซึ่งหมายความว่าสมาชิกคนอื่น ๆ ในคลาส Box สามารถเข้าถึงได้เท่านั้นและไม่สามารถเข้าถึงได้โดยส่วนอื่น ๆ ของโปรแกรมของคุณ นี่เป็นวิธีการห่อหุ้มวิธีหนึ่งที่ทำได้

เพื่อสร้างส่วนต่างๆของชั้นเรียน public (กล่าวคือสามารถเข้าถึงส่วนอื่น ๆ ของโปรแกรมของคุณได้) คุณต้องประกาศหลังจากส่วน publicคำสำคัญ. ตัวแปรหรือฟังก์ชันทั้งหมดที่กำหนดหลังจากตัวระบุสาธารณะสามารถเข้าถึงได้โดยฟังก์ชันอื่น ๆ ทั้งหมดในโปรแกรมของคุณ

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

การห่อหุ้มข้อมูลใน D

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

ตัวอย่าง

import std.stdio;
  
class Adder { 
   public: 
      // constructor 
      this(int i = 0) { 
         total = i; 
      } 
      
      // interface to outside world 
      void addNum(int number) { 
         total += number; 
      } 
      
      // interface to outside world 
      int getTotal() { 
         return total; 
      }; 
   
   private: 
      // hidden data from outside world 
      int total; 
}
 
void main( ) { 
   Adder a = new Adder(); 
   
   a.addNum(10); 
   a.addNum(20); 
   a.addNum(30);  
   writeln("Total ",a.getTotal()); 
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานโค้ดจะได้ผลลัพธ์ดังนี้ -

Total 60

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

กลยุทธ์การออกแบบคลาสใน D

พวกเราส่วนใหญ่ได้เรียนรู้จากประสบการณ์อันขมขื่นเพื่อให้สมาชิกชั้นเรียนเป็นส่วนตัวโดยปริยายเว้นแต่เราจำเป็นต้องเปิดเผยพวกเขาจริงๆ แค่นั้นก็ดีแล้วencapsulation.

ภูมิปัญญานี้ถูกนำไปใช้กับสมาชิกข้อมูลบ่อยที่สุด แต่ใช้กับสมาชิกทุกคนอย่างเท่าเทียมกันรวมถึงฟังก์ชันเสมือน