Kurakuran da Aka Fi Sani a Shirye-shiryen C++ da Yadda Ake Gyara Su
Shirye-shiryen C++ yana ɗaya daga cikin harsunan shirye-shirye mafi ƙarfi da sassauƙa. Tare da ikonsa na tallafawa shirye-shiryen tsari, waɗanda suka dogara da abu, da kuma na gama gari, ana amfani da C++ sosai a cikin aikace-aikace iri-iri, tun daga tsarin aiki zuwa aikace-aikacen wasanni masu inganci. Duk da haka, kamar kowane harshe na shirye-shirye, C++ yana da kurakurai da yawa da masu haɓakawa, sababbi da ƙwararru, galibi ke fuskanta. Wannan labarin zai tattauna wasu kurakurai da aka saba gani a cikin shirye-shiryen C++ kuma ya ba da jagora kan yadda za a gyara su.
1. Amfani da Manufofi marasa tushe
Kuskure:
Mai nuna ba tare da an fara ba zai iya nuna wurin da ba a san shi ba, wanda hakan zai haifar da ɗabi'ar da ba a zata ba ko kuma gazawar shirin. Misalin wannan kuskuren shine kamar haka:
"cpp
int ptr; // ba a fara ptr ba
ptr = 10; // Kuskure: ba a fara nuna alama ba
““
Yadda ake gyarawa:
Fara amfani da alamar kafin amfani. Za ka iya fara ta da `nullptr` ko kuma da adireshin ƙwaƙwalwar ajiya mai inganci.
"cpp
int ptr = nullptr; // Fara da nullptr
ƙimar int = 10;
ptr = &darajar;
ptr = 20; // Yanzu lafiya
““
2. Kurakurai a Gudanar da Ƙwaƙwalwa (Zubar Ƙwaƙwalwa)
Kuskure:
Ana samun ɓullar ƙwaƙwalwa idan ba a sake fitar da ƙwaƙwalwar da aka ware ba. Wannan na iya sa aikace-aikacen ya yi amfani da ƙarin ƙwaƙwalwa akan lokaci, wanda daga ƙarshe zai haifar da ƙarancin ƙwaƙwalwa.
"cpp
int ptr = sabon int[10];
// Manta da goge ƙwaƙwalwar da aka ware
““
Yadda ake gyarawa:
Koyaushe tabbatar da cewa an cire ƙwaƙwalwar da aka ware ta amfani da 'share' ko 'share[]' dangane da abin da aka yi amfani da shi don rarraba shi.
"cpp
int ptr = sabon int[10];
// Amfani da ƙwaƙwalwa…
share[] ptr; // Ƙwaƙwalwar ajiya da aka ware kyauta
““
Yi amfani da ɗakin karatu mai nuna wayo (kamar `std::unique_ptr` ko `std::shared_ptr`) don sauƙaƙa sarrafa ƙwaƙwalwa.
"cpp
sun hada da
std::unique_ptr ptr(sabon int[10]);
// Za a fitar da ƙwaƙwalwar ajiya ta atomatik lokacin da ptr ya fita daga sararin samaniya
““
3. Kurakurai wajen Amfani da Nassoshi
Kuskure:
Mayar da wani ma'auni ko nuni zuwa ga wani ma'auni na gida wanda ya wuce gona da iri na iya haifar da ɗabi'a mara tsammani.
"cpp
int& getReference() {
ƙimar int = 10;
ƙimar dawowa; // Kuskure: dawo da ma'ana zuwa ga ma'aunin gida
}
““
Yadda ake gyarawa:
A guji mayar da nassoshi ga masu canji na gida. Madadin haka, yi amfani da masu canji marasa canzawa, ko mafi kyau, dawo da ƙima, ko kuma yi la'akari da amfani da abubuwa.
"cpp
int getValue() {
ƙimar int = 10;
ƙimar dawowa; // Mafi aminci
}
““
4. Yi watsi da Saƙonnin Kuskuren Mai Tattarawa da Gargaɗi
Kuskure:
Masu shirye-shirye galibi suna yin watsi da saƙonnin kuskure da gargaɗin da mai tarawa ke bayarwa, duk da cewa waɗannan saƙonnin suna ba da mahimman bayanai game da kurakurai masu yuwuwa.
Yadda ake gyarawa:
Kullum a duba kuma a fahimci saƙonnin kuskure da gargaɗin da mai tarawa ya samar. A kunna gargaɗin mataki-mataki don tabbatar da tsaftar lambar.
Misali a GCC, yi amfani da tutar `-Wall` don samar da ƙarin gargaɗi.
"Bash
shirin g++ -Wall -o main.cpp
““
5. Kuskure a cikin Yawan Lodawa na Mai Aiki
Kuskure:
Yawan aiki mara kyau na mai aiki na iya haifar da ɗabi'a mara tsammani ko kurakuran lokacin aiki.
"cpp
class MyClass {
jama'a:
int bayanai;
Mai aiki na MyClass+ (const MyClass& wasu) {
dawo da bayanai + wasu bayanai; // Kuskure: yakamata ya dawo da MyClass
}
};
““
Yadda ake gyarawa:
Tabbatar cewa mai aiki da aka yi wa lodi ya dawo da nau'in da ya dace kuma ya kiyaye abubuwan da ba su dace ba na aji.
"cpp
class MyClass {
jama'a:
int bayanai;
Mai aiki na MyClass+ (const MyClass& wasu) {
Sakamakon MyClass;
sakamako.bayanai = bayanai + wasu.bayanai;
dawo da sakamako; // Yana dawo da abu daga MyClass
}
};
““
6. Amfani da Macros ba daidai ba
Kuskure:
A wasu lokutan ana amfani da macros fiye da kima ko kuma ba daidai ba, wanda hakan na iya haifar da kurakurai da wahalar ganowa a lokacin aiki.
"cpp
ayyana SQUARE(x) xx
sakamakon int = SQUARE(5 + 1); // Kuskure: sakamakon shine 5 + 1 5 + 1
““
Yadda ake gyarawa:
Sauya macros da maganganu ko samfura akai-akai don ingantaccen tsaro da sarrafawa na nau'in.
"cpp
template
Murabba'i T (T x) {
dawo da xx;
}
sakamakon int = murabba'i(5 + 1); // Amintaccen amfani
““
7. Amfani da Ayyukan Salon C Ba bisa Ka'ida ba
Kuskure:
Amfani da ayyukan C-style kamar `strcpy` ko `sprintf` waɗanda ke da sauƙin kamuwa da ambaliya.
"cpp
char src[] = "Sannu, Duniya!";
char dest[5];
strcpy(ƙarewa, src); // Kuskure: ambaliya mai cikewa
““
Yadda ake gyarawa:
Yi amfani da ayyukan C++ mafi aminci kamar `std::string` ko `std::vector`.
"cpp
sun hada da
std::string src = “Sannu, Duniya!”;
std::string dest = src;
““
8. Yin watsi da Gano Kuskure
Kuskure:
Yi watsi da duba kurakurai akan ayyukan I/O ko ayyukan da ka iya kasawa.
"cpp
fayil ɗin std::ifstream(“data.txt”);
// Kuskure: bai duba ko an buɗe fayil ɗin cikin nasara ba
““
Yadda ake gyarawa:
Koyaushe a duba ko aikin ya yi nasara kuma a kula da kurakurai yadda ya kamata.
"cpp
fayil ɗin std::ifstream(“data.txt”);
idan (!fayil) {
std::cerr << “An kasa buɗe fayil” << std::endl;
dawo 1;
}
““
9. Aiwatar da Zagaye mara kyau
Kuskure:
Amfani da madaukai marasa kyau na iya haifar da raguwar aikin shirin.
"cpp
don (int i = 0; i < vec.size(); i++) {
// Tsarin aiki tare da vec[i]
// Kuskure: girman() ana kiransa akan kowace maimaitawa
}
““
Yadda ake gyarawa:
Inganta madaukai ta hanyar rage maimaita kiran aiki.
"cpp
don (std::size_t i = 0, n = vec.size(); i < n; i++) {
// Tsarin aiki tare da vec[i]
}
““
Haka kuma yi amfani da algorithms na STL kamar `std::for_each` don ƙarin ingantawa.
"cpp
sun hada da
std::for_each(vec.begin(), vec.end(), [](int &value) {
// Tsarin aiki tare da ƙima
});
““
10. Kuskure a Gudanar da Zaren
Kuskure:
Rashin yin amfani da zare na iya haifar da yanayi na tsere ko kuma rashin daidaito.
"cpp
hada da gudu mara kyau() {
// Kuskure: Yanayin tsere na iya faruwa
}
std::thread t1(gudu);
std::thread t2(gudu);
““
Yadda ake gyarawa:
Yi amfani da kayan aiki na daidaitawa kamar mutexes don hana yanayin tsere da rashin nasara.
"cpp
hada da hada
std::mutex mtx;
void run() {
std::kulle_kulle_makulli(mtx);
// Tsarin da ya fi aminci daga yanayin tsere
}
std::thread t1(gudu);
std::thread t2(gudu);
t1.haɗi();
t2.haɗi();
““
Kammalawa
C++ harshe ne mai ƙarfi da sassauƙa na shirye-shirye, amma kuma yana iya fuskantar kurakurai na yau da kullun, musamman waɗanda suka shafi sarrafa ƙwaƙwalwa da nuni. Ta hanyar fahimtar waɗannan kurakuran da sanin yadda ake gyara su, za ku iya ƙirƙirar aikace-aikace masu inganci da inganci. Ku tuna koyaushe ku kula da saƙonnin mai tarawa, amfani da kayan aikin zamani waɗanda ke taimaka muku rubuta lambar tsaro , da kuma ci gaba da haɓaka ƙwarewar ku wajen fahimtar da amfani da mafi kyawun ayyukan shirye-shiryen C++.
