ฉันจะอธิบายการเขียนโปรแกรมเชิงวัตถุให้กับผู้ที่มีรหัสเฉพาะใน Fortran 77 ได้อย่างไร

แม่ของฉันทำวิทยานิพนธ์ที่วิทยาลัยใน Fortran และตอนนี้ (มากกว่าทศวรรษต่อมา) จำเป็นต้องเรียนรู้ c ++ สำหรับการจำลองสถานการณ์ของไหล เธอสามารถเข้าใจการเขียนโปรแกรมขั้นตอนทั้งหมด แต่ไม่ว่าฉันจะพยายามอธิบายวัตถุให้ยากแค่ไหนมันก็ไม่ติด (ฉันทำงานกับ Java มากฉันรู้ว่าวัตถุทำงานอย่างไร) ฉันคิดว่าฉันอาจอธิบายได้ในระดับสูงเกินไปดังนั้นจึงไม่สมเหตุสมผลกับคนที่ไม่เคยทำงานกับพวกเขาเลยและเติบโตขึ้น ขึ้นในยุคของการเขียนโปรแกรมขั้นตอนอย่างหมดจด

มีวิธีง่าย ๆ ที่ฉันสามารถอธิบายให้เธอฟังซึ่งจะช่วยให้เธอเข้าใจหรือไม่?

คำตอบสั้น ๆ : ไม่

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

OOP เป็นวิธีการจัดระเบียบตัวแปรและชิ้นส่วนของรหัส มีกี่รูปแบบที่จะกำหนด OOP 25? 30? แม้แต่ครูที่เรียนรู้ OOP จากภาษาและภูมิหลังที่แตกต่างกันก็ไม่เห็นด้วยกับคำจำกัดความของตัวเองดังนั้น ... มันจะง่ายได้อย่างไร?

ฉันไม่รู้ว่าคุณมาอย่างไร แต่เนื่องจากแม่ของคุณมีประสบการณ์คล้ายกับฉันฉันสามารถบอกคุณได้ว่าฉันมาถึงอย่างไร

ฉันกำลังเขียนโปรแกรมใน C ในโครงการขนาดใหญ่มาก มันคือปี 1988 โปรแกรมเมอร์หลายคนจัดโมดูลและไลบรารีด้วยความยากลำบากในการหลีกเลี่ยงการรบกวนในงานอื่น ๆ และทำให้การแบ่งหน้าที่ที่ดี

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

ในปี 1996 มันง่ายมากที่จะค้นพบว่า structs เหล่านั้นมีชื่อว่า "คลาส" และตัวชี้ฟังก์ชั่นเหล่านั้นถูกแทนที่ด้วยฟังก์ชั่นสมาชิกและฟังก์ชั่นเสมือนหรือเชื่อมโยงไปยังวัตถุอื่น (เรียกพฤติกรรม) โดยโปรแกรมเมอร์อื่น ๆ

ฉันเริ่มเข้าใจ OOP เมื่อฉันรู้สึกถึงความต้องการ: แยกจากกันความแตกต่างและพฤติกรรมที่กำหนดไว้

วันนี้ฉันทำงานกับ OOP แต่ฉันไม่คิดว่ามันเป็นหลักคำสอนที่จะให้บริการ: เพียงแค่ "สำนวนทั่วไป" (ชุดของ ... ) ที่ให้เราพูดด้วยกันโดยไม่จำเป็นต้องให้คำอธิบายและคำอธิบายที่ยาวตลอดเวลา . ในความเป็นจริง "อนุสัญญา" มากกว่าสิ่งอื่นใด ท้ายที่สุดแล้วทั้งหมดของ OOP ก็คือ -again- "if then goto": มันทำแค่ "multilayered" ดังนั้นสิ่งที่เป็นนามธรรมและสำนวนมากกว่าสำนวน

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

ไม่มีใครคิดว่าจะ "จัดโต๊ะ" ถ้ามีแค่สี่สิ่งที่อยู่ด้านบน มันสมเหตุสมผลเมื่อสิ่งที่อยู่ด้านบนเริ่มรบกวนซึ่งกันและกัน นั่นเป็นเวลาที่ OOP จะเข้ามา

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

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

