Wat is het verschil tussen een bungelende wijzer en een lege wijzer in C? Technisch gezien lijken beide hetzelfde.


Antwoord 1:

Er is geen verschil zolang je geen van deze aanwijzingen afwijst. Bungelen impliceert daarom dat het geheugen waarnaar de aanwijzer verwijst, voor iets anders mag worden hergebruikt, maar het programma gaat ervan uit dat de oude inhoud er nog is en probeert toegang te krijgen. Dit leidt meestal op een gegeven moment tot onjuist gedrag tijdens de uitvoering van het programma.

Bovendien denk ik dat de vraag zelf sterk aangeeft dat je geen "aanwijzingen" begrijpt. Als je je geheugen voorstelt als een regel met genummerde vakken, waarbij elk vak inhoud kan hebben (een waarde, meestal 0 ... 255), dan is de aanwijzer gewoon een geheel getal (ik vereenvoudig architectonische details hier) met het nummer (niet de waarde) van een van die vakken.


Antwoord 2:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 3:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 4:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 5:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 6:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 7:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 8:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 9:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.


Antwoord 10:

Ik zie hier veel "Engels", wat nuttig kan zijn voor iemand die het concept al kent, maar voor iemand die dit niet is, zijn dit alleen maar wartaalachtige teksten. Maar het leuke quotiënt in de antwoorden en metaforen tikt, excuses als het iemand beledigt.

Null-aanwijzer: een aanwijzer die het adres bevat voor niets of NULL-locatie zegt. Schrijven op deze locatie is een fout. Dit is ontworpen om te voorkomen dat programmeurs per ongeluk op een geheugenlocatie schrijven, wat een segmentatiefout en / of crash kan veroorzaken. Het idee was om altijd een aanwijzer met NULL te initialiseren en op NULL te controleren voordat hij schreef. Overweeg dit scenario:

int * p; // op dit moment bevat deze aanwijzer een willekeurig adres en kan deze naar elke locatie verwijzen, zelfs buiten het segment

* p = 10; // dit geeft zeker fouten.

veilige manier zou zoiets zijn als dit:

int * p = NULL;

if (p! = NULL)

* p = 10;

Bungelende wijzer: Zoals de naam al doet vermoeden, is er op de een of andere manier een wijzer vrijgegeven die geen idee heeft waarheen te wijzen, aangezien het geheugenblok waarnaar het oorspronkelijk wees.

Er zijn veel manieren mogelijk om een ​​aanwijzer te bengelen. De meest gebruikelijke manier zou zijn om nieuw, kopiëren en verwijderen

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

p = nieuwe x;

q = p;

verwijder q; // zowel q als de geheugenblokwijzer door q worden uit het geheugen verwijderd

// vanaf hier hebben we een pointer p met een adres dat niet in het geheugen bestaat. Als we proberen een waarde toe te kennen aan deze aanwijzer, zitten we in de problemen, hier is een bengelende aanwijzer

* p = 10; //Botsing

andere manieren waarop u waarschijnlijk per ongeluk een bungelende wijzer kunt maken, zijn een ondiepe kopie van een object maken door toewijzing of door een object door te geven aan een methode waarbij de door de compiler geleverde kopieermaker wordt gebruikt die weer een ondiepe kopie voor u doet.