געוויינטלעכע טעותים אין C++ פּראָגראַמירן און ווי זיי צו פאַרריכטן

געוויינטלעכע טעותים אין C++ פּראָגראַמירן און ווי זיי צו פאַרריכטן

C++ פּראָגראַמירן איז איינע פון ​​די מערסט שטאַרקע און פלעקסיבלע פּראָגראַמיר שפּראַכן. מיט איר מעגלעכקייט צו שטיצן פּראָצעדוראַלע, אָביעקט-אָריענטירטע און אַלגעמיינע פּראָגראַמירן, ווערט C++ ברייט גענוצט אין אַ ברייטע פאַרשיידנקייט פון אַפּליקאַציעס, פון אָפּערירן סיסטעמען ביז הויך-פּערפאָרמאַנס גיימינג אַפּליקאַציעס. אָבער, ווי יעדע פּראָגראַמיר שפּראַך, האט C++ אויך אַ צאָל געוויינטלעכע טעותים וואָס דעוועלאָפּערס, סיי נייע און סיי דערפאַרענע, טרעפן אָפט. דער אַרטיקל וועט דיסקוטירן עטלעכע געוויינטלעכע טעותים אין C++ פּראָגראַמירן און געבן גיידאַנס ווי אַזוי זיי צו פאַרריכטן.

1. ניצן נישט-איניציאליזירטע פּוינטערס

טעות:
אַן נישט-איניציאליזירטער פּוינטער קען ווײַזן אויף אַן אומבאַקאַנטן זכּרון אָרט, וואָס קען פאַראורזאַכן אומגעריכטע נאַטור אָדער אַ פּראָגראַם קראַך. אַ בייַשפּיל פֿון דעם טעות איז ווי גייט:

"קפּפּ
int ptr; // ptr איז נישט איניציאליזירט
ptr = 10; // טעות: צייגער נישט איניציאליזירט
““

ווי אזוי צו פאררעכטן:
איניציאליזירט דעם צייגער פארן באניץ. איר קענט עס איניציאליזירן מיט `nullptr` אדער מיט א גילטיגע זכרון אדרעס.

"קפּפּ
int ptr = nullptr; // איניציאליזירן מיט nullptr
ינט ווערט = 10;
ptr = &ווערט;
ptr = 20; // איצט זיכער
““

2. טעותים אין זכּרון פאַרוואַלטונג (זכּרון ליק)

טעות:
א זכּרון-ליק פּאַסירט ווען צוגעטיילטע זכּרון ווערט נישט ווידער-באַפֿרײַט. דאָס קען פֿאַראורזאַכן אַן אַפּליקאַציע צו נוצן מער און מער זכּרון מיט דער צײַט, וואָס וועט בסוף פֿירן צו אַ זכּרון-מאַנגל.

"קפּפּ
אינט פּטר = נייַ אינט[10];
// פארגעסן צו אויסמעקן די צוגעטיילטע זכרון
““

ווי אזוי צו פאררעכטן:
זייט זיכער צו באַפֿרײַען אַלאַקירטע זכּרון ניצנדיק `delete` אָדער `delete[]` לויט וואָס איז געניצט געוואָרן צו עס אַלאַקירן.

"קפּפּ
אינט פּטר = נייַ אינט[10];
// זכּרון באַניץ…
delete[] ptr; // פרייע צוגעטיילטע זכּרון
““

ניצט אַ קלוגע פּוינטערס ביבליאָטעק (ווי `std::unique_ptr` אדער `std::shared_ptr`) צו מאַכן זכּרון פאַרוואַלטונג גרינגער.

"קפּפּ
אַרייַננעמען

std::unique_ptr ptr(נייַער אינטעלעקט[10]);
// זכּרון וועט ווערן אויטאָמאַטיש באַפֿרײַט ווען ptr פֿאַרלאָזט דעם סקאָופּ
““

3. טעותים אין ניצן רעפערענצן

טעות:
צוריקגעבן א רעפערענץ אדער ווייזער צו א לאקאלע וועריאבעל וואס איז ארויס פון זיין סקאפע קען פאראורזאכן אומגעריכטע אויפפירונג.

"קפּפּ
אינט& באַקומען רעפערענץ() {
ינט ווערט = 10;
צוריקקער ווערט; // טעות: צוריקקערן א רעפערענץ צו א לאקאלע וועריאבעל
}
““