ฉันขอแนะนำหนังสือที่ดีสำหรับผู้ที่ต้องการเข้าใกล้ C ++: เร่ง C ++ : มันจะนำคุณเข้าสู่สำนวน C ++ โดยไม่ต้องแกล้งทำตามหลักคำสอนที่กำหนดไว้ล่วงหน้า

เพื่อนเก่าอ้างว่าฉันมีคำจำกัดความที่สั้นที่สุดที่เขารู้เกี่ยวกับการเขียนโปรแกรม OO และฉันพบว่ามันใช้งานได้สำหรับบางคน (ไม่ใช่เพื่อคนอื่น):

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

ความคิดคือการทำให้คนคิดแตกต่างกันเกี่ยวกับวิธีการทำสิ่งต่าง ๆ ในโปรแกรมของพวกเขา

บอกให้เธอนึกถึงวัตถุต่าง ๆ เช่นสิ่งของในโลกแห่งความเป็นจริง ยกตัวอย่างเช่นโลกทั้งใบสามารถผสมกันของการเขียนโปรแกรมเชิงวัตถุ (ใน C ++) กับการเขียนโปรแกรมเชิงหน้าที่บางอย่าง

ใช้วัตถุตัวอย่างเช่นเครื่องตัดหญ้ามีคุณสมบัติบางอย่างและสามารถทำบางสิ่งได้ (วัตถุและคลาส)

จากนั้นบอกเธอเกี่ยวกับเครื่องตัดหญ้าที่ดีกว่าซึ่งเป็นส่วนขยายของเครื่องตัดหญ้าที่คุณมีอยู่แล้ว บอกเธอดีกว่า แต่ยังคงสร้างกลไกแบบเดียวกัน (การสืบทอด)

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

เมื่อเธอได้รับสิ่งนี้บอกเธอเกี่ยวกับวิธีการนำสิ่งเหล่านี้ไปใช้ในภาษาที่เธอต้องเรียนรู้ (C ++)

จากนั้นบอกเธอว่าถ้าเธอต้องเขียนแบบจำลองของโลกนี้ในโลกคอมพิวเตอร์เธอจะต้องเรียนรู้วิธีการทำ

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

ฉันไปจากแอสเซมเบลอร์และภาษาโคบอลกับรูบีแล้ว

สิ่งที่ช่วยฉันในตอนแรกคือการเพิกเฉยต่อแนวคิดของคลาสที่สร้างอินสแตนซ์

เพียงแค่เริ่มต้นด้วยรหัส มีคลาส แต่เพิ่งมีวิธีการระดับชั้นเรียน ภายในวิธีการต่างๆมากมายเกี่ยวกับพารามิเตอร์ตัวแปรเงื่อนไขอาร์เรย์สตริงบูลีน ฯลฯ สิ่งนี้ควรคุ้นเคย

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

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

นั่นเป็นการเริ่มต้น

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

หมายเหตุ: เงื่อนไขของฉันมาจาก ruby ​​ไม่ใช่ c ++ ดังนั้นคุณอาจจำเป็นต้องแปล

ฉันจะอธิบายในสองขั้นตอนหรือสี่ขั้นขึ้นอยู่กับว่าคุณต้องการแยกแนวคิดของคุณมากแค่ไหน

ขั้นตอนที่ 1: แนะนำเธอกับโครงสร้าง มันเป็นขั้นตอนเล็ก ๆ จากประเภทข้อมูล Fortran ไปยังโครงสร้าง ขั้นตอนที่ 1a: ตรวจสอบให้แน่ใจว่าเธอเข้าใจการจัดสรรหน่วยความจำแบบไดนามิกและพอยน์เตอร์

ขั้นตอนที่ 2: เพิ่มขั้นตอนที่เกี่ยวข้องกับโครงสร้างเหล่านั้นเท่านั้น ขั้นตอนที่ 2a: เพิ่มการสืบทอดตามการสร้างโครงสร้างขนาดใหญ่ซึ่ง "ห่อ" โครงสร้างขนาดเล็ก

