Vad är skillnaden mellan en dinglande pekare och en nullpekare i C? Tekniskt sett verkar båda samma.


Svar 1:

Det finns ingen skillnad så länge du inte utnyttjar någon av dessa pekare. Därför innebär dinglande att minnet som pekaren pekar på tillåts återanvändas för något annat, men programmet antar att det gamla innehållet fortfarande finns där och försöker komma åt det. Detta leder vanligtvis till felaktigt beteende någon gång vid programmets körning.

Utöver det känner jag att själva frågan tydligt indikerar att du inte "förstår pekare". Om du föreställer dig minnet som en rad med numrerade rutor, där varje ruta kan ha innehåll (ett värde, vanligtvis 0 ... 255), är pekaren helt enkelt ett heltal (jag förenklar arkitektoniska detaljer här) med numret (inte värde) för en av dessa rutor.


Svar 2:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 3:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 4:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 5:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 6:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 7:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 8:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 9:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.


Svar 10:

Jag ser massor av "engelska" här, vilket kan vara användbart för någon som redan känner till konceptet men för någon som inte gör det här kommer bara att vara gibberiska texter. Men den roliga kvoten i svaren och metaforerna tickar, ursäkt om det förolämpar någon.

Nullpekare: En pekare som innehåller adressen till ingenting eller säger NULL-plats. Att skriva på den här platsen är ett fel. Detta är utformat för att förhindra programmerare att av misstag skriva på en minnesplats som kan orsaka ett segmenteringsfel och / eller krasch. Tanken var att alltid initiera en pekare med NULL och kontrollera om NULL före skrivning. Tänk på detta scenario:

int * p; // just nu innehåller denna pekare en slumpmässig adress, kan peka på vilken plats som helst, även utanför segmentet

* p = 10; // detta kommer säkert att ge fel.

säkert sätt skulle vara något så här:

int * p = NULL;

if (p! = NULL)

* p = 10;

Hängande pekare: Som namnet antyder släpps på något sätt en pekare som är ointresserad för var den ska peka eftersom minnesblocket som det ursprungligen pekade på.

Det finns många sätt att göra en pekare dinglande. Det vanligaste sättet är att nya, kopiera och radera

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

p = nytt x;

q = p;

radera q; // både q och minnesblockpekaren med q tas bort från minnet

// härifrån har vi en pekare p som har en adress som inte finns i minnet. Om vi ​​försöker tilldela något värde till den här pekaren är vi i problem, p här dinglar pekaren

* p = 10; //krascha

andra sätt på vilka du antagligen kan skapa en dinglande pekare av misstag skulle göra en grund kopia av objekt antingen genom tilldelning eller genom att överföra ett objekt till en metod och därmed använda kompilator som tillhandahålls kopieringskonstruktör som återigen gör en grund kopia för dig.