რა განსხვავებაა ცრემლსადენი მაჩვენებელსა და ნულოვან მაჩვენებელს შორის C? ტექნიკურად რომ ვთქვათ, ორივე ერთნაირად გამოიყურება.


პასუხი 1:

სხვაობა არ არის, თუ არ ჩავთვლით რომელიმე ამ მითითებას. შლნკერი ამრიგად ნიშნავს, რომ წერტილის მიერ მითითებული მეხსიერება შეიძლება გამოყენებულ იქნას სხვა რამისთვის. ამასთან, პროგრამა ვარაუდობს, რომ ძველი შინაარსი ჯერ კიდევ არსებობს და მის წვდომას ცდილობს. ეს ჩვეულებრივ იწვევს პროგრამის შესრულების დროს არასწორ ქცევას.

გარდა ამისა, მე მიმაჩნია, რომ კითხვა თავისთავად მიგვითითებს იმაზე, რომ თქვენ ვერ "გესმით მაჩვენებლები". თუ თქვენ ფიქრობთ მეხსიერებაზე, როგორც დანომრილი ველების სერია, რომელშიც თითოეულ ველს შეიძლება ჰქონდეს შინაარსი (მნიშვნელობა, ჩვეულებრივ 0 ... 255), მაჩვენებელი უბრალოდ მთელი რიცხვია (მე აქ ვამარტივებ არქიტექტურულ მახასიათებლებს), რომ ნომერი შეიცავს ამ ყუთებიდან ერთს (არა მნიშვნელობას).


პასუხი 2:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 3:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 4:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 5:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 6:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 7:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 8:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 9:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.


პასუხი 10:

მე ვხედავ უამრავ "ინგლისურს", რაც შეიძლება სასარგებლო იყოს ვინმესთვის, ვინც უკვე იცის კონცეფცია, მაგრამ ვინმესთვის, ვინც არ იცის, ეს სხვა არაფერი იქნება, თუ არა გიბრალური სიმღერები. თუმცა, მხიარული მეწარმე პასუხებს და მეტაფორებს უყურებს. უკაცრავად, თუ ეს ვინმეს შეურაცხყოფს.

Null მაჩვენებელი: ისარი, რომელიც შეიცავს მისამართს არაფერზე ან ამბობს NULL. ამ ეტაპზე წერა შეცდომაა. ეს არის პროგრამისტების თავიდან ასაცილებლად, რომ შემთხვევითი ადგილი არ მიაწოდონ ადგილს, რამაც შეიძლება გამოიწვიოს სეგმენტაციის შეცდომების და / ან ავარიის მიზეზი. მაჩვენებელი ყოველთვის უნდა იყოს ინიცირებული NULL- ით და წერის დაწყებამდე მოწმდება NULL- ზე. განვიხილოთ ეს სცენარი:

int * p; // ამ მომენტში ეს მაჩვენებელი შეიცავს შემთხვევით მისამართს და შეუძლია მოიხსნას ნებისმიერი პოზიცია, თუნდაც სეგმენტის გარეთ

* გვ = 10; // ეს ნამდვილად დაუშვებს შეცდომას.

რაღაც უსაფრთხო იქნებოდა:

int * p = NULL;

თუ (p! = NULL)

* გვ = 10;

Dangling მაჩვენებელი: როგორც სახელი გვთავაზობს, არის მაჩვენებელი, რომელსაც წარმოდგენა არ აქვს სად უნდა აღინიშნოს, რადგან მეხსიერების ბლოკი, რომელსაც იგი თავდაპირველად მიუთითებდა, რატომღაც გამოვიდა.

არსებობს მრავალი გზა, თუ როგორ შეიძლება ჩამოკიდოთ მაჩვენებელი. ყველაზე გავრცელებული გზა იქნება ახლის შექმნა, კოპირება და წაშლა

int * p = NULL; int * q = NULL;

p = ახალი x;

q = p;

q წაშლა; // q და q მეხსიერების ბლოკის მაჩვენებელი ამოღებულია მეხსიერებადან

// აქედან ჩვენ გვაქვს მაჩვენებელი p, მისამართი, რომელიც მეხსიერებაში არ არსებობს. თუ ჩვენ ვცდილობთ მივცეთ ამ მაჩვენებლის მნიშვნელობას, ჩვენ პრობლემები შეგვიძლია, p- ის მაჩვენებელი ჩამოკიდებულია აქ

* გვ = 10; // კრახი

კიდევ ერთი გზა, რის გამოც თქვენ შეიძლება შემთხვევით შექმნათ საყრდენის მაჩვენებელი, არის ობიექტის ბრტყელი ასლის გაკეთება, ან მისი მინიჭებით, ან ობიექტის მეთოდით გადაცემის გზით, შემდგენლის მიერ მოწოდებული ასლის კონსტრუქტორის გამოყენებით, რაც, თავის მხრივ, ბინაა. ასლის გაკეთება თქვენთვის.