สำหรับโปรแกรมเมอร์ของฟอร์แทรนปัจจัย "ว้าว" จะเป็นสิ่งที่คอมไพเลอร์ต้องติดตาม ได้. นั่นคือสิ่งที่คอมไพเลอร์มีไว้สำหรับ ...

ถ้าเธอทำวิทยานิพนธ์เมื่อสิบปีที่แล้วเธออาจใช้ Fortan 90 หรือ 95 ซึ่งในกรณีนี้สิ่งที่จะพูดเกี่ยวกับมันนั้นสัมพันธ์กับชนิดข้อมูลที่ได้รับ ถ้านานมาแล้วที่เธอใช้ Fortran 77 ให้แนะนำเธอกับชนิดข้อมูลที่ได้รับใน Fortran 90 แล้วพูดถึงมัน ...

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

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

ในการเขียนโปรแกรมที่ไม่ใช่เชิงวัตถุหากมีการใช้ชนิดข้อมูลที่แยกต่างหากสำหรับ Tree และ LinkedList หนึ่งจะต้องใช้วิธีการที่แตกต่างกันสำหรับการเพิ่มโหนดให้กับแต่ละ ไม่ใช่ภาษาเชิงวัตถุจะโดยทั่วไปเต้นแร้งเต้นกาถ้าใครพยายามที่จะตั้งชื่อทั้งสองวิธีAddItemตั้งแต่ชื่อใดก็ตามสามารถอ้างถึงวิธีการหนึ่งจึงนำหนึ่งในการสร้างชื่อวิธีเช่นAddTreeItem, AddLinkedListItem, RemoveTreeItemฯลฯ วิธีการดังกล่าวประพฤติ แต่มันเป็นบิต น่าเกลียด แนวคิดวิธีการAddTreeItemและRemoveTreeItemดูเหมือนจะอยู่ด้วยกัน แต่ชื่อไม่เรียงลำดับเช่นนั้น หนึ่งสามารถเขียนชื่อเป็นTreeAddItem, TreeRemoveItem,LinkedListAddItemเป็นต้น แต่นั่นจะทำให้เกิด "เสียงซ้ำซ้อน" ในตอนเริ่มต้นของการเรียกใช้แต่ละวิธี การเรียกใช้เมธอดส่วนใหญ่ในโปรแกรมทั่วไปจะมีข้อมูลสำคัญสามส่วน: (1) ส่วนของซอร์สโค้ดมีวิธีใดบ้าง (2) วิธีการใดในส่วนที่ใช้อยู่ (3) ข้อมูลส่วนใดที่กำลังดำเนินการอยู่ ในหลายกรณีประเภทของข้อมูลที่ถูกดำเนินการจะเพียงพอที่จะระบุว่าส่วนของรหัสเป็นวิธีการใดดังนั้นส่วนที่ (1) ของข้อมูลข้างต้นซ้ำซ้อน การระบุเนื้อหาในตอนเริ่มต้นของข้อความง่ายกว่าวัสดุที่อื่นดังนั้นรูปแบบการเข้ารหัส / การตั้งชื่อก็TreeAddItem(myTree, whatever)จะวางข้อมูลที่มีประโยชน์น้อยที่สุดไว้ในจุดที่สำคัญ

