ส่วนต่อประสานใน C ++ นั้นใช้คลาสนามธรรม ในทางกลับกัน คลาสจะถูกเรียกว่าคลาสนามธรรม ถ้าอย่างน้อยหนึ่งฟังก์ชันภายในคลาสถูกประกาศเป็นฟังก์ชันเสมือนล้วน
ฟังก์ชันเสมือนบริสุทธิ์คืออะไร
เดอะ ฟังก์ชันเสมือนจริงอย่างแท้จริง หมายความว่าผู้ใช้เพียงแค่ประกาศฟังก์ชันไม่ใช่คำจำกัดความ การแทนที่เมธอด/ฟังก์ชันจะใช้เมธอดเสมือนบริสุทธิ์ในคลาสที่ได้รับมา ฟังก์ชันถือเป็นเสมือนบริสุทธิ์หากอธิบายไว้ในคลาสตามที่ระบุด้านล่าง:
นี่คือไวยากรณ์ของ ฟังก์ชันเสมือนจริงอย่างแท้จริง ของห้องเรียน.
ระดับ ห้อง {
สาธารณะ :
// ฟังก์ชันเสมือนบริสุทธิ์
เสมือน สองเท่า เกทาเรีย ( ) = 0 ;
ส่วนตัว :
สองเท่า ความยาว ; // ความยาวของห้อง
สองเท่า ความกว้าง ; // ความกว้างของห้อง
} ;
คลาสนามธรรมคืออะไร
คลาสที่สร้างขึ้นโดยเฉพาะเพื่อจุดประสงค์ในการให้บริการเป็นคลาสพื้นฐานมีชื่อว่า an คลาสนามธรรม . ต้องมีฟังก์ชันเสมือนอย่างน้อยหนึ่งฟังก์ชันในคลาสนามธรรม อาจรวมถึงตัวแปรและฟังก์ชันมาตรฐาน คลาสที่ได้รับซึ่งคลาสนามธรรมมี ควรใช้ฟังก์ชันเสมือนจริงของคลาสพื้นฐาน มิฉะนั้นจะกลายเป็นนามธรรม
พิจารณาตัวอย่างต่อไปนี้ ซึ่งคลาสพาเรนต์ให้ส่วนต่อประสานกับคลาสพื้นฐานเพื่อให้คลาสพื้นฐานใช้ฟังก์ชันเสมือนบริสุทธิ์ที่เรียกว่า รับพื้นที่ () . สองคลาสที่แตกต่างกันใช้เหมือนกัน รับพื้นที่ () ฟังก์ชัน แต่เอาต์พุตสำหรับทั้งสองกรณีจะแตกต่างกัน
#รวมถึง
โดยใช้ เนมสเปซ มาตรฐาน ;
ระดับ รูปร่าง
{
สาธารณะ :
เสมือน นานาชาติ เกทาเรีย ( ) = 0 ;
เป็นโมฆะ กำหนดความกว้าง ( นานาชาติ วธ )
{
ความกว้าง = วธ ;
}
เป็นโมฆะ กำหนดความยาว ( นานาชาติ ล )
{
ความยาว = ล ;
}
มีการป้องกัน :
นานาชาติ ความกว้าง ;
นานาชาติ ความยาว ;
} ;
ระดับ สี่เหลี่ยมผืนผ้า : สาธารณะ รูปร่าง
{
สาธารณะ : นานาชาติ เกทาเรีย ( )
{
กลับ ( ความกว้าง * ความยาว ) ;
}
} ;
ระดับ สามเหลี่ยม : สาธารณะ รูปร่าง
{
สาธารณะ : นานาชาติ เกทาเรีย ( )
{
กลับ ( ความกว้าง * ความยาว ) / 2 ;
}
} ;
นานาชาติ หลัก ( เป็นโมฆะ )
{
สี่เหลี่ยมผืนผ้า R ;
สามเหลี่ยม T ;
ร. กำหนดความกว้าง ( 9 ) ;
ร. กำหนดความยาว ( 5 ) ;
ศาล << 'พื้นที่สี่เหลี่ยมผืนผ้า: ' << ร. เกทาเรีย ( ) << จบ ;
ต. กำหนดความกว้าง ( 9 ) ;
ต. กำหนดความยาว ( 5 ) ;
ศาล << 'พื้นที่สามเหลี่ยม: ' << ต. เกทาเรีย ( ) << จบ ;
กลับ 0 ;
}
เอาต์พุต
ความสำคัญของอินเทอร์เฟซ
คลาสใดก็ตามที่มาจากคลาสนามธรรมล้วน (อินเทอร์เฟซ) ควรใช้เมธอดแต่ละเมธอดของคลาสพื้นฐาน เช่น อินเทอร์เฟซเสมอ พอยน์เตอร์อินเทอร์เฟซสามารถส่งผ่านไปยังฟังก์ชันและคลาสได้ ทำให้เราสามารถเรียกฟังก์ชันของคลาสที่ได้รับจากตรงนั้นได้
กฎสำหรับการใช้อินเทอร์เฟซคืออะไร
มีกฎต่อไปนี้ที่ผู้ใช้ควรปฏิบัติตามสำหรับการใช้อินเทอร์เฟซใน C++:
- ประกาศเฉพาะฟังก์ชันเสมือนเท่านั้น
- กำหนดเพียง 0 ให้กับฟังก์ชันเสมือนล้วน
- อย่าสร้างอินเทอร์เฟซของคลาส
- การใช้การอ้างอิงถึงคลาสนามธรรมพื้นฐาน เราสามารถสร้างตัวชี้ไปยังอินสแตนซ์ของคลาสที่ได้รับมา
ในโค้ดต่อไปนี้ อินเทอร์เฟซ ลินุกซ์ เช่นเดียวกับคลาสนามธรรมที่ถูกสร้างขึ้นโดยใช้เมธอดเสมือนจริง เช่นเดียวกับฟังก์ชันที่ใช้ในคลาสลูก และเราเรียกว่า returnString() เมธอดในฟังก์ชันหลักโดยทำตามกฎอินเตอร์เฟส
#รวมถึง#รวมถึง
#รวมถึง <สตริง>
โดยใช้ เนมสเปซ มาตรฐาน ;
ระดับ ลินุกซ์
{
สาธารณะ :
เสมือน สตริง returnString ( ) = 0 ;
} ;
ระดับ เด็ก : สาธารณะ ลินุกซ์
{
สาธารณะ :
สตริง returnString ( )
{
กลับ “สวัสดีลินุชินต์” ;
}
} ;
นานาชาติ หลัก ( )
{
เด็ก child_object ;
ลินุกซ์ * พน ;
พน = & child_object ;
ศาล < returnString ( ) ;
กลับ 0 ;
}
เอาต์พุต
บทสรุป
อินเทอร์เฟซเป็นคลาสเชิงนามธรรมที่อธิบายถึงพฤติกรรมของคลาสที่ต้องใช้คลาสที่จำเป็นใน C ++ แนวทางที่กล่าวถึงข้างต้นมีความสำคัญสำหรับผู้เริ่มต้นในการพัฒนาทักษะการเขียนโปรแกรม C ++ ด้วยการทำงานกับอินเทอร์เฟซ คุณจะพบตัวอย่างบางอย่างที่จะช่วยให้คุณเรียนรู้การใช้งานอินเทอร์เฟซใน C ++