Mis vahe on C-ga rippuva ja nullkursori vahel? Tehniliselt tunduvad mõlemad ühesugused.


Vastus 1:

Pole vahet, kui te ei jäta ükski neist osutitest tähelepanuta. Seetõttu tähendab riputamine, et mälu, millele osuti osutab, lubatakse millekski muuks kasutada, kuid programm eeldab, et vana sisu on alles, ja proovib sellele juurde pääseda. Tavaliselt põhjustab see programmi täitmise mingil hetkel valet käitumist.

Lisaks sellele tunnen, et küsimus ise osutab kindlalt sellele, et te ei mõista vihjeid. Kui kujutate mälu ette nummerdatud kastide reana, kus igas kastis võib olla sisu (väärtus tavaliselt 0 ... 255), siis on osuti lihtsalt täisarv (siin lihtsustan arhitektuuri spetsiifikat), millel on number (mitte väärtus).


Vastus 2:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 3:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 4:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 5:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 6:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 7:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 8:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 9:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.


Vastus 10:

Ma näen siin palju "inglise keelt", mis võib olla kasulik neile, kes seda kontseptsiooni juba teavad, kuid neile, kes seda ei tee, on midagi muud kui hiiglaslikud tekstid. Kuid vastuste ja metafooride lõbus jaotus tiksub, palun vabandust, kui see kedagi solvab.

Nullkursor: osuti, mis sisaldab aadressi, kus pole midagi öelda, või öelda NULL asukohta. Sellesse kohta kirjutades on viga. Selle eesmärk on vältida programmeerijate tahtmatut kirjutamist mälupessa, mis võib põhjustada segmenteerimisvigu ja / või krahhi. Idee oli alati kursori initsialiseerimine NULL-iga ja enne kirjutamist NULL-i kontroll. Mõelge sellele stsenaariumile:

int * p; // praegu sisaldab see osuti juhuslikku aadressi, võib osutada mis tahes kohta, isegi segmendist väljas

* p = 10; // see kindlasti annab süü.

ohutu viis oleks midagi sellist:

int * p = NULL;

if (p! = NULL)

* p = 10;

Dangling osuti: Nagu nimigi osutab, on mingil viisil vabastatud osuti, mille kohta pole aimugi, kuhu osutada, kuna mäluplokk, millele see algselt osutas.

Osuti riputamiseks saab teha mitmel viisil. Kõige tavalisem viis oleks uus, kopeerida ja kustutada

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

p = uus x;

q = p;

kustuta q; // mälust eemaldatakse nii q kui ka mäluploki kursor q-ga

// siit on meil kursor p, mille aadressi pole mälus. Kui proovime sellele osutile mingit väärtust omistada, oleme hätta sattunud, siin on rippuv osuti

* p = 10; // krahh

muud viisid, kuidas saate kogemata rippuva osuti luua, oleks objekti madalad koopiad teha kas määramise teel või suunates objekti meetodile, kasutades selleks kompilaatori pakutavat koopiakonstruktorit, mis jällegi teeb teie jaoks madalat koopiat.