C++ ක්‍රමලේඛනයේ පොදු වැරදි සහ ඒවා නිවැරදි කරන්නේ කෙසේද?
C++ ක්‍රමලේඛනය යනු වඩාත් බලගතු සහ නම්‍යශීලී ක්‍රමලේඛන භාෂාවකි. ක්‍රියා පටිපාටික, වස්තු-නැඹුරු සහ සාමාන්‍ය ක්‍රමලේඛනයට සහාය දැක්වීමේ හැකියාව ඇතිව, C++ මෙහෙයුම් පද්ධතිවල සිට ඉහළ කාර්යසාධනයක් සහිත ක්‍රීඩා යෙදුම් දක්වා විවිධ යෙදුම්වල බහුලව භාවිතා වේ. කෙසේ වෙතත්, ඕනෑම ක්‍රමලේඛන භාෂාවක් මෙන්, C++ හි ද නව සහ පළපුරුදු සංවර්ධකයින් බොහෝ විට මුහුණ දෙන පොදු දෝෂ ගණනාවක් ඇත. මෙම ලිපියෙන් C++ ක්‍රමලේඛනයේ ඇති පොදු දෝෂ කිහිපයක් සාකච්ඡා කර ඒවා නිවැරදි කරන්නේ කෙසේද යන්න පිළිබඳ මග පෙන්වීමක් ලබා දෙනු ඇත.
1. ආරම්භ නොකළ දර්ශක භාවිතා කිරීම
දෝෂය:
ආරම්භ නොකළ දර්ශකයක් නොදන්නා මතක ස්ථානයකට යොමු කළ හැකි අතර, එය අනපේක්ෂිත හැසිරීමක් හෝ ක්‍රමලේඛ බිඳවැටීමක් ඇති කරයි. මෙම දෝෂයට උදාහරණයක් පහත පරිදි වේ:
"'cpp
int ptr; // ptr ආරම්භ කර නැත
ptr = 10; // දෝෂය: දර්ශකය ආරම්භ කර නොමැත
""
නිවැරදි කරන්නේ කෙසේද:
භාවිතයට පෙර දර්ශකය ආරම්භ කරන්න. ඔබට එය `nullptr` හෝ වලංගු මතක ලිපිනයක් සමඟ ආරම්භ කළ හැක.
"'cpp
int ptr = nullptr; // nullptr සමඟ ආරම්භ කරන්න
int අගය = 10;
ptr = &අගය;
ptr = 20; // දැන් ආරක්ෂිතයි
""
2. මතක කළමනාකරණයේ දෝෂ (මතක කාන්දුව)
දෝෂය:
වෙන් කරන ලද මතකය නැවත මුදා නොහරින විට මතක කාන්දුවක් සිදු වේ. මෙය යෙදුමක් කාලයත් සමඟ වැඩි වැඩියෙන් මතකය භාවිතා කිරීමට හේතු විය හැකි අතර, අවසානයේ මතක හිඟයකට හේතු වේ.
"'cpp
int ptr = නව int[10];
// වෙන් කළ මතකය මකා දැමීමට අමතක කරන්න
""
නිවැරදි කරන්නේ කෙසේද:
වෙන් කරන ලද මතකය වෙන් කිරීමට භාවිතා කළ දේ මත පදනම්ව, `delete` හෝ `delete[]` භාවිතයෙන් සැමවිටම නිදහස් කිරීමට වග බලා ගන්න.
"'cpp
int ptr = නව int[10];
// මතක භාවිතය…
මකන්න[] ptr; // නිදහස් වෙන් කළ මතකය
""
මතක කළමනාකරණය පහසු කිරීම සඳහා ස්මාර්ට් පොයින්ටර් පුස්තකාලයක් (`std::unique_ptr` හෝ `std::shared_ptr` වැනි) භාවිතා කරන්න.
"'cpp
ඇතුළත් වේ
සම්මත::යුනික්_පීටීආර් ptr(නව int[10]);
// ptr විෂය පථයෙන් පිටවන විට මතකය ස්වයංක්‍රීයව මුදා හරිනු ඇත.
""
3. යොමු භාවිතා කිරීමේදී සිදුවන වැරදි
දෝෂය:
විෂය පථයෙන් පිටතට ගිය දේශීය විචල්‍යයකට යොමුවක් හෝ දර්ශකයක් ආපසු යැවීම අනපේක්ෂිත හැසිරීම් ඇති කළ හැකිය.
"'cpp
int& යොමුව ලබා ගන්න() {
int අගය = 10;
ප්‍රතිලාභ අගය; // දෝෂය: දේශීය විචල්‍යයකට යොමුවක් ආපසු ලබා දීම
}
""
නිවැරදි කරන්නේ කෙසේද:
දේශීය විචල්‍යයන් වෙත යොමු කිරීම් ආපසු ලබා දීමෙන් වළකින්න. ඒ වෙනුවට, ස්ථිතික විචල්‍යයන් භාවිතා කරන්න, නැතහොත් ඊටත් වඩා හොඳ අගයන් ආපසු ලබා දෙන්න, නැතහොත් වස්තූන් භාවිතා කිරීම සලකා බලන්න.
"'cpp
int අගය ලබා ගන්න() {
int අගය = 10;
ප්‍රතිලාභ අගය; // ආරක්ෂිතයි
}
""
4. සම්පාදක දෝෂ පණිවිඩ සහ අනතුරු ඇඟවීම් නොසලකා හරින්න.
දෝෂය:
ක්‍රමලේඛකයින් බොහෝ විට සම්පාදකයා විසින් නිකුත් කරන ලද දෝෂ පණිවිඩ සහ අනතුරු ඇඟවීම් නොසලකා හරිති, නමුත් මෙම පණිවිඩ විභව දෝෂ පිළිබඳ වැදගත් තොරතුරු සපයයි.
නිවැරදි කරන්නේ කෙසේද:
සම්පාදකය මඟින් ජනනය කරන දෝෂ පණිවිඩ සහ අනතුරු ඇඟවීම් සැමවිටම පරීක්ෂා කර තේරුම් ගන්න. කේතය පිරිසිදු කිරීම සහතික කිරීම සඳහා ඉහළ මට්ටමේ අනතුරු ඇඟවීම් සක්‍රීය කරන්න.
උදාහරණයක් ලෙස GCC හි, තවත් අනතුරු ඇඟවීම් ජනනය කිරීමට `-Wall` ධජය භාවිතා කරන්න.
"`බෑෂ්
g++ -Wall -o වැඩසටහන main.cpp
""
5. ක්‍රියාකරු අධි බර පැටවීමේ දෝෂය
දෝෂය:
වැරදි ක්‍රියාකරු අධි බර පැටවීම අනපේක්ෂිත හැසිරීම් හෝ ධාවන කාල දෝෂ ඇති කළ හැකිය.
"'cpp
පන්තිය මගේ පන්තිය {
පොදු:
int දත්ත;
MyClass ක්‍රියාකරු+ (const MyClass& වෙනත්) {
දත්ත + other.data ආපසු ලබා දෙන්න; // දෝෂය: MyClass ආපසු ලබා දිය යුතුය
}
};
""
නිවැරදි කරන්නේ කෙසේද:
අධි බර පටවන ලද ක්‍රියාකරු සුදුසු වර්ගය ආපසු ලබා දෙන බවටත් පන්තියේ වෙනස් නොවන දේ සංරක්ෂණය කරන බවටත් වග බලා ගන්න.
"'cpp
පන්තිය මගේ පන්තිය {
පොදු:
int දත්ත;
MyClass ක්‍රියාකරු+ (const MyClass& වෙනත්) {
MyClass ප්‍රතිඵලය;
ප්‍රතිඵල.දත්ත = දත්ත + වෙනත්.දත්ත;
ප්‍රතිඵලය ආපසු ලබා දෙයි; // MyClass වෙතින් වස්තුවක් ආපසු ලබා දෙයි
}
};
""
6. මැක්‍රෝස් අනිසි ලෙස භාවිතා කිරීම
දෝෂය:
මැක්‍රෝ සමහර විට අධික ලෙස හෝ වැරදි ලෙස භාවිතා කරනු ලැබේ, එමඟින් ධාවන වේලාවේදී අනාවරණය කර ගැනීමට අපහසු දෝෂ ඇති විය හැක.
"'cpp
SQUARE(x) xx නිර්වචනය කරන්න
int ප්‍රතිඵලය = SQUARE(5 + 1); // දෝෂය: ප්‍රතිඵලය 5 + 1 5 + 1 වේ
""
නිවැරදි කරන්නේ කෙසේද:
වඩා හොඳ ටයිප් ආරක්ෂාව සහ පාලනය සඳහා මැක්‍රෝ නියත ප්‍රකාශන හෝ සැකිලි සමඟ ප්‍රතිස්ථාපනය කරන්න.
"'cpp
සැකිල්ල
T චතුරස්‍රය(T x) {
ආපසු xx;
}
int ප්‍රතිඵලය = වර්ග(5 + 1); // භාවිතා කිරීමට ආරක්ෂිතයි
""
7. C-style ශ්‍රිත අනිසි ලෙස භාවිතා කිරීම
දෝෂය:
බෆර පිටාර ගැලීමට ගොදුරු විය හැකි `strcpy` හෝ `sprintf` වැනි C-විලාස ශ්‍රිත භාවිතා කිරීම.
"'cpp
char src[] = "හෙලෝ, ලෝකය!";
චාර් ඩෙස්ට්[5];
strcpy(dest, src); // දෝෂය: බෆරය පිටාර ගැලීම
""
නිවැරදි කරන්නේ කෙසේද:
`std::string` හෝ `std::vector` වැනි ආරක්ෂිත C++ ශ්‍රිත භාවිතා කරන්න.
"'cpp
ඇතුළත් වේ
std::string src = “හෙලෝ, ලෝකය!”;
std::string dest = src;
""
8. දෝෂ හඳුනාගැනීම නොසලකා හැරීම
දෝෂය:
අසාර්ථක විය හැකි I/O මෙහෙයුම් හෝ ශ්‍රිතවල දෝෂ පරීක්ෂාව නොසලකා හරින්න.
"'cpp
std::ifstream ගොනුව(“data.txt”);
// දෝෂය: ගොනුව සාර්ථකව විවෘත කර ඇත්දැයි පරීක්ෂා කළේ නැත
""
නිවැරදි කරන්නේ කෙසේද:
මෙහෙයුම සාර්ථකද යන්න සැමවිටම පරීක්ෂා කර දෝෂ නිසි ලෙස හසුරුවන්න.
"'cpp
std::ifstream ගොනුව(“data.txt”);
(! ගොනුව) { නම්
std::cerr << “ගොනුව විවෘත කිරීමට අසමත් විය” << std::endl;
ආපසු 1;
}
""
9. උපප්‍රශස්ත ලූප ක්‍රියාත්මක කිරීම
දෝෂය:
උපප්‍රශස්ත ලූප භාවිතා කිරීම වැඩසටහන් කාර්ය සාධනය අඩුවීමට හේතු විය හැක.
"'cpp
(int i = 0; i < vec.size(); i++) සඳහා {
// vec[i] සමඟ ක්‍රියාවලිය
// දෝෂය: සෑම පුනරාවර්තනයකදීම size() කැඳවන ලදී
}
""
නිවැරදි කරන්නේ කෙසේද:
නැවත නැවත ක්‍රියාකාරී ඇමතුම් අඩු කිරීමෙන් ලූප ප්‍රශස්ත කරන්න.
"'cpp
(std::size_t i = 0, n = vec.size(); i <n; i++) සඳහා {
// vec[i] සමඟ ක්‍රියාවලිය
}
""
තවදුරටත් ප්‍රශස්තිකරණය සඳහා `std::for_each` වැනි STL ඇල්ගොරිතම වලින් ප්‍රයෝජන ගන්න.
"'cpp
ඇතුළත් වේ
std::for_each(vec.begin(), vec.end(), [](int &value) {
// අගය සහිත ක්‍රියාවලිය
});
""
10. නූල් හැසිරවීමේ දෝෂය
දෝෂය:
නූල් වැරදි ලෙස හැසිරවීම තරඟ තත්වයන්ට හෝ අවහිරතා වලට හේතු විය හැක.
"'cpp
void run() { ඇතුළත් කරන්න
// දෝෂය: ධාවන තත්ත්වය ඇති විය හැක
}
std::නූල් t1(ධාවනය);
std::නූල් t2(ධාවනය);
""
නිවැරදි කරන්නේ කෙසේද:
තරඟ තත්වයන් සහ අවහිරතා වැළැක්වීම සඳහා මුටෙක්ස් වැනි සමමුහුර්තකරණ ප්‍රාථමික භාවිතා කරන්න.
"'cpp
ඇතුළත් කරන්න ඇතුළත් කරන්න
සම්මත::මුටෙක්ස් mtx;
අවලංගු ධාවනය () {
std::lock_guard අගුල(mtx);
// තරඟ තත්වයන්ගෙන් ආරක්ෂිත ක්‍රියාවලියක්
}
std::නූල් t1(ධාවනය);
std::නූල් t2(ධාවනය);
t1.එකතු වන්න();
t2.එකතු වන්න();
""
නිගමනය
C++ යනු බලවත් හා නම්‍යශීලී ක්‍රමලේඛන භාෂාවකි, නමුත් එය විශේෂයෙන් මතකය සහ දර්ශක කළමනාකරණයට අදාළ පොදු දෝෂ වලටද ගොදුරු වේ. මෙම දෝෂ තේරුම් ගැනීමෙන් සහ ඒවා නිවැරදි කරන්නේ කෙසේදැයි දැන ගැනීමෙන්, ඔබට වඩාත් විශ්වාසදායක සහ කාර්යක්ෂම යෙදුම් සංවර්ධනය කළ හැකිය . සම්පාදක පණිවිඩ කෙරෙහි සැමවිටම අවධානය යොමු කිරීමට, ආරක්ෂිත කේත ලිවීමට උපකාරී වන නවීන මෙවලම් භාවිතා කිරීමට සහ C++ ක්‍රමලේඛන හොඳම භාවිතයන් තේරුම් ගැනීමට සහ යෙදීමට ඔබේ කුසලතා නිරන්තරයෙන් ඔප් නංවා ගැනීමට මතක තබා ගන්න.
