Sa C, ang Null ay isang simbolikong pare-pareho na palaging tumuturo sa isang wala na punto sa memorya. Bagaman maraming mga programmer ang tinatrato ito bilang katumbas ng 0, ito ay isang pagpapasimple na maaaring mapunta ka sa paglaon. Mahusay na suriin ang iyong mga pointer laban sa NULL nang direkta, at gamitin ang 0 sa iba pang mga konteksto. Pinapanatili nito ang iyong code na malinis at madaling maunawaan, dahil malalaman mong nakikipagtulungan ka sa mga payo sa tuwing nakikita mo ang Null.
Mga hakbang
Bahagi 1 ng 2: Pagsasagawa ng isang Null Check
Hakbang 1. Gamitin ang karaniwang null check code
Ang sumusunod ay ang pinaka halatang paraan upang magsulat ng isang null check. Gagamitin namin ptr sa artikulong ito bilang pangalan ng pointer na iyong tinitingnan.
-
kung (ptr == NULL)
{
// code kung ang pointer ay NUL
} iba pa {
// code kung hindi NUL
}
Hakbang 2. Subukan para sa anumang halaga ngunit NUL
Minsan mas maginhawa upang subukin ang hindi pagkakapantay-pantay sa halip. Walang sorpresa dito:
-
kung (ptr! = NULL) {
// code kung hindi NUL
}
Hakbang 3. Isulat muna ang NULL upang maiwasan ang mga error (opsyonal)
Ang pangunahing kawalan sa pamamaraang PTR == NULL ay ang pagkakataon na hindi mo sinasadyang mai-type ang ptr = NULL sa halip, itatalaga ang halaga ng NULL sa pointer na iyon. Maaari itong maging sanhi ng isang pangunahing sakit ng ulo. Dahil ang pagsubok para sa (sa) pagkakapantay-pantay ay tinatrato ang mga pagpapatakbo nang simetriko, maaari kang makakuha ng eksaktong parehong resulta sa pamamagitan ng pagsulat kung (NULL == ptr) sa halip Ito ay mas typo-lumalaban, dahil ang isang hindi sinasadyang NULL = ptr ay lumilikha ng isang simpleng error sa pag-ipon.
Mukha itong medyo mahirap sa ilang mga programmer, ngunit perpektong may bisa ito. Aling diskarte na ginagamit mo ay nakasalalay lamang sa personal na kagustuhan, at kung gaano kahusay ang iyong tagatala sa pagtuklas ng error na (ptr = NULL)
Hakbang 4. Subukin kung ang variable ay totoo
Isang simple kung (ptr) sinusubukan kung Totoo ang ptr. Ibabalik nito ang MALI kung ang ptr ay NULL, o kung ang ptr ay 0. Ang pagkakaiba ay hindi mahalaga sa maraming mga kaso, ngunit magkaroon ng kamalayan na ang mga ito ay hindi magkapareho sa lahat ng mga arkitektura.
Ang baligtad nito ay kung (! ptr), na magbabalik TUNAY kung Ptr ay MALI.
Bahagi 2 ng 2: Pag-iwas sa Mga Pagkakamali
Hakbang 1. Magtakda ng isang pointer bago suriin para sa NULL
Ang isang karaniwang pagkakamali ay ipalagay na ang isang bagong nilikha na pointer ay may halaga na NUL. Hindi ito totoo. Ang isang hindi nakatalagang pointer ay tumuturo pa rin sa isang address ng memorya, hindi lamang isa na iyong tinukoy. Karaniwang kasanayan na itakda ang bagong nilikha o bagong napalaya na mga payo sa NULL upang matiyak na hindi mo gagamitin ang hindi kapaki-pakinabang na address nang hindi sinasadya.
-
Iwasan ang pagkakamaling ito:
char * ptr;
kung (ptr == NULL)
{
// Ibabalik nito ang MALI. Ang pointer ay nakatalaga ng isang wastong halaga.
}
-
Sa halip ay isulat:
char * ptr = NULL; // Itinatalaga nito ang pointer sa NULL
kung (ptr == NULL)
{
// Ibabalik nito ang TUNAY kung ang pointer ay hindi naitalaga muli.
}
Hakbang 2. Magbayad ng pansin sa mga pagpapaandar na maaaring bumalik sa Null
Kung ang isang pagpapaandar ay maaaring ibalik ang Null, isipin kung ito ay isang posibilidad, at kung magdulot ito ng mga problema sa paglaon ng iyong code. Narito ang isang halimbawa ng pagpapaandar ng malloc gamit ang null check (kung (ptr)) upang matiyak na humahawak lamang ito ng mga pahiwatig na may wastong halaga:
-
int * ptr = malloc (N * sizeof (int));
kung (ptr) {
int i;
para sa (i = 0; i <N; ++ i)
ptr = i;
}
Hakbang 3. Maunawaan na ang NULL ay 0 ngunit dapat mong palaging gamitin ang Null sa halip na 0 kapag nagtatrabaho sa mga payo para sa kalinawan
Kasaysayan, kinatawan ng C ang Null bilang bilang 0 (iyon ay, 0x00). Sa panahong ito maaari itong makakuha ng medyo mas kumplikado, at nag-iiba sa pamamagitan ng operating system. Karaniwan mong masusuri ang paggamit ng Null ptr == 0, ngunit may mga kaso sa sulok kung saan maaaring maging sanhi ito ng isang isyu. Marahil na mas mahalaga, ang paggamit ng Null ay ginagawang malinaw na nagtatrabaho ka sa mga payo para sa ibang tao na nagbabasa ng iyong code.