ווי אזוי צו פאררעכטן:
פֿאַרמײַדט צוריקגעבן רעפֿערענצן צו לאָקאַלע וועריאַבלען. אַנשטאָט, ניצט סטאַטישע וועריאַבלען, אָדער נאָך בעסער, צוריקגעבן ווערטן, אָדער באַטראַכט ניצן אָביעקטן.

"קפּפּ
אינט געט ווערט() {
ינט ווערט = 10;
צוריקקער ווערט; // זיכערער
}
““

4. איגנארירן קאָמפּיילער טעות מעלדונגען און וואָרענונגען

טעות:
פּראָגראַמירער איגנאָרירן אָפט טעות מעלדונגען און וואָרענונגען ארויסגעגעבן דורך דעם קאָמפּיילער, כאָטש די מעלדונגען צושטעלן וויכטיקע אינפֿאָרמאַציע וועגן פּאָטענציעלע טעותים.

ווי אזוי צו פאררעכטן:
שטענדיק קאָנטראָלירן און פֿאַרשטיין די טעות מעלדונגען און וואָרענונגען גענערירט דורך דעם קאָמפּיילער. אַקטיווירן הויך-לעוועל וואָרענונגען צו ענשור ריינער קאָד.

למשל אין GCC, ניצט דעם `-Wall` פאָן צו דזשענערירן מער וואָרענונגען.

"באַש
g++ -Wall -o פּראָגראַם main.cpp
““

5. טעות אין אָפּעראַטאָר אָוווערלאָודינג

טעות:
אומריכטיקע אפעראטאר איבערלאדונג קען פאראורזאכן אומגעריכטע אויפפירונג אדער ראנטיים ערראָרס.

"קפּפּ
קלאַס MyClass {
עפנטלעך:
אינט דאַטן;
מײַן קלאַס אָפּעראַטאָר+ (קאָנסט מײַן קלאַס& אַנדערע) {
צוריקגעבן דאטן + אנדערע.דאטן; // טעות: זאל צוריקגעבן מיין קלאס
}
};
““

ווי אזוי צו פאררעכטן:
זייט זיכער אז דער איבערגעלאדענער אפעראטאר גיט צוריק דעם פאסיגן טיפ און באווארנט די אומפארענדערלעכע פונקטן פון דער קלאס.

"קפּפּ
קלאַס MyClass {
עפנטלעך:
אינט דאַטן;
מײַן קלאַס אָפּעראַטאָר+ (קאָנסט מײַן קלאַס& אַנדערע) {
מייַן קלאַס רעזולטאַט;
רעזולטאַט.דאַטן = דאַטן + אַנדערע.דאַטן;
צוריקגעבן רעזולטאַט; // צוריקגעבן אַן אָביעקט פֿון מײַן קלאַס
}
};
““

6. מיסברויַך פֿון מאַקראָס

טעות:
מאַקראָס ווערן מאַנטשמאָל גענוצט צו פיל אָדער נישט ריכטיק, וואָס קען פירן צו טעותים וואָס זענען שווער צו דעטעקטירן בעת ​​לויף-צייט.

"קפּפּ
דעפינירן קוואַדראַט(x) xx

גאַנץ רעזולטאַט = קוואַדראַט(5 + 1); // טעות: דער רעזולטאַט איז 5 + 1 5 + 1
““

ווי אזוי צו פאררעכטן:
פאַרבייַטן מאַקראָס מיט קאָנסטאַנטע אויסדרוקן אָדער טעמפּלאַטן פֿאַר בעסערע טיפּ זיכערהייט און קאָנטראָל.

"קפּפּ
מוסטער
ט קוואַדראַט(ט x) {
צוריקקער xx;
}

גאַנץ רעזולטאַט = קוואַדראַט(5 + 1); // זיכער צו נוצן
““

7. אומרעכטע באַניץ פון C-סטיל פונקציעס

טעות:
ניצן C-סטיל פונקציעס ווי `strcpy` אדער `sprintf` וועלכע זענען אויסגעשטעלט צו באַפער אָוווערפלאָו.

"קפּפּ
char src[] = "העלא, וועלט!";
כאַראַקטער דעסטאַניישאַן[5];
strcpy(dest, src); // טעות: באַפער אָוווערפלאָו
““

