หลีกเลี่ยงข้อผิดพลาดที่มุ่งเน้นวัตถุย้ายจาก C ทำงานอะไรให้คุณ

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

ฉันมีหลักสูตรมหาวิทยาลัยใน OOP และเข้าใจพื้นฐานของการห่อหุ้มข้อมูลที่เป็นนามธรรมข้อมูลที่หลากหลายรูปแบบโมดูลย่อยและมรดก

ผมอ่าน/programming/2688910/learning-to-think-in-the-object-oriented-wayและ/programming/1157847/learning-object-oriented-thinking , และจะดูหนังสือบางเล่มที่ชี้ไปยังคำตอบเหล่านั้น

ฉันคิดว่าโครงการขนาดกลางถึงขนาดใหญ่หลายแห่งของฉันจะได้รับประโยชน์จากการใช้ OOP อย่างมีประสิทธิภาพ แต่ในฐานะมือใหม่ฉันต้องการหลีกเลี่ยงข้อผิดพลาดที่ใช้เวลานานและเสียเวลา

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

ฉันกำลังคิดตามแนวของบางอย่างเช่น "เป็นเรื่องปกติหรือไม่ที่จะมีผู้สังเกตการณ์และวิธีการปรับเปลี่ยนจำนวนพอสมควรและใช้ตัวแปรส่วนตัวหรือมีเทคนิคสำหรับการรวม / ลดพวกมัน?"

ฉันไม่กังวลเกี่ยวกับการใช้ C ++ เป็นภาษา OO บริสุทธิ์หากมีเหตุผลที่ดีในการผสมวิธีการ (เตือนความจำถึงเหตุผลในการใช้ GOTO แม้ว่าจะ จำกัด อยู่เพียงเล็กน้อย)

ขอบคุณ!

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

อย่างแรกคือความผิดพลาดของการเปิดเผยข้อมูลมากเกินไป เริ่มต้นควรจะเป็นไม่ได้privatepublic

หลังจากนั้นมา getters / setters มากเกินไป สมมติว่าฉันมีสมาชิกข้อมูล ฉันจริงๆต้องข้อมูลนี้ในระดับอื่น ๆ ตกลงทำให้ทะเยอทะยาน ฉันจริงๆ reaallyต้องเปลี่ยนข้อมูลนี้ในช่วงอายุการใช้งานของวัตถุ? จากนั้นทำสุนัขเซทเทอร์

โปรแกรมเมอร์มือใหม่ส่วนใหญ่มีค่าเริ่มต้นในการสร้าง getter / setter สำหรับสมาชิกข้อมูลทุกคน กลุ่มการเชื่อมต่อนี้และมักจะเป็นตัวเลือกการออกแบบที่ไม่ดี

เมื่อฉันข้ามช่องว่างนั้นฉันตัดสินด้วยวิธีการต่อไปนี้:

0) ฉันเริ่มต้นช้าด้วยแอพขั้นตอนขนาดเล็ก / กลางและไม่มีสิ่งที่สำคัญต่อการทำงาน

1) การทำแผนที่ 1st-pass แบบง่าย ๆ ว่าฉันจะเขียนโปรแกรมตั้งแต่เริ่มต้นในลักษณะ OO ได้อย่างไรที่สำคัญที่สุดสำหรับฉันในเวลานั้นและนี่คืออัตนัย - คือการหาคลาสพื้นฐานทั้งหมด วัตถุของฉันคือแค็ปซูลให้มากที่สุดในคลาสฐาน วิธีเสมือนบริสุทธิ์สำหรับทุกสิ่งที่เป็นไปได้ในคลาสฐาน

2) จากนั้นขั้นตอนต่อไปคือสร้างการสืบทอด

3) ขั้นตอนสุดท้ายคือ - ในรหัสขั้นตอนเดิมแยกโครงสร้างข้อมูลออกจากรหัสผู้สังเกตการณ์ / ตัวแก้ไข จากนั้นใช้การซ่อนข้อมูลและแมปข้อมูลทั่วไปทั้งหมดลงในคลาสฐานและในคลาสย่อยนั้นเป็นข้อมูลที่ไม่ธรรมดาในโปรแกรม และการรักษาแบบเดียวกันสำหรับผู้สังเกตการณ์ / รหัสปรับปรุง - ตรรกะ 'ใช้ทุกที่' ไปสู่คลาสพื้นฐาน และดู / แก้ไขตรรกะที่ทำหน้าที่เฉพาะในส่วนย่อยของข้อมูลที่เข้าไปในชั้นเรียนที่ได้รับ

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

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

