C– ში NULL არის სიმბოლური მუდმივი, რომელიც ყოველთვის მიუთითებს მეხსიერებაში არარსებულ წერტილზე. მიუხედავად იმისა, რომ ბევრი პროგრამისტი მას უტოლდება 0 -ს, ეს არის გამარტივება, რომელსაც შეუძლია შემდგომში გაგიწიოთ. უმჯობესია შეამოწმოთ თქვენი მითითებები პირდაპირ NULL– ის წინააღმდეგ და გამოიყენოთ 0 სხვა კონტექსტში. ეს ინახავს თქვენს კოდს სუფთა და ადვილად გასაგები, რადგან თქვენ იცით, რომ თქვენ მუშაობთ პოინტერებთან ყოველ ჯერზე, როდესაც ხედავთ NULL.
ნაბიჯები
მე -2 ნაწილი 1: ბათილად შემოწმება
ნაბიჯი 1. გამოიყენეთ სტანდარტული null გამშვები კოდი
შემდეგი არის ყველაზე აშკარა გზა ნულოვანი ჩეკის დასაწერად. ჩვენ გამოვიყენებთ პტრ ამ სტატიაში, როგორც მაჩვენებლის სახელი, რომელსაც თქვენ ამოწმებთ.
-
თუ (ptr == NULL)
{
// კოდი თუ მაჩვენებელი არის NULL
} სხვა {
// კოდი თუ არა NULL
}
ნაბიჯი 2. გამოცადეთ ნებისმიერი მნიშვნელობა, მაგრამ NULL
ზოგჯერ უფრო მოსახერხებელია უთანასწორობის შემოწმება. აქ გასაკვირი არ არის:
-
თუ (ptr! = NULL) {
// კოდი თუ არა NULL
}
ნაბიჯი 3. ჩაწერეთ პირველი NULL შეცდომების თავიდან ასაცილებლად (სურვილისამებრ)
PTR == NULL მეთოდის მთავარი მინუსი არის შანსი, რომ თქვენ შემთხვევით ჩაწეროთ ptr = NULL, მიანიჭოთ NULL მნიშვნელობა ამ მაჩვენებელს. ამან შეიძლება გამოიწვიოს ძლიერი თავის ტკივილი. ვინაიდან (არა) თანასწორობის ტესტირება ოპერანდებს სიმეტრიულად ეპყრობა, თქვენ შეგიძლიათ მიიღოთ ზუსტად იგივე შედეგი წერილობით თუ (NULL == ptr) სამაგიეროდ. ეს უფრო ტიპ-რეზისტენტულია, ვინაიდან შემთხვევითი NULL = ptr ქმნის მარტივი შედგენის შეცდომას.
ზოგიერთი პროგრამისტებისთვის ეს ცოტა უხერხულად გამოიყურება, მაგრამ ის სრულყოფილად მოქმედებს. რომელი მიდგომა გამოიყენებთ მხოლოდ პირად უპირატესობაზეა დამოკიდებული და რამდენად კარგია თქვენი შემდგენელი if (ptr = NULL) შეცდომის გამოვლენაში
ნაბიჯი 4. შეამოწმეთ არის თუ არა ცვლადი ჭეშმარიტი
Მარტივი თუ (ptr) ამოწმებს არის თუ არა ptr მართებული. ის დააბრუნებს მცდარს, თუ ptr არის NULL, ან თუ ptr არის 0. განსხვავება არ აქვს მნიშვნელობა ხშირ შემთხვევაში, მაგრამ იცოდეთ, რომ ეს არ არის იდენტური ყველა არქიტექტურაში.
ამის საპირისპიროა თუ (! ptr), რომელიც დააბრუნებს TRUE თუ ptr არის FALSE.
მე -2 ნაწილი 2: შეცდომების თავიდან აცილება
ნაბიჯი 1. დააყენეთ მაჩვენებელი NULL– ის შემოწმებამდე
ერთი გავრცელებული შეცდომაა ვივარაუდოთ, რომ ახლად შექმნილ მაჩვენებელს აქვს NULL მნიშვნელობა. Ეს არ არის სიმართლე. დაუნიშნავი მაჩვენებელი მაინც მიუთითებს მეხსიერების მისამართზე, არა მხოლოდ თქვენზე მითითებულზე. ჩვეულებრივი პრაქტიკაა ახლადშექმნილი ან ახლადმოხსნილი მითითებების დაყენება NULL- ზე, რათა დარწმუნდეთ, რომ შემთხვევით არ გამოიყენებთ ამ არასასურველ მისამართს.
-
მოერიდეთ ამ შეცდომას:
char *ptr;
თუ (ptr == NULL)
{
// ეს დააბრუნებს FALSE- ს. მაჩვენებელს მიენიჭა სწორი მნიშვნელობა.
}
-
სამაგიეროდ დაწერე:
char *ptr = NULL; // ეს მიანიჭებს მაჩვენებელს NULL- ს
თუ (ptr == NULL)
{
// ეს დააბრუნებს TRUE- ს, თუ მაჩვენებელი არ არის გადანაწილებული.
}
ნაბიჯი 2. ყურადღება მიაქციეთ ფუნქციებს, რომლებსაც შეუძლიათ NULL დაბრუნება
თუ ფუნქციას შეუძლია დააბრუნოს NULL, დაფიქრდით არის თუ არა ეს შესაძლებლობა და გამოიწვევს თუ არა ეს პრობლემებს მოგვიანებით თქვენს კოდში. აქ მოცემულია malloc ფუნქციის მაგალითი null შემოწმების გამოყენებით (თუ (ptr)) იმისათვის, რომ უზრუნველყოს მხოლოდ დამუშავებული მაჩვენებლების მოქმედი მნიშვნელობები:
-
int * ptr = malloc (N * sizeof (int));
თუ (ptr) {
int i;
for (i = 0; i <N; ++ i)
ptr = i;
}
ნაბიჯი 3. გესმით, რომ NULL არის 0 მაგრამ თქვენ ყოველთვის უნდა გამოიყენოთ NULL 0 -ის ნაცვლად, როდესაც მკაფიო მითითებებთან მუშაობისას
ისტორიულად, C წარმოადგენდა NULL- ს, როგორც რიცხვს 0 (ანუ 0x00). დღესდღეობით ის შეიძლება ოდნავ გართულდეს და განსხვავდება ოპერაციული სისტემის მიხედვით. ჩვეულებრივ შეგიძლიათ შეამოწმოთ NULL გამოყენებით ptr == 0, მაგრამ არის კუთხის შემთხვევები, როდესაც ამან შეიძლება პრობლემა გამოიწვიოს. ალბათ, რაც მთავარია, NULL- ის გამოყენებით აშკარა ხდება, რომ თქვენ მუშაობთ მითითებებთან სხვა ადამიანებისთვის, რომლებიც კითხულობენ თქვენს კოდს.
