ฟังก์ชั่น Namespace + กับวิธีการคงที่ในชั้นเรียน

สมมติว่าฉันมีหรือกำลังจะเขียนชุดของฟังก์ชั่นที่เกี่ยวข้อง สมมติว่าพวกเขาเกี่ยวข้องกับคณิตศาสตร์ ฉันควร:

1. เขียนฟังก์ชั่นเหล่านี้และใส่ไว้ในMyMathเนมสเปซของฉันและอ้างอิงผ่านMyMath::XYZ()
2. สร้างชั้นเรียนที่เรียกว่าMyMathและทำให้วิธีการเหล่านี้คงที่และอ้างถึงในทำนองเดียวกันMyMath::XYZ()

เหตุใดฉันจึงเลือกหนึ่งรายการเพื่อจัดระเบียบซอฟต์แวร์ของฉัน

โดยค่าเริ่มต้นใช้ฟังก์ชั่น namespaced

คลาสจะสร้างวัตถุไม่ใช่เพื่อแทนที่เนมสเปซ

ในรหัสเชิงวัตถุ

Scott Meyers เขียนรายการทั้งหมดสำหรับหนังสือ Effective C ++ ของเขาในหัวข้อนี้ "ชอบฟังก์ชั่นที่ไม่ใช่สมาชิกที่ไม่ใช่สมาชิกในฟังก์ชั่นสมาชิก" ฉันพบการอ้างอิงออนไลน์กับหลักการนี้ในบทความจาก Herb Sutter:http://www.gotw.ca/gotw/084.htm

สิ่งสำคัญที่ควรทราบคือ: ในฟังก์ชั่น C ++ ในเนมสเปซเดียวกันกับคลาสที่อยู่ในอินเทอร์เฟซของคลาสนั้น (เนื่องจากADLจะค้นหาฟังก์ชันเหล่านั้นเมื่อแก้ไขการเรียกใช้ฟังก์ชัน)

ฟังก์ชั่น Namespaced เว้นแต่จะประกาศ "เพื่อน" ไม่มีการเข้าถึงภายในของชั้นเรียนในขณะที่วิธีการคงที่มี

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

ส่วนขยาย I

การเพิ่มโค้ดให้กับส่วนติดต่อของคลาส

ใน C # คุณสามารถเพิ่มวิธีการในชั้นเรียนแม้ว่าคุณจะไม่สามารถเข้าถึงได้ แต่ใน C ++ นี่เป็นไปไม่ได้

แต่ยังคงอยู่ใน C ++ คุณยังสามารถเพิ่มฟังก์ชันเนมสเปซได้แม้กระทั่งกับคลาสที่มีคนเขียนให้คุณ

ดูจากอีกด้านหนึ่งซึ่งเป็นสิ่งสำคัญเมื่อออกแบบรหัสของคุณเพราะเมื่อใส่ฟังก์ชั่นของคุณในเนมสเปซคุณจะอนุญาตให้ผู้ใช้เพิ่ม / ทำอินเทอร์เฟซของคลาสให้สมบูรณ์

ส่วนขยาย II

ผลข้างเคียงของจุดก่อนหน้าเป็นไปไม่ได้ที่จะประกาศวิธีคงที่ในหลายหัว ทุกวิธีจะต้องประกาศในคลาสเดียวกัน

สำหรับเนมสเปซฟังก์ชันจากเนมสเปซเดียวกันสามารถประกาศได้ในหลายหัว (ฟังก์ชั่นการแลกเปลี่ยนเกือบเป็นมาตรฐานเป็นตัวอย่างที่ดีที่สุด)

ส่วนขยาย III

coolness พื้นฐานของเนมสเปซคือในบางโค้ดคุณสามารถหลีกเลี่ยงการกล่าวถึงมันหากคุณใช้คำสำคัญ "using":

#include <string>
#include <vector>

// Etc.
{
   using namespace std ;
   // Now, everything from std is accessible without qualification
   string s ; // Ok
   vector v ; // Ok
}

