მთარგმნელისგან. ინტერნეტში ვეძებდი მარტივ და ადვილად გამოსაყენებელ სახელმძღვანელოს C++-ში პროგრამების დასაწერად. ერთ-ერთი ვარიანტი მომეწონა და გადავწყვიტე მისი თარგმნა და გამოცემა. თუ ეს თემა კარგად იქნა მიღებული ჰაბრას მომხმარებლების მიერ, შემიძლია თარგმნა სხვა დაკავშირებული დოკუმენტები, ასევე სხვა კომპანიების კოდის დაწერის სახელმძღვანელო.
1. შესავალი
ეს დოკუმენტი შეიცავს ინსტრუქციებს C++-ში პროგრამების დასაწერად.მაგრამ ამ წყაროების გარდა, რეკომენდაციების კიდევ ერთი ჩამონათვალის გამოჩენის რამდენიმე მიზეზი არსებობს. მთავარი მიზეზი მათი გადაჭარბებული განზოგადებაა, ვინაიდან ხშირად საჭიროა კერძო წესების (განსაკუთრებით დასახელების წესების) დაზუსტება. ეს დოკუმენტი შეიცავს კომენტარებს, რაც უფრო მოსახერხებელს ხდის კოდის გადასინჯვისას, ვიდრე სხვა არსებული დოკუმენტები. გარდა ამისა, პროგრამირების გაიდლაინები, როგორც წესი, შეიცავს სტილის პრობლემებისა და ტექნიკური პრობლემების აღწერილობას, რაც არ არის ძალიან მოსახერხებელი. ეს დოკუმენტი არ შეიცავს ტექნიკურ რჩევებს C++-ისთვის, რომელიც ფოკუსირებულია სტილის საკითხებზე.
განვითარების ხელმისაწვდომ გარემოს შეუძლია გააუმჯობესოს კოდის წაკითხვა წვდომის მოდიფიკატორების ჩვენებით, კოდის ხაზგასმით, ავტომატური ფორმატირებით და სხვა, მაგრამ პროგრამისტი არ უნდა დაეყრდნოს ამ ინსტრუმენტებს. წყაროს კოდი უნდა განიხილებოდეს დეველოპერული გარემოს მიღმა და უნდა დაიწეროს, რომ მაქსიმალურად წაკითხვა იყოს გარემოს მიუხედავად.
1.1 დოკუმენტის ფორმატი
რეკომენდაციები დაჯგუფებულია თემის მიხედვით და დანომრილია ისე, რომ მათი მითითება შესაძლებელი იყოს კოდის განხილვისას. რეკომენდაციები იყოფა მნიშვნელობის მიხედვით: სავალდებულო, ძალიან რეკომენდებული და ზოგადი. 1. რეკომენდაციების ნებისმიერი დარღვევა დასაშვებია, თუ ეს აუმჯობესებს კითხვადობას.2. წესები შეიძლება დაირღვეს, თუ მათზე არსებობს პირადი წინააღმდეგობა.
ეს არის მცდელობა შეიქმნას ზოგადი მითითებების ნაკრები ყველასათვის ერთი სტილის დაკისრების გარეშე. გამოცდილი პროგრამისტები, როგორც წესი, აწყობენ სტილს ისე, რომ მოერგოს საკუთარ თავს. მსგავსი მითითებების სიის არსებობა (ან თუნდაც მათი დათვალიერების მოთხოვნა) ადამიანებს აიძულებს იფიქრონ თავიანთი პროგრამირების სტილზე და შეაფასონ საკუთარი პროგრამირების პრაქტიკა.
მეორეს მხრივ, ახალი და გამოუცდელი პროგრამისტები, როგორც წესი, იყენებენ სტილის სახელმძღვანელოებს პროგრამირების ჟარგონის უკეთ გასაგებად.
3 დასახელების კონვენციები
3.1 დასახელების ზოგადი წესები
3. ტიპების აღმნიშვნელი სახელები უნდა დაიწეროს შერეული რეგისტრით, დაწყებული დიდი რეგისტრით.ხაზი, SavingsAccount
4. ცვლადის სახელები უნდა დაიწეროს შერეული რეგისტრით, დაწყებული პატარა რეგისტრით.
ხაზი, შემნახველი ანგარიში
გავრცელებული პრაქტიკა C++ დეველოპერის საზოგადოებაში. საშუალებას გაძლევთ მარტივად განასხვავოთ ცვლადები ტიპებისგან, თავიდან აიცილოთ პოტენციური სახელების შეჯახება, მაგალითად: Line line;
5. დასახელებული მუდმივები (მათ შორის, აღრიცხვის მნიშვნელობები) უნდა დაიწეროს დიდი ასოებით ხაზგასმით, როგორც განმსაზღვრელი.
MAX_ITERATIONS, COLOR_RED, PI
გავრცელებული პრაქტიკა C++ დეველოპერის საზოგადოებაში. ასეთი მუდმივების გამოყენება უნდა იყოს მინიმუმამდე. უმეტეს შემთხვევაში, ღირებულების, როგორც მეთოდის დანერგვა საუკეთესო გამოსავალია:
Int getMaxIterations() // NOT: MAX_ITERATIONS = 25 ( დაბრუნება 25; )
ეს ფორმა უფრო იკითხება და გარანტიას იძლევა ერთი ინტერფეისი კლასში შენახული მნიშვნელობებისთვის.
6. მეთოდებისა და ფუნქციების სახელები უნდა იყოს ზმნები, დაწერილი შერეული რეგისტრით და იწყებოდეს მცირე რეგისტრით.
GetName(), computeTotalWidth()
იგივეა, რაც ცვლადების წესი, მაგრამ მათ შორის განსხვავება მდგომარეობს მათ სპეციფიკურ ფორმებში.
7. სახელთა სივრცის სახელები უნდა დაიწეროს მცირე ასოებით.
მოდელი::ანალიზატორი, io::iomanager, საერთო::მათემატიკა::გეომეტრია
გავრცელებული პრაქტიკა C++ დეველოპერის საზოგადოებაში.
8. შაბლონებში აკრიფეთ სახელები დასახელებული უნდა იყოს ერთი დიდი ასოთი.
შაბლონი
გავრცელებული პრაქტიკა C++ დეველოპერის საზოგადოებაში. საშუალებას გაძლევთ განასხვავოთ შაბლონის სახელები სხვა გამოყენებული სახელებისგან.
9. შემოკლებები და აბრევიატურები სახელებში უნდა დაიწეროს მცირე ასოებით.
exportHtmlSource(); // DON'T: exportHTMLSource(); openDvdPlayer(); // NOT: openDVDPlayer();
დიდი ასოების გამოყენებამ შეიძლება გამოიწვიოს ზემოთ აღწერილი სახელების კონფლიქტი. წინააღმდეგ შემთხვევაში, ცვლადებს დაერქმევა dVD, hTML და ა.შ., რაც არ იკითხება. კიდევ ერთი პრობლემა უკვე აღწერილია ზემოთ; როდესაც სახელი ასოცირდება სხვასთან, წაკითხვის უნარი მცირდება; აბრევიატურის შემდგომი სიტყვა არ გამოირჩევა ისე, როგორც უნდა.
10. გლობალური ცვლადები ყოველთვის უნდა იყოს გამოყენებული ფარგლების გარჩევადობის ოპერატორთან (::).
::mainWindow.open(), ::applicationContext.getName()
თავიდან უნდა იქნას აცილებული გლობალური ცვლადების გამოყენება. სასურველია გამოიყენოს ერთტონიანი.
11. კლასის წევრები მოდიფიკატორითკერძო უნდა მიენიჭოს ხაზგასმული სუფიქსი.
კლასი SomeClass ( პირადი: int length_;)
სახელისა და ტიპის გარდა, scope არის ცვლადის ყველაზე მნიშვნელოვანი თვისება. წვდომის მოდიფიკატორის ცალსახად მითითება ხაზგასმულის სახით გამორიცხავს დაბნეულობას კლასის წევრებსა და ლოკალურ ცვლადებს შორის. ეს მნიშვნელოვანია, რადგან კლასის ცვლადები უფრო მნიშვნელოვანია, ვიდრე მეთოდის ცვლადები და მათ უფრო ფრთხილად უნდა მოეპყროთ.
ხაზგასმული სუფიქსის დამატებითი ეფექტი არის დასახელების პრობლემების გადაჭრა მნიშვნელობის დადგენის მეთოდებში და კონსტრუქტორებში:
სიცარიელე setDepth (int სიღრმე) (depth_ = სიღრმე;)
პრობლემა ის არის, რომ ხაზგასმის ორი ვარიანტი არსებობს - როგორც სუფიქსი და როგორც პრეფიქსი. ორივე ვარიანტი ფართოდ გამოიყენება, მაგრამ პირველი ვარიანტი რეკომენდირებულია, რადგან ის უზრუნველყოფს უკეთ წაკითხვას. უნდა აღინიშნოს, რომ ცვლადების წვდომის მოდიფიკატორის განსაზღვრა ზოგჯერ საკამათო საკითხია. თუმცა, როგორც ჩანს, რეკომენდებული პრაქტიკა იძენს მიმდევრებს და უფრო გავრცელებული ხდება პროფესიონალებში.
12. მორგებულ ცვლადებს უნდა მიენიჭოთ იგივე სახელი, როგორც მათი ტიპი.
Void setTopic(თემა* თემა) // NOT: void setTopic(თემა* მნიშვნელობა) // NOT: void setTopic(თემა* aTopic) // NOT: void setTopic(თემა* t) void connect(მონაცემთა ბაზა* მონაცემთა ბაზა) // NOT : void connect (მონაცემთა ბაზა* db) // NOT: void connect (მონაცემთა ბაზა* oracleDB)
შეამცირეთ სირთულე გამოყენებული ტერმინებისა და სახელების რაოდენობის შემცირებით. ასევე აადვილებს ტიპის ამოცნობას უბრალოდ ცვლადის სახელით.
არარეგულირებადი ცვლადები შეიძლება დასახელდეს მათი მიზნისა და ტიპის მიხედვით:
წერტილი startPoint, centerPoint; სახელი შესვლაName;
13. ყველა სახელი უნდა იყოს დაწერილი ინგლისურად.
14. დიდი მოცულობის ცვლადებს უნდა ეწოდოს გრძელი სახელები, ხოლო მცირე ფარგლების მქონეებს - მოკლე სახელები.
დროებითი ცვლადების სახელები, რომლებიც გამოიყენება დროებითი მნიშვნელობების ან ინდექსების შესანახად, უმჯობესია მოკლედ იყოს დაცული. პროგრამისტს, რომელიც კითხულობს ასეთ ცვლადებს, უნდა შეეძლოს ივარაუდოს, რომ მათი მნიშვნელობები არ გამოიყენება კოდის რამდენიმე ხაზის მიღმა. როგორც წესი, ეს ცვლადებია მე, ჯ, კ, ლ, მ, ნ(მთლიანი რიცხვებისთვის) და ასევე გდა დ(სიმბოლოებისთვის).
15. ობიექტების სახელები ცალსახად არ არის მითითებული; თქვენ უნდა მოერიდოთ ობიექტების სახელების მითითებას მეთოდების სახელებში.
(გამოკლებულია პუნქტი No16. - მთარგმნელის შენიშვნა.)
3.2 დასახელების სპეციალური წესები
17. სიტყვებიმისაღებად შეიქმნა უნდა იქნას გამოყენებული იქ, სადაც ატრიბუტი პირდაპირ არის წვდომა.Employee.getName(); თანამშრომელი.setName(სახელი); matrix.getElement(2, 4); matrix.setElement(2, 4, მნიშვნელობა);
გავრცელებული პრაქტიკა C++ დეველოპერის საზოგადოებაში. ჯავაში ეს კონვენცია მეტ-ნაკლებად სტანდარტული გახდა.
18. სიტყვაგამოთვლა შეიძლება გამოყენებულ იქნას მეთოდებში, რომლებიც გამოთვლიან რაღაცას.
ValueSet->computeAverage(); matrix->computeInverse()
დაუყოვნებლივ უთხარით მკითხველს, რომ ეს შრომატევადი ოპერაციაა.
19. სიტყვაიპოვე შეიძლება გამოყენებულ იქნას მეთოდებში, რომლებიც ასრულებენ ნებისმიერ ძიებას.
Vertex.findNearestVertex(); matrix.findMinElement();
დაუყოვნებლივ აცნობეთ მკითხველს, რომ ეს არის მარტივი საძიებო მეთოდი, რომელიც არ საჭიროებს დიდ გამოთვლას.
20. სიტყვაინიციალიზაცია შეიძლება გამოყენებულ იქნას იქ, სადაც ობიექტის ან ერთეულის ინიციალიზაცია ხდება.
Printer.initializeFontSet();
უპირატესობა უნდა მიენიჭოს ინიციალის ამერიკულ ვერსიას ზ e ვიდრე ბრიტანული საწყისი სე. თავიდან უნდა იქნას აცილებული აბრევიატურა init.
21. ცვლადებს, რომლებიც წარმოადგენენ GUI-ს, უნდა მიენიჭოთ სუფიქსი, რომელიც შეესაბამება კომპონენტის ტიპის სახელს.
MainWindow, propertiesDialog, widthScale, loginText, leftScrollbar, mainForm, fileMenu, minLabel, exitButton, yesToggle და ა.შ.
აუმჯობესებს კითხვადობას, რადგან სახელი აძლევს მომხმარებელს პირდაპირ მინიშნებას ცვლადის ტიპისა და, შესაბამისად, ობიექტების რესურსების შესახებ.
22. მრავლობითი რიცხვი უნდა იქნას გამოყენებული საგნების სიმრავლეების (კოლექციების) წარმოსაჩენად.
ვექტორი
აუმჯობესებს კითხვადობას, რადგან სახელი აძლევს მომხმარებელს პირდაპირ მინიშნებას ცვლადის ტიპისა და ოპერაციების შესახებ, რომლებიც შეიძლება გამოყენებულ იქნას ამ ელემენტებზე.
23. პრეფიქსინ უნდა იქნას გამოყენებული ობიექტების რაოდენობის წარმოსაჩენად.
NPoints, nხაზები
აღნიშვნა აღებულია მათემატიკიდან, სადაც ეს არის დადგენილი კონვენცია ობიექტების რაოდენობის აღსანიშნავად.
24. სუფიქსიარა უნდა იქნას გამოყენებული ერთეულის ნომრის მითითებისთვის.
ცხრილიარა, თანამშრომელი
აღნიშვნა აღებულია მათემატიკიდან, სადაც ეს არის დადგენილი კონვენცია ერთეულის ნომრის მითითებისთვის.
კიდევ ერთი კარგი ალტერნატივა არის პრეფიქსი მე: iTable, iEmployee. ცხადყოფს, რომ ეს არის დასახელებული იტერატორი.
25. Iterator ცვლადები უნდა იყოს დასახელებულიმე, ჯ, კ და ა.შ.
ამისთვის (int i = 0; i< nTables); i++) {
:
}
for (vector
აღნიშვნა აღებულია მათემატიკიდან, სადაც ეს არის დამკვიდრებული კონვენცია იტერატორების აღნიშვნისათვის.
ცვლადები სახელებით ჯ, კდა ა.შ. რეკომენდირებულია გამოიყენოს მხოლოდ წყობილ მარყუჟებში.
26. პრეფიქსიარის უნდა იყოს გამოყენებული მხოლოდ ლოგიკური ცვლადებისა და მეთოდებისთვის.
IsSet, isVisible, isFinished, isFound, isOpen
ჩვეულებრივი პრაქტიკა C++ განვითარების საზოგადოებაში, რომელიც ზოგჯერ გამოიყენება Java-შიც.
ამ პრეფიქსის გამოყენებით თავიდან აიცილებთ სახელებს, როგორიცაა სტატუსიან დროშა. არის სტატუსიან არის დროშაუბრალოდ არ ჯდება და პროგრამისტი იძულებულია აირჩიოს უფრო მნიშვნელოვანი სახელები.
ზოგიერთ სიტუაციაში პრეფიქსი არისჯობია სხვათი ჩაანაცვლო: აქვს, შეუძლიაან უნდა:
Bool hasLicense(); bool canEvaluate(); bool shouldSort();
27. სიმეტრიული სახელები გამოყენებული უნდა იქნეს შესაბამისი მოქმედებებისათვის.
მიღება/დაყენება, დამატება/წაშლა, შექმნა/განადგურება, დაწყება/შეჩერება, ჩასმა/წაშლა, გაზრდა/შემცირება, ძველი/ახალი, დაწყება/დასრულება, პირველი/ბოლო, ზევით/ქვემოთ, მინ/მაქს, შემდეგი/წინა, ძველი/ ახალი, გახსნა/დახურვა, ჩვენება/დამალვა, შეჩერება/განახლება და ა.შ.
სიმეტრიის მეშვეობით სირთულის შემცირება.
28. თავიდან უნდა იქნას აცილებული სახელების შემოკლებები.
ComputeAverage(); // NOT: compAvg();
მოდით შევხედოთ ორი ტიპის სიტყვას. პირველი არის ჩვეულებრივი სიტყვები, რომლებიც ჩამოთვლილია ლექსიკონებში, რომელთა შემოკლება შეუძლებელია. არასოდეს შემოკლება:
Cmd ბრძანების cp ნაცვლად pt-ის კოპირების ნაცვლად point comp-ის ნაცვლად გამოთვლა init ნაცვლად ინიციალიზაციისა და ა.შ.
მეორე ტიპი არის კონკრეტული სფეროსთვის დამახასიათებელი სიტყვები, რომლებიც ცნობილია მათი შემოკლებით/აბრევიატურებით. ისინი უნდა დაიწეროს შემოკლებით. არასოდეს დაწერო:
HypertextMarkupLanguage ნაცვლად html CentralProcessingUnit-ის ნაცვლად cpu PriceEarningRatio ნაცვლად pe და ა.შ.
29. თავიდან უნდა იქნას აცილებული მაჩვენებლების დამატებითი დასახელება.
ხაზი * ხაზი; // არ არის რეკომენდირებული: Line* pLine; // არ არის რეკომენდებული: Line* linePtr;
C/C++-ში ბევრი ცვლადი არის მაჩვენებელი. მხოლოდ მაშინ, როდესაც C++ ობიექტის ტიპი განსაკუთრებით მნიშვნელოვანია, სახელი უნდა ასახავდეს მას.
30. თქვენ არ შეგიძლიათ ლოგიკური (ლოგიკური) ცვლადების დასახელება, რომლებიც შეიცავს უარყოფას.
Bool isError; // IMPOSSIBLE: isNoError bool isFound; // არა: არ არის ნაპოვნი
პრობლემა ჩნდება, როდესაც ასეთი სახელი გამოიყენება ლოგიკური უარყოფის ოპერატორთან ერთად, რაც იწვევს ორმაგ უარყოფას. შედეგი არ უნდა იყოს უარყოფითი !არ არის ნაპოვნი.
31. რიცხვებში მუდმივებს შეიძლება ჰქონდეთ პრეფიქსი - ტიპის საერთო სახელწოდება.
Enum ფერი (COLOR_RED, COLOR_GREEN, COLOR_BLUE);
ეს იძლევა დამატებით ინფორმაციას იმის შესახებ, თუ სად მდებარეობს დეკლარაცია, რა მუდმივებია აღწერილი ერთ ჩამოთვლაში და რა კონცეფციას წარმოადგენს მუდმივები.
კიდევ ერთი მიდგომაა მუდმივებზე მითითება მათი ზოგადი ტიპის მიხედვით: ფერი::წითელი, ავიაკომპანია::AIR_FRANCE და ა.შ.
გაითვალისწინეთ, რომ enum სახელი ჩვეულებრივ იწერება მხოლობით, მაგალითად: enum ფერი (...). მრავლობითი სახელი კარგად გამოიყურება გამოცხადებისას, მაგრამ არ მუშაობს კარგად პრაქტიკულ გამოყენებაში.
32. გამონაკლის კლასებს უნდა მიეცეს სუფიქსიგამონაკლისი .
კლასი AccessException ( : )
გამონაკლისი კლასები ნამდვილად არ არის პროგრამის არქიტექტურის ნაწილი და მათი ამგვარად დასახელება განასხვავებს მათ სხვა კლასებისგან.
33. ფუნქციები (მეთოდები, რომლებიც აბრუნებენ მნიშვნელობებს) უნდა დაასახელონ იმის მიხედვით, თუ რას აბრუნებენ, ხოლო პროცედურები უნდა დასახელდეს იმის მიხედვით, თუ რას ასრულებენ (void მეთოდები).
წაკითხვის გაუმჯობესება. ეს დასახელება ცხადყოფს, რას აკეთებს მეთოდი და რას არა, და ასევე ათავისუფლებს კოდს პოტენციური გვერდითი ეფექტებისგან.
4 ფაილი
4.1 წყარო ფაილები
34. C++ სათაურის ფაილებს უნდა მიეცეს გაფართოება.თ (სასურველია) ან.hpp . წყაროს კოდის ფაილებს შეიძლება ჰქონდეს გაფართოებები.c++ (რეკომენდირებულია).C , .cc ან.cpp .MyClass.c++, MyClass.h
ეს არის გაფართოებები, რომლებიც დამტკიცებულია C++ სტანდარტით.
35. კლასი უნდა იყოს დეკლარირებული სათაურის ფაილში და განისაზღვროს (დანერგილი) წყაროს კოდის ფაილში, ფაილის სახელები იგივეა, რაც კლასის სახელი.
MyClass.h, MyClass.c++
აადვილებს კლასთან დაკავშირებული ფაილების პოვნას. აშკარა გამონაკლისი არის შაბლონის კლასები, რომლებიც უნდა გამოცხადდეს და განისაზღვროს სათაურის ფაილში.
36. ყველა განმარტება უნდა იყოს კოდის ფაილებში.
კლასი MyClass ( საჯარო: int getValue () (დაბრუნების მნიშვნელობა_;) // NOT! ... კერძო: int value_;)
Header ფაილები აცხადებენ ინტერფეისს, წყაროს კოდის ფაილები ახორციელებენ მას. თუ პროგრამისტს სჭირდება განხორციელების პოვნა, ის დარწმუნებული უნდა იყოს, რომ იპოვის მას წყაროს კოდის ფაილში.
37. ფაილის შინაარსი არ უნდა აღემატებოდეს 80 სვეტს.
80 სვეტი არის ფართოდ გამოყენებული გარჩევადობა რედაქტორებისთვის, ტერმინალის ემულატორებისთვის, პრინტერებისთვის და გამართვისთვის; ფაილები გადადის სხვადასხვა ადამიანებს შორის, ამიტომ თქვენ უნდა დაიცვან ეს შეზღუდვები. ხაზების შესაბამისი წყვეტები აუმჯობესებს წაკითხვის შესაძლებლობას წყაროს კოდზე თანამშრომლობისას.
38. სპეციალური სიმბოლოების (როგორიცაა TAB) და გვერდის წყვეტების გამოყენება შეუძლებელია.
ასეთი სიმბოლოები იწვევს უამრავ პრობლემას რედაქტორებთან, ტერმინალის ემულატორებთან და გამართულებთან, რომლებიც გამოიყენება ერთობლივი განვითარების პროგრამებში და პლატფორმაზე არსებულ გარემოში.
39. გატეხილი ხაზების არასრული უნდა იყოს აშკარა.
ჯამი = a + b + c + d + e; ფუნქცია (param1, param2, param3); setText("გრძელი ხაზი გაყოფილი" "ორ ნაწილად."); for (int tableNo = 0; tableNo< nTables;
tableNo += tableStep) {
...
}
მწკრივების წყვეტები ჩნდება, როდესაც ზემოთ აღწერილი 80-სვეტიანი ლიმიტი დარღვეულია. რთულია დაშლის მკაცრი და სწრაფი წესების მიცემა, მაგრამ ზემოთ მოყვანილი მაგალითები გვიჩვენებს ზოგად პრინციპებს.
Ზოგადად:
- ათობითი შესვენება;
- შესვენება ოპერატორის შემდეგ;
- ახალი ხაზის გასწორება წინა ხაზის გამოხატვის დასაწყისთან.
4.2 ფაილის ჩართვა
40. ჰედერის ფაილები უნდა შეიცავდეს ბუდე დაცვას.#ifndef COM_COMPANY_MODULE_CLASSNAME_H #define COM_COMPANY_MODULE_CLASSNAME_H: #endif // COM_COMPANY_MODULE_CLASSNAME_H
დიზაინი საშუალებას გაძლევთ თავიდან აიცილოთ კომპილაციის შეცდომები. ეს კონვენცია საშუალებას გაძლევთ ნახოთ ფაილის პოზიცია პროექტის სტრუქტურაში და თავიდან აიცილოთ სახელების კონფლიქტი.
41. ჩართვის დირექტივები უნდა იყოს დახარისხებული (ადგილის მიხედვით სისტემურ იერარქიაში, ქვედა დონე - უმაღლესი თანამდებობა) და დაჯგუფებული. დატოვეთ ცარიელი ხაზი ჯგუფებს შორის.
#შეიცავს
ჩართვის გზები არ უნდა იყოს აბსოლუტური. ამის ნაცვლად უნდა იქნას გამოყენებული შემდგენელი დირექტივები.
42. ჩართეთ დირექტივები უნდა განთავსდეს მხოლოდ ფაილის დასაწყისში.
Გენერალური რეპეტიცია. მოერიდეთ არასასურველ გვერდით ეფექტებს, რომლებიც შეიძლება გამოიწვიოს "დამალულმა" წყაროს კოდის ფაილის სადღაც შუაში.
5 გამონათქვამები
5.1 ტიპები
43. ერთ ფაილში გამოყენებული ლოკალური ტიპები უნდა იყოს დეკლარირებული მხოლოდ ამ ფაილში.აუმჯობესებს ინფორმაციის დამალვას.
44. საკლასო სექციებისაჯარო , დაცული დაკერძო უნდა დალაგდეს. ყველა განყოფილება მკაფიოდ უნდა იყოს მითითებული.
ჯერ უნდა იყოს განყოფილება საჯარო, რომელიც კლასის გაცნობის მსურველებს გადაარჩენს საკითხავი განყოფილებებისგან დაცული/პირადი.
45. ტიპის ჩამოსხმა უნდა იყოს მკაფიო. არასოდეს დაეყრდნოთ იმპლიციტური ტიპის კასტინგს.
FloatValue = static_cast
ამით, პროგრამისტი აჩვენებს, რომ მან იცის ტიპების განსხვავება და რომ დაბნეულობა არის მიზანმიმართული.
5.2 ცვლადები
46. ცვლადები უნდა იყოს ინიცირებული იმ ადგილას, სადაც ისინი დეკლარირებულია.ეს უზრუნველყოფს ცვლადების გამოყენებას ნებისმიერ დროს. მაგრამ ზოგჯერ ამის გაკეთება შეუძლებელია:
Int x, y, z; getCenter(&x, &y, &z);
ამ შემთხვევაში, უმჯობესია დატოვოთ ცვლადები არაინიციალიზებული, ვიდრე მათთვის რაიმე მნიშვნელობის მინიჭება.
47. ცვლადებს არასოდეს უნდა ჰქონდეს ორმაგი მნიშვნელობა.
გააუმჯობესეთ წაკითხვის უნარი ყველა წარმოდგენილი კონცეფციის თანმიმდევრულობის უზრუნველსაყოფად. შეამცირეთ გვერდითი ეფექტების გამო შეცდომის შესაძლებლობა.
48. თავიდან უნდა იქნას აცილებული გლობალური ცვლადების გამოყენება.
C++-ში გლობალური ცვლადების გამოყენების არანაირი მიზეზი არ არსებობს (სინამდვილეში არის. - მთარგმნელის შენიშვნა). იგივე ეხება გლობალურ ფუნქციებს და (სტატიკური) ცვლადებს, რომელთა ფარგლები არის მთელი ფაილი.
49. თქვენ არ უნდა გამოაცხადოთ კლასის ცვლადები როგორცსაჯარო .
ეს ცვლადები არღვევს ინფორმაციის დამალვისა და ინკაფსულაციის პრინციპებს. ამის ნაცვლად, გამოიყენეთ ცვლადები მოდიფიკატორით კერძოდა მასთან დაკავშირებული წვდომის ფუნქციები. გამონაკლისი არის კლასი ქცევის გარეშე, პრაქტიკულად მონაცემთა სტრუქტურა (ექვივალენტური C ენის სტრუქტურები). ამ შემთხვევაში აზრი არ აქვს ამ ცვლადების დამალვას.
გთხოვთ გაითვალისწინოთ, რომ C++-ის სტრუქტურები შენარჩუნებულია მხოლოდ C-თან თავსებადობისთვის; მათი გამოყენება აფერხებს კოდის წაკითხვას. გამოიყენეთ კლასები სტრუქტურების ნაცვლად.
(გამოკლებულია პუნქტი No50. - მთარგმნელის შენიშვნა.)
ფლოტი* x; // არ არის რეკომენდებული: float *x; int&y; // არ არის რეკომენდებული: ინტ
ის, რომ ცვლადი არის მაჩვენებელი ან მითითება, მიუთითებს მის ტიპზე და არა სახელზე. C პროგრამისტები ხშირად განსხვავებულ მიდგომას ატარებენ, მაგრამ C++-ში უმჯობესია დაიცვან ეს რეკომენდაცია.
(გამოკლებულია პუნქტი No52. - მთარგმნელის შენიშვნა.)
53. თავიდან უნდა იქნას აცილებული ლოგიკური (ლოგიკური) ცვლადების და მაჩვენებლების იმპლიციტური შედარება ნულთან.
თუ (nხაზები != 0) // არ არის რეკომენდებული: if (nხაზები) თუ (მნიშვნელობა != 0.0) // არ არის რეკომენდებული: თუ (მნიშვნელობა)
C++ სტანდარტი არ იძლევა გარანტიას, რომ int და float ცვლადების ნულის ტოლი მნიშვნელობები წარმოდგენილი იქნება როგორც ორობითი 0. ასევე, აშკარა შედარებით, შესადარებელი ტიპი ჩანს.
ლოგიკური იქნება ვივარაუდოთ, რომ მაჩვენებლები ასევე არ უნდა შედარდეს ნულთან, მაგალითად, if (ხაზი == 0) ნაცვლად if (ხაზის). ეს უკანასკნელი ძალიან გავრცელებული პრაქტიკაა C/C++-ში, ამიტომ მისი გამოყენებაც შესაძლებელია.
54. ცვლადები უნდა გამოცხადდეს რაც შეიძლება მცირე მოცულობით.
ეს აადვილებს ცვლადი და გვერდითი ეფექტების ეფექტის კონტროლს.
5.3 ციკლი
55. თქვენ არ შეგიძლიათ შეიტანოთ გამონათქვამები for() კონსტრუქციაში, რომლებიც არ არის დაკავშირებული მარყუჟის კონტროლთან.ჯამი = 0; // NOT: for (i = 0, ჯამი = 0; i< 100; i++)
for (i = 0; i < 100; i++) sum += value[i];
sum += value[i];
გააუმჯობესეთ მხარდაჭერა და წაკითხვის უნარი. გააკონტროლეთ ციკლი მკაცრად განცალკევებით იმისგან, რაც მას შეიცავს.
56. ციკლთან დაკავშირებული ცვლადები უნდა იყოს ინიციალიზებული უშუალოდ მის წინ.
57. Do-while მარყუჟების თავიდან აცილება შესაძლებელია.
ასეთი მარყუჟები ნაკლებად იკითხება, რადგან მდგომარეობა აღწერილია სხეულის შემდეგ. მკითხველს მოუწევს მთელი ციკლის გავლა, რათა გაიგოს, როგორ მუშაობს იგი.
Do-while მარყუჟები საერთოდ არ არის მკაცრად საჭირო. ნებისმიერი ასეთი მარყუჟი შეიძლება შეიცვალოს ცოტათი ან მარყუჟით.
გამოყენებული ნაკლები კონსტრუქცია აუმჯობესებს კითხვადობას.
58. მოერიდეთ გამოყენებასშესვენება დაგააგრძელე ციკლებში.
ასეთი გამონათქვამები უნდა იქნას გამოყენებული მხოლოდ მაშინ, როდესაც ისინი აძლიერებენ წაკითხვას.
(გამოკლებულია პუნქტი No59. - მთარგმნელის შენიშვნა.)
60. უსასრულო მარყუჟებისთვის უნდა გამოიყენოთ ფორმახოლო (მართალია) .
ხოლო (მართალია) (:) (;;) ( // არა! : ) ხოლო (1) ( // არა! : )
ერთის გამოცდა არასაჭირო და უაზროა. for (;;) ფორმა არ არის ძალიან იკითხება; ასევე არ არის აშკარა, რომ მარყუჟი უსასრულოა.
5.4 პირობები
61. მკაცრად მოერიდეთ რთულ გამონათქვამებს. ამის ნაცვლად, შეიყვანეთ ლოგიკური ცვლადები.Bool is Finished = (ელემენტის No< 0) || (elementNo >maxElement); bool isRepeatedEntry = elementNo == lastElement; თუ (დასრულებულია || არის განმეორებითი ჩანაწერი) ( : ) // არა: თუ ((ელემენტის ნომერი< 0) || (elementNo >maxElement)|| ელემენტის ნომერი == ბოლო ელემენტი) ( :)
გამონათქვამებისთვის ლოგიკური ცვლადების დაყენება გამოიწვევს პროგრამის თვითდოკუმენტირებას. დიზაინი უფრო ადვილი იქნება წაკითხვა, გამართვა და შენარჩუნება.
62. მოსალოდნელი ნაწილი უნდა განთავსდეს ნაწილშითუ , გამონაკლისი - ნაწილობრივსხვა .
Bool isOk = readFile(fileName); თუ (კარგი) ( : ) სხვა ( : )
ეს დაგეხმარებათ იმის უზრუნველსაყოფად, რომ გამონაკლისები არ აფერხებენ ნორმალურ შესრულებას. მნიშვნელოვანია წაკითხვისა და შესრულებისთვის.
63. პირობა უნდა განთავსდეს ცალკე ხაზზე.
64. ტერმინებისა და პირობების შესრულებადი გამონათქვამები მკაცრად უნდა იქნას აცილებული.
ფაილი* fileHandle = open(fileName, "w"); if (!fileHandle) ( : ) // NOT: if (!(fileHandle = open(fileName, "w"))) ( : )
პირობებში შესრულებადი გამონათქვამები ართულებს წაკითხვას. ეს განსაკუთრებით ეხება C/C++-ის დამწყებთათვის.
5.5 სხვადასხვა
65. კოდში „ჯადოსნური“ ნომრები თავიდან უნდა იქნას აცილებული. 0 ან 1-ის გარდა სხვა რიცხვები უნდა გამოცხადდეს დასახელებულ მუდმივებად.თუ თავად რიცხვს არ აქვს აშკარა მნიშვნელობა, წაკითხვა უმჯობესდება დასახელებული მუდმივის შემოღებით. კიდევ ერთი მიდგომა არის ისეთი მეთოდის შექმნა, რომელიც შეიძლება გამოყენებულ იქნას მუდმივზე წვდომისთვის.
66. მცურავი წერტილის მუდმივები უნდა დაიწეროს ათობითი წერტილით და ათწილადის შემდეგ ერთი ციფრი მაინც.
ორმაგი ჯამი = 0.0; // არ არის რეკომენდებული: ორმაგი ჯამი = 0; ორმაგი სიჩქარე = 3.0e8; // არ არის რეკომენდებული: ორმაგი სიჩქარე = 3e8; ორმაგი ჯამი; : ჯამი = (a + b) * 10.0;
ეს ხაზს უსვამს განსხვავებულ მიდგომას მთელ რიცხვებთან და მცურავი წერტილის რიცხვებთან მუშაობისას. მათემატიკური თვალსაზრისით, ეს ორი მოდელი სრულიად განსხვავებული და შეუთავსებელია.
და ასევე (როგორც ზემოთ მოყვანილ ბოლო მაგალითშია ნაჩვენები) აქცენტი კეთდება ცვლადის ტიპზე (ჯამზე) ისეთ ადგილას, სადაც ის აშკარა არ არის.
67. მცურავი წერტილის მუდმივები ყოველთვის უნდა იწერებოდეს ათწილადამდე მინიმუმ ერთი ციფრით.
რიცხვებისა და გამონათქვამების C++ სისტემა მომდინარეობს მათემატიკიდან და შეძლებისდაგვარად უნდა მიჰყვეთ ტრადიციულ აღნიშვნას. სხვა საკითხებთან ერთად, 0.5 უფრო იკითხება ვიდრე .5 (პირველი ვარიანტი არ შეიძლება აგვერიოს რიცხვში 5).
68. ფუნქციებში უნდა იყოს მითითებული დაბრუნებული მნიშვნელობის ტიპი.
Int getValue() // NOT: getValue() ( : )
თუ ცალსახად არ არის მითითებული, C++ ვარაუდობს, რომ დაბრუნებული მნიშვნელობა არის int ტიპის. არასოდეს უნდა დაეყრდნოთ ამას, რადგან ამან შეიძლება დააბნიოს პროგრამისტები, რომლებიც არ იცნობენ მას.
69. არ უნდა იქნას გამოყენებულიწადი .
ეს განცხადება არღვევს სტრუქტურირებული პროგრამირების პრინციპებს. უნდა იქნას გამოყენებული მხოლოდ ძალიან იშვიათ შემთხვევებში (მაგალითად, ღრმად ჩასმული მარყუჟიდან გასასვლელად), როდესაც სხვა ვარიანტები აშკარად არღვევს წაკითხვას.
70. „NULL“-ის ნაცვლად გამოყენებული უნდა იყოს „0“.
NULL არის C სტანდარტული ბიბლიოთეკის ნაწილი და მოძველებულია C++-ში.
6 დიზაინი და კომენტარები
6.1 დიზაინი
71. ძირითადი ჩაღრმავება უნდა იყოს ორი სივრცე.ამისთვის (i = 0; i< nElements; i++)
a[i] = 0;
ერთი სივრცის შეწევა საკმარისად მცირეა კოდის ლოგიკური სტრუქტურის ასახვისთვის. 4-ზე მეტი ადგილის ჩაღრმავება ღრმად ჩადგმულ კოდს წაუკითხავად ხდის და ზრდის ხაზების გატეხვის ალბათობას. ფართოდ არის გავრცელებული ვარიანტები 2, 3 ან 4 სივრცეებით; და 2 და 4 - უფრო ფართოდ.
72. კოდის ბლოკები უნდა იყოს დაფორმატებული, როგორც ნაჩვენებია მაგალით 1-ში (რეკომენდებულია) ან მაგალით 2-ში, მაგრამ არავითარ შემთხვევაში, როგორც ნაჩვენებია მაგალით 3-ში. ფუნქციების და კლასების ფორმატირება უნდა მოჰყვეს მე-2 მაგალითს.
სანამ (! შესრულებულია) ( doSomething(); done = moreToDo(); )
სანამ (! შესრულებულია) ( doSomething(); done = moreToDo(); )
სანამ (! შესრულებულია) ( doSomething(); done = moreToDo(); )
მაგალითი 3 იყენებს არასაჭირო შეწევას, რაც ხელს უშლის კოდის ლოგიკური სტრუქტურის ნათლად ჩვენებას.
73. კლასის დეკლარაციები
კლასი SomeClass: საჯარო BaseClass ( საჯარო: ... დაცული: ... კერძო: ... )
ზემოთ ჩამოთვლილი წესის განსაკუთრებული შედეგი.
74. მეთოდების განმარტებები უნდა ჩამოყალიბდეს შემდეგნაირად:
გააუქმეთ someMethod() (...)
75. მშენებლობათუ კიდევ უნდა იყოს ფორმატირებული შემდეგნაირად:
თუ (პირობა) (განცხადებები;) თუ (პირობა) (განცხადებები;) სხვა (განცხადებები;) თუ (პირობა) (განცხადებები;) სხვა თუ (პირობა) (განცხადებები;) სხვა (განცხადებები;)
ზემოთ ჩამოთვლილი წესის დასკვნა. უფრო მეტიც, წერა სხვაიმავე ხაზზე, როგორც პირველი ბლოკის დახურვის ხვეული სამაგრი, არ არის უკანონო:
თუ (პირობა) (განცხადებები;) სხვა (განცხადებები;)
ჯობია თითოეული თუ სხვა ნაწილი ცალკე ხაზზე დავაყენოთ. ეს აადვილებს კოდის მანიპულირებას, როგორიცაა ბლოკის გადატანა სხვა.
76. ციკლიამისთვის უნდა იყოს ფორმატირებული შემდეგნაირად:
იყიდება (ინიციალიზაცია; მდგომარეობა; განახლება) (განცხადებები;)
ზემოთ ჩამოთვლილი წესის დასკვნა.
77. ციკლიამისთვის ცარიელი სხეულით უნდა იყოს ფორმატირებული შემდეგნაირად:
იყიდება (ინიციალიზაცია; მდგომარეობა; განახლება) ;
ხაზს უსვამს მკითხველს, რომ სხეული ცარიელია. თუმცა, სხეულის გარეშე ციკლები თავიდან უნდა იქნას აცილებული.
78. ციკლიხოლო უნდა იყოს ფორმატირებული შემდეგნაირად:
ხოლო (პირობა) (განცხადებები;)
ზემოთ ჩამოთვლილი წესის დასკვნა.
79. ციკლიგავაკეთოთ-ხოლო უნდა იყოს ფორმატირებული შემდეგნაირად:
Do ( განცხადებები; ) while (პირობა);
ზემოთ ჩამოთვლილი წესის დასკვნა.
80. მშენებლობაშეცვლა უნდა იყოს ფორმატირებული შემდეგნაირად:
შეცვლა (პირობა) (შემთხვევა ABC: განცხადებები; // გამოტოვებული "შესვენება" შემთხვევა DEF: განცხადებები; შესვენება; შემთხვევა XYZ: განცხადებები; შესვენება; ნაგულისხმევი: განცხადებები; შესვენება; )
გთხოვთ გაითვალისწინოთ, რომ ყოველი სიტყვა საქმეაქვს ჩაღრმავება მთელ სტრუქტურასთან მიმართებაში, რაც ხელს უწყობს მის ხაზგასმას. ასევე ყურადღება მიაქციეთ მსხვილი ნაწლავის წინ არსებულ სივრცეებს. თუ საკვანძო სიტყვა აკლია სადმე შესვენება, მაშინ კომენტარი უნდა იყოს გაფრთხილება ამის შესახებ. პროგრამისტებს ხშირად ავიწყდებათ ამ სიტყვის დადება, ამიტომ მისი განზრახ გამოტოვების შემთხვევა სპეციალურად უნდა იყოს აღწერილი.
81. მშენებლობაცდა-დაჭერა უნდა იყოს ფორმატირებული შემდეგნაირად:
სცადეთ ( განცხადებები; ) დაჭერა (გამონაკლისი და გამონაკლისი) ( განცხადებები; )
ზემოთ ჩამოთვლილი წესის დასკვნა. კითხვები კონსტრუქციაში ხვეული ბრეკეტების დახურვის შესახებ თუ კიდევ, აქაც მიმართეთ.
82. თუ დიზაინითუ კიდევ შეიცავს მხოლოდ ერთ გამოხატულებას სხეულში, ხვეული ბრეკეტების გამოტოვება შესაძლებელია.
თუ (პირობით) განცხადება; ხოლო (პირობის) განცხადება; ამისთვის (ინიციალიზაცია; მდგომარეობა; განახლება) განცხადება;
მაინც რეკომენდირებულია არ გამოტოვოთ ხვეული ბრეკეტები.
83. ფუნქციის დაბრუნების ტიპი შეიძლება განთავსდეს თავად ფუნქციის სახელის ზემოთ.
ბათილად MyClass::myMethod(void) ( : )
ამ გზით ფუნქციები ერთ სვეტშია გასწორებული.
6.2 ფართები
84.ოპერატორები უნდა იყოს გამოყოფილი სივრცეებით.
- დაჯავშნილ C++ საკვანძო სიტყვებს უნდა მოჰყვეს ინტერვალი.
- მძიმების შემდეგ სივრცეები უნდა განთავსდეს.
- მსხვილი ნაწლავები უნდა იყოს გამოყოფილი სივრცეებით.
- მძიმის შემდეგ მარყუჟში ამისთვისფართები უნდა იყოს ჩართული.
A = (b + c) * d; // არ არის რეკომენდებული: a=(b+c)*d ხოლო (true) // არ არის რეკომენდებული: while(true) (... doSomething(a, b, c, d); // არ არის რეკომენდებული: რაღაცის გაკეთება (a,b,c,d); შემთხვევა 100: // არ არის რეკომენდებული: შემთხვევა 100: for (i = 0; i< 10; i++) { // НЕ РЕКОМЕНДУЕТСЯ: for(i=0;i<10;i++){
...
ხაზს უსვამს გამონათქვამების ცალკეულ ნაწილებს. აუმჯობესებს კითხვადობას. რთულია რეკომენდაციების ყოვლისმომცველი კომპლექტის მიცემა C++-ში ცარიელი სივრცის შესახებ. ზემოთ მოცემული რეკომენდაციები უნდა აჩვენოს ზოგადი პრინციპები.
85. მეთოდების სახელებს შეიძლება მოჰყვეს ინტერვალი, თუ მოჰყვება სხვა სახელი.
DoSomething (currentFile);
ხაზს უსვამს ცალკეულ სახელებს. აუმჯობესებს კითხვადობას. თუ სხვა სახელი არ არის, სივრცე შეიძლება გამოტოვდეს (doSomething()).
კიდევ ერთი მიდგომა არის სივრცის მითითება გახსნის ფრჩხილების შემდეგ. ადამიანები, რომლებიც მას იყენებენ, ასევე, ჩვეულებრივ ათავსებენ ადგილს დახურვის ფრჩხილის წინ: doSomething(currentFile);. ეს საშუალებას აძლევს ცალკეული სახელების ხაზგასმას; დახურვის ფრჩხილამდე სივრცე არაბუნებრივად გამოიყურება, მაგრამ მის გარეშე გამოთქმა ასიმეტრიულად გამოიყურება (doSomething(currentFile);).
86. კოდში ლოგიკური ბლოკები უნდა იყოს გამოყოფილი ცარიელი ხაზით.
Matrix4x4 მატრიცა = new Matrix4x4(); ორმაგი cosAngle = Math.cos(კუთხე); double sinAngle = Math.sin(კუთხე); matrix.setElement(1, 1, cosAngle); matrix.setElement(1, 2, sinAngle); matrix.setElement(2, 1, -sinAngle); matrix.setElement(2, 2, cosAngle); გამრავლება (მატრიცა);
აუმჯობესებს კითხვადობას.
ეს მათ საშუალებას აძლევს უკეთ გამოიჩინონ.
88. დეკლარაციებში ცვლადები შეიძლება გასწორდეს.
AsciiFile* ფაილი; int nPoints; ათწილადი x, y;
აუმჯობესებს კითხვადობას. წყვილები უფრო ნათლად ჩანს ტიპი - ცვლადი.
89. გამოიყენეთ გასწორება იქ, სადაც ის აუმჯობესებს წაკითხვას.
თუ (a == lowValue) compueSomething(); else if (a == mediumValue) computeSomethingElse(); else if (a == highValue) computeSomethingElseYet(); მნიშვნელობა = (პოტენციალი * ზეთის სიმკვრივე) / მუდმივი1 + (სიღრმე * წყლის სიმკვრივე) / მუდმივი2 + (zCoordinateValue * gasDensity) / მუდმივი3; minPosition = computeDistance(min, x, y, z); საშუალო პოზიცია = გამოთვლა მანძილი (საშუალო, x, y, z); შეცვლა (მნიშვნელობა) (საქმე PHASE_OIL: strcpy (ფაზა, "ზეთი"); შესვენება; ქეისი PHASE_WATER: strcpy (ფაზა, "წყალი"); შესვენება; შემთხვევა PHASE_GAS: strcpy (ფაზა, "გაზი"); შესვენება; )
არსებობს მრავალი შემთხვევა, როდესაც კოდი შეიძლება კიდევ უფრო გასწორდეს, მაშინაც კი, თუ ის არღვევს ადრე დადგენილ წესებს.
6.3 კომენტარები
90. რთული სვლების გამოყენებით დაწერილი რთული კოდი არ უნდა იყოს კომენტირებული, არამედ გადაწერილი!თქვენ უნდა გააკეთოთ რაც შეიძლება ნაკლები კომენტარი, გახადოთ კოდი თვითდოკუმენტირებული, სწორი სახელების არჩევით და მკაფიო ლოგიკური სტრუქტურის შექმნით.
91. ყველა კომენტარი უნდა იყოს დაწერილი ინგლისურად.
საერთაშორისო გარემოში ინგლისური სასურველი ენაა.
92. გამოყენება//ყველა კომენტარისთვის, მათ შორის მრავალხაზოვანი.
// კომენტარი, რომელიც მოიცავს // მრავალ ხაზს.
თუ დაიცავთ ამ რეკომენდაციას, გააკეთეთ მრავალხაზოვანი კომენტარები /* */
შეიძლება გამოყენებულ იქნას გამართვისა და სხვა მიზნებისთვის.
შემდეგ // თქვენ უნდა დააყენოთ ინტერვალი, ხოლო თავად კომენტარი უნდა დაიწყოს დიდი ასოთი და დასრულდეს წერტილით.
93. კომენტარები უნდა იყოს მოწყობილი ისე, რომ ისინი ეხებოდეს იმას, რასაც ისინი აღწერენ.
94. კლასების და მეთოდების სათაურების კომენტარები უნდა შეესაბამებოდეს JavaDoc კონვენციებს.
Java პროგრამისტები უფრო მოწინავე მიდგომას ახორციელებენ დოკუმენტაციისადმი სტანდარტული Javadoc ავტომატიზირებული ხელსაწყოს წყალობით, რომელიც არის განვითარების ნაკრების ნაწილი და გაძლევთ საშუალებას ავტომატურად შექმნათ HTML დოკუმენტაცია კომენტარებიდან თქვენს კოდში.
მსგავსი ინსტრუმენტები არსებობს C++-ში. ისინი მიჰყვებიან იგივე ტეგის სინტაქსის კონვენციებს, როგორც JavaDoc (იხილეთ მაგალითად Doc++ ან Doxygen).
7 ბმული
- კოდი სრული, სტივ მაკკონელი - Microsoft Press
- პროგრამირება C++-ში, წესები და რეკომენდაციები, M Henricson, ე. Nyquist, Ellemtel (შვედური ტელეკომი):
მოდით, რამდენიმე განმარტება მივცეთ. C ენაში ნებისმიერი პროგრამა შედგება რამდენიმე პროგრამის ერთეულისგან და თითოეული მათგანი არის ფუნქცია. ფუნქციები C-ში მსგავსია ფუნქციების ან ქვეპროგრამების Fortran-ში ან პროცედურების პასკალში. ფუნქციების სახელები არჩეულია თვითნებურად (მხოლოდ ლათინური ასოებით), მაგრამ ერთ-ერთი მათგანი. მთავარი, სწორედ აქ იწყება პროგრამის შესრულება. ასეთი ძირითადი ფუნქცია, როგორც წესი, იძახებს სხვა ფუნქციებს, რომლებიც იმავე ფაილშია, როგორც მთავარი პროგრამა, ან ამოღებულია წინასწარ მომზადებული ფუნქციების ბიბლიოთეკიდან. მთავარიარ აქვს არგუმენტები, ამიტომ მისი სია ასე გამოიყურება: ()
. ფრჩხილები { }
ჩარჩო ოპერატორები, რომლებიც თავად ახორციელებენ ალგორითმს. ეს ფრჩხილები ჰგავს BEGIN - END-ს პასკალში.
ხაზი int a,b,c;აცხადებს ა, ბ, გმთელი ტიპის ცვლადები. პროგრამაში გამოყენებული ყველა ცვლადი უნდა იყოს დეკლარირებული. შემდეგ მოდის დავალების ოპერატორები ამნიშვნელობა 5
, და ბ - 7
, თან- მათი ჯამის ღირებულება. აკრიფეთ ცვლადი მნიშვნელობები ინტდიაპაზონში არიან [-32768; 32767].
ფუნქცია printfაჩვენებს: ჯამი = 12.
ახლა განვიხილოთ ფუნქცია სკანფიგანკუთვნილია ფორმატირებული მონაცემების შეყვანისთვის. ფუნქცია სკანფიიყენებს ცვლად მისამართებს, ვიდრე მათ მნიშვნელობებს, როგორც რეალურ პარამეტრებს. ამისათვის მოათავსეთ ნიშანი შესაბამისი პარამეტრის წინ & - სიმბოლო მისამართის აღებისთვის. Მაგალითად, &XLნიშნავს "ცვლადი მისამართი XL", არა მნიშვნელობა, რომელსაც ამჟამად აქვს ცვლადი.
ფუნქციის ფორმატის სტრიქონი სკანფიგანსაზღვრავს, რა მონაცემებია მოსალოდნელი შეყვანის სახით. თუ ფუნქცია შეხვდება ნიშანს ფორმატის სტრიქონში % რასაც მოჰყვება კონვერტაციის სიმბოლო, ის გამოტოვებს სიმბოლოებს, სანამ არ შეხვდება ცარიელ სიმბოლოს.
წინა პროგრამას აქვს ერთი ნაკლი: ჯამის გამოსათვლელი პროგრამა მხოლოდ ერთი კონკრეტული შემთხვევისთვისაა შესაფერისი, როცა a=5, b=7. მოდით გავაუმჯობესოთ იგი შესაბამისი დავალების ოპერატორების ფუნქციის გამოძახებით ჩანაცვლებით სკანფი(მაგალითი 1.2):
ფორმატის სტრიქონი განსაზღვრავს ფუნქციებს სკანფიშეიყვანეთ ათობითი რიცხვი, რომელიც უნდა განთავსდეს ცვლადში ა, შემდეგ, გამოყოფილი ინტერვალით, შეიყვანეთ მეორე ათობითი რიცხვი, რომელიც უნდა მიენიჭოს ცვლადს ბ.გაითვალისწინეთ, რომ პროგრამა იწყება კომმინტარიუმის ხაზით: /* .. */ , შემდგენელი გამოტოვებს ნებისმიერ სიმბოლოს /*-სა და */-ს შორის და შეიძლება გამოყენებულ იქნას განმარტებისთვის.
ტეგები: პირველი პროგრამა C. საფუძვლები. სი ბორლანდი. C Code Gear. Si Embarcadero. C MS Visual Studio. C MS Express.
ჩვენი პირველი C პროგრამის დაწერა
პირველ რიგში, თქვენ უნდა დააინსტალიროთ პროგრამა. პრინციპში, არ აქვს მნიშვნელობა რა პროგრამულ უზრუნველყოფას იყენებთ, ისევე როგორც ოპერაციული სისტემა არ არის მნიშვნელოვანი. მაგრამ მთელი კურსის განმავლობაში მე მივცემ მაგალითებს MS Visula Studio 2012 Express Edition-ის გამოყენებით. Visual Studio 2012 Express Edition უფასოა და საკმარისია მთელი კურსის შესასწავლად. გარდა ამისა, როგორც პრაქტიკამ აჩვენა, ის ბევრად უფრო მკაცრია კოდთან მიმართებაში და იძლევა შეცდომებისა და გაფრთხილებების უფრო სრულ აღწერას. ენის შესწავლისას შეგიძლიათ გამოიყენოთ Borland (aka CodeGEAR, aka Embarcadero და ა.შ.), Dev Cpp, MinGW, ან gcc, ან რაც გსურთ.
მაგალითი MS Visual Studio-სთვის
1. გახსენით IDE, გადადით File | შექმენით პროექტი...
2. აირჩიეთ კონსოლის აპლიკაცია და მიეცით სახელი. ამ შემთხვევაში პირველი_პროგრამა
4. მონიშნეთ „ცარიელი პროექტი“ ჩამრთველი.
5. რის შემდეგაც ვიღებთ ცარიელ პროექტის სტრუქტურას. დაამატეთ ახალი ელემენტი: დააწკაპუნეთ საქაღალდეზე მარჯვენა ღილაკით
"საწყისი კოდის ფაილები" | დამატება | ელემენტის შექმნა...
დაამატეთ ახალი cpp ფაილი, მაგრამ შეინახეთ გაფართოებით .c
ფაილს დავარქვით main.c ყველაფერი მზადაა, შეგიძლიათ დაწეროთ პროგრამა. ნაბიჯები სხვა პლატფორმებისთვის.
ბორლანდი
მე მხოლოდ Code Gear C++Builder 2007 მაქვს დაყენებული, მაგრამ სხვა (და წინა) გამოშვებებში ყველაფერი იგივე კეთდება.
1. შევქმნათ ახალი პროექტი File | ახალი | სხვა...
2. დაამატეთ კონსოლის აპლიკაცია
3. აირჩიეთ C ენა
4. ვიღებთ დასრულებულ პროექტს. თქვენ უნდა შეინახოთ ის თქვენთვის სასურველი სახელით. მანამდე, თავად პროექტს და ყველა ფაილს ექნება ნაგულისხმევი სახელები. თქვენ შეგიძლიათ წაშალოთ ის, რაც Borland-მა დაწერა პროგრამის ტექსტში ნაგულისხმევად.
მაგალითი cc/gcc ტერმინალისთვის
გახსენით თქვენი საყვარელი ტექსტური რედაქტორი და დააკოპირეთ პროგრამის კოდი იქ.
#შეიცავს
თუ პროგრამა შეინახეთ ფაილში სახელად hello.c, ჩაწერეთ ბრძანება ტერმინალში
Cc გამარჯობა.c -o გამარჯობა
Gcc გამარჯობა -ო გამარჯობა
ამ შემთხვევაში, ცხადია, თქვენ უნდა იყოთ პროგრამის საქაღალდეში. gcc შექმნის შესრულებად სახელად hello. გაუშვით და გამოვა Hello, World!
ზოგჯერ შეიძლება იყოს პრობლემები წვდომის უფლებებთან დაკავშირებით. შეამოწმეთ, რომ გაქვთ შესრულებადი ფაილი, წინააღმდეგ შემთხვევაში მიეცით საკუთარ თავს მისი გაშვების უფლება.
Chmod 760 გამარჯობა
თუ თქვენ გაქვთ რამდენიმე ფაილი, თქვენ უნდა ჩამოთვალოთ ყველა ფაილის სახელები თანმიმდევრობით. მაგალითად, თუ თქვენ გაქვთ კიდევ ორი ფაილი simple.h და simple.c, მაშინ უნდა დაწეროთ
Cc გამარჯობა.c მარტივი.c -o გამარჯობა
პროგრამის კოდი
ჩვეულებრივ, პირველ პროგრამაში არის Hello, World! ეკრანზე.
#შეიცავს
გაუშვით პროგრამა (Run | Run ან F9 Borland-ისთვის, Build | Build Solution ან F5 MS-ისთვის) პროგრამა გამოჩნდება Hello, World! და დაელოდება რომელიმე კლავიშის დაჭერას.
მოდით შევხედოთ კოდს უფრო დეტალურად. პირველი ორი ხაზი
#შეიცავს
დირექტივები შემდგენელთან სტანდარტული ბიბლიოთეკების stdio (სტანდარტული შეყვანის გამომავალი) და conio (კონსოლის შეყვანის გამომავალი) დასაკავშირებლად. .h გაფართოება მიუთითებს, რომ ეს არის სათაურის ფაილები. შემდგენელი კოპირებს conio და stdio ბიბლიოთეკების კოდს და შესაძლებელს ხდის ამ ბიბლიოთეკებში აღწერილი ფუნქციების გამოყენებას.
Int main (int argc, char* argv)
ეს არის მთავარი ფუნქცია. ის განსხვავდება სხვა ფუნქციებისგან, რომლებიც შეგიძლიათ განსაზღვროთ, რომ არის შესასვლელი წერტილი - პროგრამის შესრულება იწყება მისგან.
მთავარ ფუნქციას აქვს ორი პარამეტრი - პარამეტრების რაოდენობა argc და გავლილი პარამეტრების მასივი argv. ეს არგუმენტები არჩევითია, ასე რომ თქვენ არ გჭირდებათ მათი დაწერა. მათ გამოყენებაზე მოგვიანებით ვისაუბრებთ.
#შეიცავს
მოდით გავაკეთოთ რაღაც უფრო რთული, რომ ვისწავლოთ როგორ დაამატოთ ახალი ფაილები პროგრამაში. ახლა თქვენთვის მნიშვნელოვანია ისწავლოთ როგორ დაამატოთ ახალი ფაილები; თუ კოდის ნაწილი გაურკვეველი რჩება, არ აქვს მნიშვნელობა.
1. შექმენით ახალი სათაურის ფაილი "Header files" საქაღალდეში, დაარქვით simple.h
2. შექმენით ახალი ფაილი simple.c Source Files საქაღალდეში.
3. დაამატეთ მარტივი.თ
#ifndef _SIMPLE_H_ #define _SIMPLE_H_ #include
აქ ჩვენ გამოვაცხადეთ ახალი ფუნქცია doSomething. მას არ აქვს სხეული, ეს იქნება აღწერილი simple.c ფაილში. აქ ჩვენ ასევე მოიცავს stdio და conio ბიბლიოთეკებს
მარტივი .გ
#include "simple.h" void doSomething() ( printf("მუშაობს!"); _getch(); )
ჩვენ ჩავრთავთ header ფაილს simple.c. ის იწერება ორმაგი ბრჭყალებით, რადგან ეს არ არის სტანდარტული ბიბლიოთეკის ფაილი. სტანდარტული ბიბლიოთეკის ფაილები, როგორც წესი, მდებარეობს თავად IDE-ის ჩათვლით საქაღალდეში. თუ ჩვენს ფაილებს იქ მოვათავსებთ, მათი დეკლარირება შესაძლებელია კუთხის ფრჩხილებშიც. თქვენ ასევე შეგიძლიათ გამოიყენოთ აბსოლუტური ფაილის ბილიკები ორმაგ ბრჭყალებში. ვინაიდან ჩვენ უკვე ჩავრთეთ conio და stdio ბიბლიოთეკები .h ფაილში, ისინი „ხილულია“ .c ფაილში.
შემდეგი, ძირითადში.გ