ข้อมูลทั้งหมดใน OOP ควรเป็นส่วนตัวหรือได้รับการคุ้มครองทั้งนี้ขึ้นอยู่กับผู้ที่คุณคุยด้วยและมีให้เฉพาะผ่าน accessors และ mutators โดยทั่วไปแล้วฉันคิดว่านี่เป็นวิธีปฏิบัติที่ดี แต่มีหลายครั้งที่ฉันแตกต่างจากบรรทัดฐานนี้ ตัวอย่างเช่นถ้าคุณมีคลาส (ใน Java สมมติว่า) ผู้ที่มีจุดประสงค์เพียงอย่างเดียวคือการเก็บข้อมูลบางส่วนไว้ในหน่วยทางลอจิคัลมันเหมาะสมที่จะปล่อยให้ฟิลด์เป็นแบบสาธารณะ หากเป็นแคปซูลที่ไม่เปลี่ยนรูปให้ทำเครื่องหมายสุดท้ายและเริ่มต้นในตัวสร้าง สิ่งนี้จะลดคลาส (ในตัวอย่างนี้) ให้น้อยกว่าโครงสร้าง (ในความเป็นจริงโดยใช้ C ++ คุณควรเรียกโครงสร้างนี้ว่าทำงานได้เหมือนคลาส แต่การมองเห็นเริ่มต้นเป็นสาธารณะและคุณตั้งใจชัดเจนขึ้น) ฉันคิดว่าคุณจะพบว่าการใช้มันสะดวกสบายกว่าในกรณีเหล่านี้

สิ่งหนึ่งที่คุณไม่ต้องการทำอย่างแน่นอนคือมีเขตข้อมูลที่ต้องตรวจสอบความสม่ำเสมอในการเปลี่ยนแปลงและปล่อยให้สาธารณะ

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

ฉันไม่กังวลเกี่ยวกับการใช้ C ++ เป็นภาษา OO บริสุทธิ์หากมีเหตุผลที่ดีในการผสมวิธีการ (เตือนความจำถึงเหตุผลในการใช้ GOTO แม้ว่าจะ จำกัด อยู่เพียงเล็กน้อย)

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

จากมุมมองของ OO ฉันคิดว่า C ++ นั้นสั้นไปหน่อย ตัวอย่างความคิดของการมีฟังก์ชั่นที่ไม่ใช่เสมือนคือการทำเครื่องหมายในส่วนนี้ ฉันเคยมีข้อโต้แย้งกับคนที่ไม่เห็นด้วยกับฉัน แต่สมาชิกที่ไม่ใช่เสมือนเพียงแค่ไม่สอดคล้องกับกระบวนทัศน์เท่าที่ฉันกังวล Polymorphism เป็นองค์ประกอบสำคัญของ OO และคลาสที่มีฟังก์ชั่นที่ไม่ใช่เสมือนไม่ใช่ polymorphic ในความหมาย OO ดังนั้นในภาษา OO ฉันคิดว่า C ++ ค่อนข้างอ่อนแอเมื่อเปรียบเทียบกับภาษาอย่าง Java หรือ Objective-C

การเขียนโปรแกรมทั่วไปในทางกลับกัน C ++ มีอันนี้ค่อนข้างดี ฉันเคยได้ยินว่ามีภาษาที่ดีกว่าสำหรับเรื่องนี้เช่นกัน แต่การรวมกันของวัตถุและฟังก์ชั่นทั่วไปเป็นสิ่งที่ค่อนข้างทรงพลังและแสดงออก นอกจากนี้ยังสามารถแช่งอย่างรวดเร็วทั้งในเวลาการเขียนโปรแกรมและเวลาในการประมวลผล มันอยู่ในพื้นที่นี้ที่ฉันคิดว่า C ++ ส่องประกาย แต่ยอมรับว่ามันอาจจะดีกว่า (เช่นการสนับสนุนภาษาสำหรับแนวคิดเป็นต้น) มีคนคิดว่าพวกเขาควรยึดติดกับกระบวนทัศน์ของ OO และปฏิบัติต่อผู้อื่นตามคำสั่งของคำสั่ง goto ในระดับของการผิดศีลธรรมจริง ๆ หายไปโดยไม่ได้ดูกระบวนทัศน์นี้