string ss ; // COMPILATION ERROR
vector vv ; // COMPILATION ERROR

และคุณสามารถ จำกัด "มลภาวะ" ให้เหลือหนึ่งคลาสด้วย:

#include <string>
#include <vector>

{
   using std::string ;
   string s ; // Ok
   vector v ; // COMPILATION ERROR
}

string ss ; // COMPILATION ERROR
vector vv ; // COMPILATION ERROR

"รูปแบบ" นี้จำเป็นสำหรับการใช้สำนวนแลกเปลี่ยนที่เกือบจะเป็นมาตรฐาน

และนี่เป็นไปไม่ได้ที่จะทำอย่างไรกับวิธีการคงที่ในชั้นเรียน

ดังนั้นเนมสเปซ C ++ จึงมีความหมายของตัวเอง

แต่มันจะไปไกลกว่านั้นเมื่อคุณสามารถรวม namespaces ในลักษณะที่คล้ายกับการสืบทอด

ตัวอย่างเช่นถ้าคุณมีเนมสเปซ A ที่มีฟังก์ชัน AAA, เนมสเปซ B ที่มีฟังก์ชั่น BBB คุณสามารถประกาศเนมสเปซ C และนำ AAA และ BBB ในเนมสเปซนี้โดยใช้คำหลัก

ข้อสรุป

เนมสเปซใช้สำหรับเนมสเปซ คลาสสำหรับคลาส

C ++ ได้รับการออกแบบเพื่อให้แต่ละแนวคิดมีความแตกต่างกันและมีการใช้แตกต่างกันในกรณีที่แตกต่างกันเพื่อแก้ปัญหาที่แตกต่างกัน

อย่าใช้คลาสเมื่อคุณต้องการเนมสเปซ

และในกรณีของคุณคุณต้องมีเนมสเปซ

มีคนมากมายที่ไม่เห็นด้วยกับฉัน แต่นี่คือวิธีที่ฉันเห็น:

คลาสนั้นเป็นนิยามของวัตถุชนิดหนึ่ง วิธีการสแตติกควรกำหนดการดำเนินงานที่เชื่อมโยงกับคำนิยามของวัตถุนั้น

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

ตัวอย่างเช่นในกรณีของคุณถามตัวเองว่า "MyMath คืออะไร" หากMyMathไม่ได้กำหนดประเภทของวัตถุฉันจะพูดว่า: อย่าทำให้เป็นคลาส

แต่อย่างที่ฉันพูดฉันรู้ว่ามีคนมากมายที่ไม่เห็นด้วยกับฉันเกี่ยวกับเรื่องนี้ (โดยเฉพาะนักพัฒนา Java และ C #)

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

มิฉะนั้นใช้ฟังก์ชั่น namespaced

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

template<typename T, int decimalPlaces>
class MyMath
{
   // routines operate on datatype T, preserving at least decimalPlaces precision
};

// math routines for manufacturing calculations
typedef MyMath<double, 4> CAMMath;
// math routines for on-screen displays
typedef MyMath<float, 2> PreviewMath;

หากคุณไม่ต้องการสิ่งนั้นโดยทั้งหมดให้ใช้เนมสเปซ

คุณควรใช้เนมสเปซเนื่องจากเนมสเปซมีข้อดีกว่าคลาส:

• คุณไม่จำเป็นต้องกำหนดทุกอย่างในส่วนหัวเดียวกัน
• คุณไม่จำเป็นต้องเปิดเผยการนำไปใช้ทั้งหมดของคุณในส่วนหัว
• คุณไม่สามารถusingเป็นสมาชิกคลาสได้ คุณสามารถusingเป็นสมาชิกเนมสเปซ
• คุณทำไม่ได้using classแต่using namespaceไม่ใช่ทั้งหมดที่เป็นความคิดที่ดี
• การใช้คลาสหมายความว่ามีบางวัตถุที่จะสร้างเมื่อไม่มีจริง ๆ

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

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

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

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