คำถามติดแท็ก naming

ฉันมักจะสับสนเกี่ยวกับไฟล์ส่วนหัว มันแปลกมาก: คุณรวมไฟล์. h ซึ่งไม่รวม. cpp แต่. cpp จะถูกคอมไพล์ด้วยเช่นกัน เมื่อเร็ว ๆ นี้ฉันเข้าร่วมโครงการของทีมและแน่นอนว่าจะใช้ทั้ง. h และ. cpp ฉันเข้าใจว่าสิ่งนี้สำคัญมาก แต่ฉันไม่สามารถอยู่กับการคัดลอกทุกการประกาศฟังก์ชันในแต่ละคลาสที่เรามี ฉันจะจัดการกับการประชุม 2 ไฟล์ได้อย่างมีประสิทธิภาพได้อย่างไร มีเครื่องมือใดบ้างที่จะช่วยเหลือหรือเปลี่ยนหนึ่งไฟล์ที่มีลักษณะตัวอย่างด้านล่างเป็น. h และ. cpp โดยอัตโนมัติ? (เฉพาะสำหรับ MS VC ++ 2010) class A { ... Type f(Type a,Type b) { //implementation here, not in another file! } ... }; Type f(Type …

25 c++  language-design  naming 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการถกเถียงอภิปรายโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน6 ปีที่ผ่านมา แนวปฏิบัติที่ดีที่สุดคืออะไรหลักการจัดการการตั้งชื่อที่ยอมรับกันทั่วไปสำหรับตัวแปรส่วนตัวใน C # private int myInteger; private int MyInteger; private int mMyInteger; private int _myInteger; private int _MyInteger; ตัวเลือกอื่น ๆ ที่ลึกลับ คุณใช้อันไหนและเพราะอะไร (บริษัท ของฉันค่อนข้างใหม่สำหรับ C # และฉันต้องการเลือกวิธี "ยอมรับในอุตสาหกรรม" มากที่สุดเพื่อลองใช้มาตรฐานการเข้ารหัสของเรา)

25 coding-standards  variables  naming 

เป็นวิธีที่ดีในการตั้งชื่อวิธีการที่ตรวจสอบว่า X จะต้องทำคืออะไรและ X มันถ้าจำเป็น? ตัวอย่างเช่นวิธีตั้งชื่อวิธีการที่จะอัพเดทรายชื่อผู้ใช้หากผู้ใช้ใหม่ได้เข้าสู่ระบบ? UpdateListIfNeededดูเหมือนจะนานเกินไปในขณะที่ความเรียบง่ายUpdateListหมายถึงการดำเนินการที่อาจมีราคาแพงและไม่จำเป็นทุกครั้ง EnsureListUpdatedเป็นตัวแปรเช่นกัน C # มีbool TryXXX(args, out result)รูปแบบ (เช่นint.TryParse(str, out num)) เพื่อตรวจสอบว่า X เป็นไปได้และทำมัน แต่นั่นแตกต่างอย่างละเอียด

23 language-agnostic  naming  coding-standards 

คำถามเปิดกว้างที่น่าอึดอัดใจ แต่มันเป็นปัญหาที่ฉันต้องเผชิญกับ: ซอฟต์แวร์ที่ง่ายต่อการบำรุงรักษาและใช้งานด้วยซอฟต์แวร์ที่ออกแบบมาอย่างดี การพยายามออกแบบให้ใช้งานง่ายหมายถึงการตั้งชื่อคอมโพเนนต์ของคุณในลักษณะที่นักพัฒนาซอฟต์แวร์รายต่อไปควรสามารถสรุปการทำงานของส่วนประกอบ นี่คือเหตุผลที่เราไม่ตั้งชื่อคลาสของเรา "Type1", "Type2" เป็นต้น เมื่อคุณกำลังสร้างแบบจำลองแนวคิดในโลกแห่งความเป็นจริง (เช่นลูกค้า) สิ่งนี้ง่ายเหมือนการตั้งชื่อประเภทของคุณหลังจากที่แนวคิดแบบโลกแห่งความจริงถูกจำลอง แต่เมื่อคุณสร้างสิ่งที่เป็นนามธรรมซึ่งเป็นระบบมากขึ้นมันง่ายมากที่จะหมดชื่อซึ่งง่ายต่อการอ่านและย่อยง่าย มันแย่ลง (สำหรับฉัน) เมื่อพยายามตั้งชื่อตระกูลประเภทโดยใช้ประเภทฐานหรือส่วนต่อประสานที่อธิบายถึงองค์ประกอบที่ต้องทำ แต่ไม่ใช่วิธีการทำงาน สิ่งนี้นำไปสู่แต่ละประเภทที่ได้มาโดยพยายามอธิบายถึงรสชาติของการนำไปใช้ (เช่นIDataConnectionและSqlConnectionใน. NET Framework) แต่คุณจะแสดงบางสิ่งที่ซับซ้อนเช่น "ทำงานโดยสะท้อนและมองหาชุดคุณลักษณะเฉพาะ" ได้อย่างไร จากนั้นเมื่อคุณเลือกชื่อสำหรับประเภทที่คุณคิดว่าอธิบายว่ามันกำลังพยายามทำอะไรเพื่อนร่วมงานของคุณถามว่า "WTF ทำสิ่งนี้ได้DomainSecurityMetadataProviderจริงหรือไม่ " มีเทคนิคที่ดีหรือไม่ในการเลือกชื่อที่มีความหมายดีสำหรับส่วนประกอบหรือจะสร้างกลุ่มขององค์ประกอบโดยไม่ต้องใช้ชื่อที่ยุ่งเหยิงหรือไม่? มีการทดสอบอย่างง่าย ๆ ที่ฉันสามารถนำไปใช้กับชื่อเพื่อให้เกิดความรู้สึกที่ดีขึ้นไม่ว่าจะเป็นชื่อ "ดี" หรือไม่

23 design  naming 

เป็นการยากที่จะบอกสิ่งที่ถูกถามที่นี่ คำถามนี้คลุมเครือคลุมเครือไม่สมบูรณ์กว้างเกินไปหรือโวหารและไม่สามารถตอบได้อย่างสมเหตุสมผลในรูปแบบปัจจุบัน สำหรับความช่วยเหลือในการทำความเข้าใจคำถามนี้เพื่อที่จะสามารถเปิด, ไปที่ศูนย์ช่วยเหลือ ปิดให้บริการใน8 ปีที่ผ่านมา ฉันค้นหาฟอรัม แต่ฉันไม่สามารถหาคำตอบได้ว่าทำไมจึงควรหลีกเลี่ยงเพียงเพราะเหตุใดมันจึงไม่ใช่กระสุนเงิน ดังนั้นฉันไม่คิดว่าคำถามนี้จะซ้ำกัน มีความถูกต้องเหตุผลว่าทำไมฉันควรยกเลิกระบบฮังการีฉันใช้เพื่อ? จนถึงตอนนี้ฉันเห็นประโยชน์ต่อไปนี้ในการใช้งาน: การตั้งชื่อตัวแปรที่สอดคล้องกัน คุณเห็นประเภทโดยไม่ต้องค้นหา (Intellisense ตาย / ทำดัชนีครึ่งเวลาดังนั้นจึงเป็นเหตุผลที่ถูกต้อง) ความหมายยังคงสามารถบรรจุลงในส่วนที่สองของชื่อ และติดตามข้อเสีย: มันทำให้บางคนรำคาญ (ไม่รู้เลยว่าทำไม) หากประเภทมีการเปลี่ยนแปลงประเภทอาจไม่ตรงกับการตั้งชื่อของตัวแปร (ฉันไม่คิดว่ามันเป็นเหตุผลที่ถูกต้องประเภทมีการเปลี่ยนแปลงน้อยและคุณมี "เปลี่ยนชื่อทั้งหมด") ดังนั้นทำไม: vector<string> vecCityNames; wstring strCity = L"abc"; //more code here vecCityNames.push_back(strCity); เลวร้ายยิ่งกว่า: vector<string> cityNames; wstring city = L"abc"; //more code here cityNames.push_back(city);//Are we pushing back int …

23 c++  naming 

วันนี้ฉันได้พูดคุยกับเพื่อนร่วมงานเกี่ยวกับการตั้งชื่อfinalฟิลด์ในคลาส Java ในfinalฟิลด์โอปี้ของเขาควรได้รับการพิจารณาว่าเป็นค่าคงที่เนื่องจากค่าของมันจะไม่เปลี่ยนแปลงหลังจากการสร้างอินสแตนซ์ สิ่งนี้จะนำไปสู่หลักการตั้งชื่อต่อไปนี้สำหรับfinalฟิลด์: public class Foo { private static final String BLA_BLA = "bla"; private final String BAR_BATZ; ... } ในความเห็นของฉันstatic finalควรพิจารณาเฉพาะเขตข้อมูลในขณะที่เขตข้อมูลที่finalควรปฏิบัติตามหลักการตั้งชื่อ camelCase ตามปกติเท่านั้น public class Foo { private static final String BLA = "bla"; private final String barBatz; ... } ตอนนี้ฉันค่อนข้างไม่แน่ใจเพราะเขาเป็นโปรแกรมเมอร์ที่มีประสบการณ์มากกว่าฉันและฉันมักจะเห็นด้วยกับความคิดเห็นของเขาและถือว่าเขาเป็นนักพัฒนาที่ดีมาก ข้อมูลใด ๆ เกี่ยวกับเรื่องนี้?

23 java  naming  final 

ฉันมักจะเห็นโครงการ (ในโครงการ Java และทีมงานใช้ Eclipse) pที่พารามิเตอร์ฟังก์ชั่นที่มีคำนำหน้า ตัวอย่างเช่น public void filter (Result pResult) ... โดยส่วนตัวฉันไม่เห็นประโยชน์ใด ๆ ในเรื่องนี้ แต่ต้องการทราบว่าการให้เหตุผลคืออะไร คำอธิบายที่ดีที่สุดที่ฉันเคยได้ยินคือการแยกชื่อของฟิลด์ที่มีชื่อเหมือนกันฉันมีปัญหากับคำอธิบายนั้น แต่ฉันสามารถเข้าใจประเด็นได้

22 java  coding-style  naming  eclipse  auto-completion 

หลังจากอ่านคำตอบของ gnatไปที่ทำไมวิธีหลักแบบคงที่ใน Java และ C # แทนที่จะเป็นตัวสร้าง? ฉันใช้คำตอบของเขาเพื่อหมายความว่าจุดประสงค์ของคลาส Java ที่มีเมธอด main static คือเพื่อdefine a program entry pointและไม่ได้หมายความว่าเป็นโปรแกรมเอง อาจมีวิธีที่ดีกว่าในการทำเช่นนี้ แต่ฉันมักจะมีชั้นเรียนที่มีวิธีหลักแบบคงที่เพื่อทำสิ่งที่ง่ายเช่นนี้ public class MenuLauncher { public static void main(String[] args) { Menu menu = new Menu(); menu.run(); } } โค้ดด้านบนจะเป็นแนวปฏิบัติที่ดีที่สุดสำหรับ OOP หรือไม่หากคลาสที่มีสแตติกหลักไม่ได้ทำอะไรมากไปกว่าการเริ่มต้นหรือเริ่มโปรแกรมตรรกะภายในวัตถุที่ไม่คงที่แยกต่างหาก หลังจากทั้งหมดหลักเป็นแบบคงที่ดังนั้นชั้น MenuLauncher จะไม่ถูก จำกัด มาก? เนื่องจาก main เป็นจุดเริ่มต้นฉันไม่เห็นจุดประสงค์อื่นใดสำหรับชั้นเรียนอื่นที่ไม่ใช่จุดเข้า มีแบบแผนการตั้งชื่อ Java …

21 java  naming  naming-standards  entry-point 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 7 ปีที่ผ่านมา เพียงแค่สงสัยว่าใครมีการประชุมที่ดีที่จะปฏิบัติตามในกรณีมุมมุมนี้ ฉันใช้ Java จริงๆ แต่คิดว่า C # folks อาจมีความเข้าใจที่ดีเช่นกัน สมมติว่าฉันกำลังพยายามตั้งชื่อคลาสที่คำสองคำติดต่อกันในชื่อคลาสเป็นตัวเลข (โปรดทราบว่าคำถามเดียวกันสามารถถามชื่อตัวระบุได้) ไม่สามารถเป็นตัวอย่างที่ดี แต่ลองนึกถึงบางอย่างเช่น "ค่า IEEE 802 16 บิต" การรวมตัวย่อติดต่อกันเป็น doable หากคุณยอมรับ classnames HttpUrlConnectionเช่น แต่มันอย่างจริงจังทำให้ฉันโยนขึ้นเล็ก ๆ น้อย ๆ IEEE80216BitValueที่จะคิดว่าการตั้งชื่อชั้นเรียน ถ้าฉันต้องเลือกฉันจะบอกว่ามันแย่ยิ่งกว่าIEEE802_16BitValueที่ดูเหมือนผิดพลาด สำหรับตัวเลขขนาดเล็กฉันจะพิจารณาIEEE802SixteenBitValueแต่นั่นก็ไม่ได้ดีขนาดนั้น ใครบ้างที่มีการประชุม? ดูเหมือนว่าแนวทางการตั้งชื่อของ Microsoft เป็นเพียงแนวทางเดียวที่อธิบายการตั้งชื่อตัวย่อโดยละเอียดเพื่อให้งานเสร็จ แต่ไม่มีใครได้ระบุหมายเลขในชื่อคลาส

21 naming  coding-style 

จากวิกิพีเดีย Extensible Markup Language (XML) เป็นชุดของกฎสำหรับการเข้ารหัสเอกสารในรูปแบบที่เครื่องอ่านได้ มันถูกกำหนดใน XML 1.0 Specification [4] ผลิตโดย W3C และข้อกำหนดที่เกี่ยวข้องอื่น ๆ อีกมากมายมาตรฐานเปิดฟรีทั้งหมด [5] อะไรคือเหตุผลทางประวัติศาสตร์ในการเรียก XML ชวเลขและค่อนข้างเป็น EML ที่เป็นธรรมชาติมากกว่าเดิม?

21 naming  xml  etymology 

มีความแตกต่างระหว่างการตั้งชื่อคลาส "Handler", "Manager" หรือ "Controller" หรือไม่? PurchaseManagerIE: PurchaseHandler, PurchaseController, ความพอเพียงเหล่านี้ถ่ายทอดความหมายเดียวกันหรือมีความแตกต่างอย่างชัดเจนระหว่างพวกเขาหรือไม่? หากไม่มีคำตอบที่ไม่เชื่อเรื่องภาษาให้พิจารณา Java เป็นภาษา

21 java  naming 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว เมื่อใช้ตัวแปรที่มีพหูพจน์และเอกพจน์เหมือนกันคุณจะตั้งชื่อพวกเขาอย่างไร มีมาตรฐานออกมาบ้างไหม? ตัวอย่างเช่น: Series[] series // Plural Series series // Singular ลึก: หากต้องการเจาะจงชุดของฉันจะต้องเรียกว่าชุด (เนื่องจากการจัดรูปแบบ JSON) คุณจะพิจารณาตั้งชื่อรูปแบบเอกพจน์ของซีรี่ส์ที่เพิ่มเข้าไปในคอลเลกชันSeries sหรือไม่ ในขณะที่: List<Series> series = new List<Series>(); Series s; while (someBool) { s = new Series(); s.Name = "Name"; while (anotherBool) { s.AddValue(someValue); } series.Add(s); }

20 c#  naming  naming-standards  language-discussion 

ฉันกำลังทำงานในโปรเจ็กต์ที่เกี่ยวข้องกับอุปกรณ์ทางกายภาพและฉันสับสนว่าจะตั้งชื่อคลาสบางคลาสในโครงการนี้ได้อย่างไร เมื่อพิจารณาถึงอุปกรณ์จริง (เซ็นเซอร์และตัวรับสัญญาณ) เป็นสิ่งหนึ่งและการเป็นตัวแทนของพวกเขาในซอฟต์แวร์นั้นเป็นอีกสิ่งหนึ่ง ตัวอย่างเช่นในขณะที่Sensorคลาสจะเป็นตัวแทนของเซ็นเซอร์จริง (เมื่อเชื่อมต่อกับอุปกรณ์ที่ใช้งานจริง) SensorInfoจะถูกใช้เพื่อแสดงเฉพาะคุณสมบัติของเซ็นเซอร์ดังกล่าว ตัวอย่างเช่นเมื่อบันทึกไฟล์ฉันจะทำให้เป็น a SensorInfoถึงส่วนหัวของไฟล์แทนการทำให้เป็นอันดับ a Sensorซึ่งเรียงลำดับของจะไม่ทำให้รู้สึก แต่ตอนนี้ฉันสับสนเพราะมีวงจรกลางในวงจรชีวิตของวัตถุที่ฉันไม่สามารถตัดสินใจได้ว่าฉันควรใช้อย่างใดอย่างหนึ่งหรืออื่นหรือวิธีการได้รับอย่างใดอย่างหนึ่งหรือแม้กระทั่งว่าตัวแปรทั้งสองควรจะยุบลงในชั้นเดียวเท่านั้น นอกจากนี้Employeeคลาสตัวอย่างที่ธรรมดาเกินไปก็ชัดเจนว่าเป็นเพียงตัวแทนของบุคคลจริง แต่ไม่มีใครแนะนำให้ตั้งชื่อชั้นเรียนEmployeeInfoแทนเท่าที่ฉันรู้ ภาษาที่ฉันทำงานด้วยคือ. NET และรูปแบบการตั้งชื่อนี้ดูเหมือนจะเป็นเรื่องทั่วไปตลอดทั้งเฟรมเวิร์กสำหรับตัวอย่างของคลาสเหล่านี้: DirectoryและDirectoryInfoชั้นเรียน FileและFileInfoชั้นเรียน ConnectionInfoชั้นเรียน (ไม่มีConnectionชั้นเรียนผู้สื่อข่าว); DeviceInfoชั้นเรียน (ไม่มีDeviceชั้นเรียนผู้สื่อข่าว); ดังนั้นคำถามของฉันคือ: มีเหตุผลทั่วไปเกี่ยวกับการใช้รูปแบบการตั้งชื่อนี้หรือไม่? มีกรณีที่เหมาะสมหรือไม่ที่จะมีชื่อคู่ ( ThingและThingInfo) และกรณีอื่น ๆ ที่ควรมีอยู่เฉพาะThingInfoคลาสหรือThingคลาสโดยไม่มีคู่

20 c#  .net  naming  class-design  naming-standards 

เมื่อเร็ว ๆ นี้ฉันได้พัฒนา API ของตัวเองและด้วยความสนใจลงทุนในการออกแบบ API ฉันมีความสนใจอย่างมากว่าฉันจะปรับปรุงการออกแบบ API ได้อย่างไร แง่มุมหนึ่งที่เกิดขึ้นสองสามครั้งคือ (ไม่ใช่โดยผู้ใช้ API ของฉัน แต่ในการสังเกตการอภิปรายเกี่ยวกับหัวข้อ): สิ่งหนึ่งที่ควรรู้เพียงแค่ดูรหัสที่เรียก API ว่ามันกำลังทำอะไรอยู่ ตัวอย่างเช่นดูการสนทนานี้ใน GitHub สำหรับวาทกรรมวาทกรรมมันมีลักษณะดังนี้: foo.update_pinned(true, true); เพียงแค่มองไปที่โค้ด (โดยไม่รู้ชื่อพารามิเตอร์เอกสาร ฯลฯ ) เราไม่สามารถเดาได้ว่ามันจะทำอะไร - อาร์กิวเมนต์ที่ 2 หมายถึงอะไร การปรับปรุงที่แนะนำคือการมี: foo.pin() foo.unpin() foo.pin_globally() และนั่นก็เป็นการล้างสิ่งต่าง ๆ (ข้อโต้แย้งที่สองคือว่าจะตรึง foo ทั่วโลกฉันเดา) และฉันเห็นด้วยในกรณีนี้ภายหลังจะเป็นการปรับปรุงอย่างแน่นอน แต่ผมเชื่อว่าอาจจะมีกรณีที่วิธีการในการตั้งค่าสถานะที่แตกต่างกัน แต่ที่เกี่ยวข้องเหตุผลจะได้รับการสัมผัสที่ดีกว่าเรียกวิธีหนึ่งมากกว่าคนแยกเป็นสัดส่วนถึงแม้คุณจะไม่ทราบว่าสิ่งที่ทำเพียงแค่มองรหัส (ดังนั้นคุณจะต้องหันไปดูที่ชื่อพารามิเตอร์และเอกสารประกอบเพื่อค้นหา - ซึ่งโดยส่วนตัวแล้วฉันจะทำทุกอย่างไม่ว่าฉันจะไม่คุ้นเคยกับ API) ตัวอย่างเช่นฉันเปิดเผยหนึ่งวิธีSetVisibility(bool, string, bool)ในFalconPeerและฉันรับทราบเพียงแค่ดูที่บรรทัด: …

20 programming-practices  naming  api  api-design 

ฉันกำลังอ่าน 'ห้องสมุดมาตรฐาน C' โดย PJ Plauger ซึ่งน่าสนใจจริงๆ หนังสือเล่มนี้ไม่เพียง แต่อธิบายวิธีการใช้ห้องสมุด แต่ยังอธิบายถึงวิธีการนำไปใช้งาน ฉันอ่านctype.hส่วนเสร็จแล้วและในส่วนหัวฟังก์ชั่นจะประกาศเป็นทั้งมาโครและฟังก์ชั่น ตัวอย่างเช่น int isdigit(int); แต่ยัง #define isdigit(c) (_Ctype[(int)(c)] & _DI) ฉันไม่เข้าใจว่าทำไมใช้ทั้งคู่ นอกจากนี้ถ้าฉันพยายามสร้างctypeส่วนหัวที่กำหนดเองและการนำไปใช้ใหม่ฉันสามารถรวบรวมได้สำเร็จถ้าฉันลบแมโครออก (ใส่เครื่องหมายความคิดเห็นในการกำหนด) แง่มุมนี้ไม่ได้อธิบายในหนังสือ ใครช่วยอธิบายหน่อยได้ไหม?

20 c  naming  functions  macros