ווי אזוי צו פאררעכטן:
ניצט זיכערערע C++ פונקציעס ווי `std::string` אדער `std::vector`.

"קפּפּ
אַרייַננעמען
std::string src = "העלא, וועלט!";
std::string דעסט = src;
““

8. איגנאָרירן טעות דעטעקציע

טעות:
איגנאָרירן טעות קאָנטראָל אויף I/O אָפּעראַציעס אָדער פונקציעס וואָס קענען דורכפאַלן.

"קפּפּ
std::ifstream טעקע("דאטן.טקסט");
// טעות: נישט געטשעקט צי די טעקע איז געראָטן געעפנט געוואָרן
““

ווי אזוי צו פאררעכטן:
שטענדיק קאָנטראָלירן צי די אָפּעראַציע איז געווען געראָטן און האַנדלען מיט ערראָרס ריכטיק.

"קפּפּ
std::ifstream טעקע("דאטן.טקסט");
אויב (!טעקע) {
std::cerr << "נישט געקענט עפענען די טעקע" << std::endl;
קסנומקס צוריקקומען;
}
““

9. סובאָפּטימאַלע שלייף ימפּלעמענטאַציע

טעות:
ניצן נישט-אפטימאַלע לופּס קען פאַראורזאַכן אַ פאַרקלענערונג אין פּראָגראַם פאָרשטעלונג.

"קפּפּ
פֿאַר (int i = 0; i < vec.size(); i++) {
// פּראָצעס מיט vec[i]
// טעות: size() גערופן ביי יעדער איטעראציע
}
““

ווי אזוי צו פאררעכטן:
אָפּטימיזירן לופּס דורך רעדוצירן ריפּיטיד פונקציע רופן.

"קפּפּ
פֿאַר (std::size_t i = 0, n = vc.size(); i < n; i++) {
// פּראָצעס מיט vec[i]
}
““

ניצט אויך אויס STL אַלגעריטמען ווי `std::for_each` פֿאַר ווייטערדיקע אָפּטימיזאַציע.

"קפּפּ
אַרייַננעמען
std::for_each(vec.begin(), vec.end(), [](int &ווערט) {
// פּראָצעס מיט ווערט
});
““

10. טעות אין פֿאָדעם האַנדלינג

טעות:
שלעכטע האַנדלינג פון פֿעדעם קען פירן צו ראַסע באדינגונגען אָדער דעדלאַקס.

"קפּפּ
אַרייַננעמען פּאָיד לויף () {
// טעות: ראַסע צושטאַנד קען פּאַסירן
}

std::thread t1(לויפן);
std::thread t2(לויפן);
““

ווי אזוי צו פאררעכטן:
ניצט סינקראָניזאַציע פּרימיטיוון ווי מוטעקסעס צו פאַרמייַדן ראַסע באדינגונגען און דעדלאַקס.

"קפּפּ
אַרייַננעמען אַרייַננעמען

std::mutex mtx;

פּאָיד לויף() {
std::lock_guard שלאָס(mtx);
// א פּראָצעס וואָס איז זיכער פֿון ראַסע באַדינגונגען
}

std::thread t1(לויפן);
std::thread t2(לויפן);

ט1.דזשוין();
ט2.דזשוין();
““

קעסימפּולאַן

C++ איז אַ שטאַרקע און פלעקסיבלע פּראָגראַמיר שפּראַך, אָבער זי איז אויך אונטערטעניק צו געוויינטלעכע טעותים, ספּעציעל אין באַצוג צו זכּרון און פּוינטער פאַרוואַלטונג. דורך פֿאַרשטיין די טעותים און וויסן ווי זיי צו פאַרריכטן, קענט איר אַנטוויקלען מער פאַרלאָזלעכע און עפֿעקטיווע אַפּליקאַציעס. געדענקט צו שטענדיק באַצאָלן ופֿמערקזאַמקייט צו קאָמפּיילער מעסעדזשעס, נוצן מאָדערנע מכשירים וואָס העלפֿן אײַך שרײַבן זיכערן קאָד , און קעסיידער פֿאַרבעסערן אײַערע סקילז אין פֿאַרשטיין און אַפּליצירן C++ פּראָגראַמיר בעסטע פּראַקטיקעס.