metaprogramming ของเทมเพลตก็ค่อนข้างน่าประทับใจเช่นกัน ลองดูตัวอย่าง Boost.Units library ไลบรารีนี้จัดเตรียมการสนับสนุนชนิดสำหรับปริมาณมิติ ฉันใช้ห้องสมุดนี้อย่างกว้างขวางใน บริษัท วิศวกรรมที่ฉันทำงานอยู่ มันเพียงแค่ให้ข้อเสนอแนะที่มากขึ้นทันทีสำหรับด้านหนึ่งของโปรแกรมเมอร์ที่เป็นไปได้หรือแม้กระทั่งข้อผิดพลาดของข้อกำหนด เป็นไปไม่ได้ที่จะรวบรวมโปรแกรมที่ใช้สูตรที่ทั้งสองด้านของตัวดำเนินการ '=' ไม่เทียบเท่ากันในมิติ ฉันเองไม่มีประสบการณ์กับภาษาอื่นที่เป็นไปได้และไม่แน่นอนกับภาษาที่มีพลังและความเร็วของ C ++

Metaprogramming เป็นกระบวนทัศน์การทำงานอย่างหมดจด

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

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

@nightcracker

อย่างแรกคือความผิดพลาดของการเปิดเผยข้อมูลมากเกินไป ค่าเริ่มต้นควรเป็นแบบส่วนตัวไม่ใช่แบบสาธารณะ หลังจากนั้นมา getters / setters มากเกินไป

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

Dominic Gurto

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

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

wantTheBest

ฉันเริ่มช้าด้วยแอพขั้นตอนขนาดเล็ก / กลางและไม่มีสิ่งที่สำคัญต่อภารกิจในการทำงาน ในโค้ดโพรซีเดอร์ดั้งเดิมแยกโครงสร้างข้อมูลออกจากโค้ด obsever / modifier

มันสมเหตุสมผลมาก ... ฉันชอบความคิดในการทำให้สิ่งต่าง ๆ ทำงานอยู่ตลอดเวลา แต่เพื่อสร้างสิ่งที่ไม่สำคัญกับชั้นเรียน

JPM

สิ่งหนึ่งที่คุณไม่ต้องการทำอย่างแน่นอนคือมีเขตข้อมูลที่ต้องตรวจสอบความสม่ำเสมอในการเปลี่ยนแปลงและปล่อยให้สาธารณะ

ฉันรู้มาพักหนึ่งแล้วว่านี่เป็นหนึ่งในจุดแข็งของการห่อหุ้มข้อมูล ... ความสามารถในการบังคับใช้ความมั่นคงและสำหรับเงื่อนไข / ช่วง / ฯลฯ

Crazy Eddie

มีคนคิดว่าพวกเขาควรยึดติดกับกระบวนทัศน์ของ OO และปฏิบัติต่อผู้อื่นตามคำสั่งของคำสั่ง goto ในระดับของการผิดศีลธรรมจริง ๆ หายไปโดยไม่ได้ดูกระบวนทัศน์นี้ metaprogramming ของเทมเพลตก็ค่อนข้างน่าประทับใจเช่นกัน

ฉันคิดถึงคำตอบของ Crazy Eddie บ่อยมากฉันคิดว่าเพราะฉันไม่ได้อ่านในบางหัวข้อที่กล่าวถึง ... เช่น metaprogramming ฉันคิดว่าข้อความที่ยอดเยี่ยมในโพสต์ของ CE คือ C ++ เป็นการผสมผสานระหว่างความสามารถและสไตล์ที่แต่ละคนควรนำมาใช้ให้เกิดประโยชน์สูงสุด ... รวมถึงความจำเป็นถ้านั่นคือสิ่งที่สมเหตุสมผล

ขอบคุณอีกครั้งสำหรับทุกคนที่ตอบกลับ!

ข้อผิดพลาดที่ใหญ่ที่สุดคือความเชื่อที่ว่า OOP เป็นกระสุนเงินหรือเป็น "กระบวนทัศน์ที่สมบูรณ์แบบ"