ในทางตรงกันข้ามการใช้การเขียนโปรแกรมเชิงวัตถุหนึ่งจะได้อย่างมีประสิทธิภาพวิธีการตั้งชื่อเป็นTree.AddItemฯลฯ และงบเช่นmyTree.AddItem(whatever)จะทำให้เกิดคอมไพเลอร์ที่จะบอกว่าเป็นหลัก "อืม ... myTreeเป็นประเภทTreeเพื่อให้รหัสนี้ควรเรียกTree.AddItem(). มันไม่จำเป็นที่จะต้อง ระบุTree.เมื่อเรียกAddItemตั้งแต่คอมไพเลอร์รู้ประเภทของmyTreeแนวคิดแนวคิดคำสั่งmyTree.AddItem(whatever)เทียบเท่าTree.AddItem(myTree, whatever)และภาษาเชิงวัตถุบางอย่างอาจอนุญาตให้ทั้งสองรูปแบบเทียบเท่าในความเป็นจริงภาษาส่วนใหญ่ละเว้นพารามิเตอร์แรกจากฟังก์ชั่นฟังก์ชั่นและมี วิธีการที่กำหนดไว้ในชั้นเรียนเช่นTreeโดยปริยายใช้พารามิเตอร์ของประเภทTreeและกำหนดชื่อเช่นthis, หรือselfMe

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

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

• การมีเพศสัมพันธ์:การกำหนดการดำเนินการควบคู่ไปกับการแสดงข้อมูลที่มันทำงาน

• การรวมภายหลัง:เลือกการรวมกันของการแสดงข้อมูลและพฤติกรรมที่รันไทม์

• การห่อหุ้ม:สร้างความมั่นใจว่าข้อมูลนั้นถูกต้องโดยการสร้างและจะไม่ถูกยกเลิกในภายหลัง

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

ฉันขอแนะนำให้ดาวน์โหลด BlueJ เล่นกับมันเป็นเวลา 20 นาทีจากนั้นให้เธอเล่นกับมันเป็นเวลา 20 นาที

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

มันยังแสดงให้คุณเห็นถึงความแตกต่างโดยตรงระหว่างคลาสและวัตถุ

มันจะไม่ให้ข้อมูลเชิงลึกเกี่ยวกับรูปแบบการออกแบบ OO แต่จะให้ภาพรวมที่ยอดเยี่ยมของแนวคิด

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

ดังนั้นในความคิดของฉันวิธีที่ดีที่สุดในการอธิบายการวางแนววัตถุด้วย C ++ สำหรับผู้ใช้ F77 จะต้องดำเนินการอย่างเป็นขั้นตอน:

ขั้นแรกแนะนำผู้ใช้ให้รู้จักกับแนวคิดของการวางแนววัตถุในการตั้งค่าที่คุ้นเคยโดยแสดงวิธีการพัฒนาโครงสร้างคล้ายวัตถุใน Fortran 77 - ตัวอย่างเช่นดูเอกสารเช่น B. Patton "Object-oriented Fortran 77 (ผู้ปฏิบัติงาน) มุมมอง) "ฟอรั่ม SIGPLAN Fortran 12, 2 (1993), หน้า 23-24 และการอ้างอิงในนั้น

จากนั้นสร้างการโต้ตอบระหว่างโครงสร้างเหล่านั้นกับคลาส C ++ และเมธอด

สุดท้ายหารือเกี่ยวกับคุณสมบัติเพิ่มเติมที่ C ++ สามารถให้เพื่ออำนวยความสะดวกในการเขียนโปรแกรม OO

เมื่อฉันถูกโยกย้ายไปยังภาษาเชิงวัตถุจากการฝึกอบรมครั้งแรกของฉันใน Pascal, '.' ปัญหาก็เป็นเครื่องกีดขวางที่ใหญ่ที่สุดสำหรับฉันเช่นกัน ฉันใช้เวลาหลายปีกว่าจะผ่านมันไปได้

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

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

ช่วงเวลา aha สำหรับฉันคือเมื่อฉันรู้ว่าตัวชี้ระดับบนสุดนั้นเป็นเพียง namespace

ฉันขอแนะนำให้ให้เธอเขียนโค้ดจำนวนมากซึ่งต้องการให้เธอกำหนดชื่อฟังก์ชันของเธอโดยไม่ต้องใช้เครื่องหมายจุดเริ่มต้น จากนั้นให้เธอลองเขียนใหม่โดยใช้เครื่องหมายจุด

การออกกำลังกายแบบนั้นควรพาเธอไปที่จุดเริ่มต้น"สิ่งนี้คือคาถา?" อุปสรรค์

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