Arbeta med minne i C. Välja minne i C (funktion malloc) Dynamisk minnesallokering

Beskrivning

Returnerar pekaren till den första byte av minnesområdet, som markerades från en hög

Malloc () -funktionen returnerar en pekare till den första byte av minnesområdet av storlek, som markerades från en hög. Om det inte finns något tillräckligt med minne för att uppfylla frågan, returneras nollpekaren. Det är viktigt att alltid se till att returvärdet inte är en nollpekare. Ett försök att använda en nollpekare leder vanligtvis till ett fullständigt systemfel.

Om du skriver 16-bitars program för 8086-processorfamiljen (till exempel 80486 eller Pentium), ger din kompilator förmodligen ytterligare minnesallokeringsfunktioner som tar hänsyn till den segmenterade minnesmodellen som används av dessa processorer när de arbetar i 16-bitars läge. Till exempel kan det vara funktioner som fördelar FAR-STAPP-minnet (som ligger utanför standarddatasegmentet). Dessa funktioner kan tilldela pekare till minnet, vars volym är mer än ett segment och släpper ett sådant minne.

tomrumfri (void * pekare);

brukade frigöra minne som pekargumentet indikerar. För det första tilldelas minnet för applikationen, efter att ha slutfört arbetet med minnet, måste det returneras, den här avkastningen och den fria funktionen är inkopplad.

_Msize

Den _msize-funktionen returnerar storleken på minnesområdet isolerat från en hög:

size_t _msize (void *);

argumentet är en pekare till minnesblocket. Den _msize-funktionen returnerar minnesstorleken i byte. Storlek_t är unsigned heltal.

malloc.

Malloc-funktionen lyfter fram minnesområdet från "heap" (dvs fri minnesområde):

void * malloc (size_t);

argumentet bestämmer antalet byte som måste tilldelas från minnet. Malloc-funktionen returnerar en tomt pekare till ett valt minne, det kan ges till önskad typ. Om det är gratis att markera minnet är mindre än size_t, kommer malloc-funktionen att returnera noll.

Ett exempel på att arbeta med MALLOC-funktionen:

/ * Författare: @author subbotin b.p..h\u003e #include #Omfatta. Int Main (tomrum); int * pekare; sätter ("för att få minne"); pekare \u003d (int *) malloc (2 * size (int)); intminnesize \u003d _msize (pekare); printf ("Minnesstorlek \u003d% DN ", minnesstämpel); om (pekare \u003d\u003d null) (sätter (" problem "); returnera exit_failure;) fri (pekare); sätter (" till fritt minne "); returnera exit_success;)

här är en plats i minnet för en matris som består av två delar av typ int. Om minnesfördelningen gick framgångsrikt, släpper vi det här minnesområdet med den fria funktionen.

Vi får:

calloc.

Calloc-funktionen lyfter fram minnesområdet och placerar en array i den initialiserad av nollor:

void * calloc (size_t, size_t);

det första argumentet är antalet element, och den andra är storleken i byte av ett element. Produkten av argumentvärden och kommer att ge värdet på minnesområdet som begärs att markera. Calloc-funktionen returnerar tomrummet till det valda området i minnet, det kan sättas till önskad typ. Om det är mindre fritt att markera minnet än Sailorborn, kommer Calloc-funktionen att returnera null.

Provarbete med Calloc-funktion:

/ * Författare: @author subbotin b.p..h\u003e #include #Omfatta. Int Main (tomrum); int * pekare; sätter ("för att få minne"); pekare \u003d (int *) calloc (2, sizeof (int)); intminnesize \u003d _msize (pekare); printf ("Minnesstorlek \u003d% DN ", minnesstämpel); om (pekare \u003d\u003d null) (sätter (" problem "); returnera exit_failure;) fri (pekare); sätter (" till fritt minne "); returnera exit_success;)

i exemplet fördelas minnet för en INT-array innehållande två element. Dessa element initieras med nollor. Om minnesfördelningen gick framgångsrikt, släpper vi det här minnesområdet med den fria funktionen.

Vi får:

realloc

RealLOC-funktionen ändrar storleken på det förutvalda minnesområdet:

void * realloc (void *, size_t);

det första argumentet är en pekare på minnesområdet, vars storlek måste ändras, det andra argumentet bestämmer den nya storleken på minnesområdet. Om den här storleken är noll, och det första argumentet indikerar det befintliga minnesområdet, kommer RealLOC-funktionen att returnera null och källblocket som det första argumentet indikerar kommer att släppas. Om det är mindre fritt att markera minnet än Sailorbero, kommer RealLoc-funktionen att återvända , och källblocket av minne till vilket det första argumentet specificeras sparas och kommer att förbli oförändrat. RealLOC-funktionen returnerar tomtpekaren till det valda området i minnet, det kan sättas till önskad typ.

Dynamisk minnesallokering med hjälp av MALLOC-biblioteksfunktionen består av följande steg.

1. Slå på Malloc .h Header File-programmet. #Include-direktivet .

2. Meddelande om indikatorn på önskad typ, till exempel int * p;

3. Ringa MALLOC-funktionen med en indikation som parametern för den önskade mängden minne i byte. Eftersom funktionen ger resultatet av sitt arbete i form av en pekare till tomrummet, utförs typ (typ av resultat konverteras till den typ som anges i annonsen). Tilldelar det värde som erhållits till den deklarerade pekaren. Exempel:

p \u003d (int *) malloc (antal arrayelement * sizeof (int));

Istället int kan ersättas med vilken som helst som är angiven för programmerare.

4. Kontrollera faktum av minnesallokering. Om minnesallokeringen i önskad volym inte är möjlig, returnerar MALLOC-funktionen en noll nollpekare som resultat, som motsvarar lögnervärdet. Om valet av minne exekveras, fortsätt utförandet av programmet om inte, vi lämnar det med lämplig diagnos av brist på minne. Exempel:

om (! p) meddelande, utgång; Annars fortsatte;

5. Släpp av minne efter slutet av arbetet med det. För att göra detta, ring funktionen f Gee och använd en pekare som ett argument:

fri (p);

Värdet på pekaren som erhållits efter steg 3 måste sparas till steg 5. Annars kommer hela minnet som är allokerat vid denna adress att gå förlorat när du lämnar programmet, vilket i slutändan kan leda till brist på minne och störning av operativsystemet ..

Den vanligaste orsaken till datorns "hängande" när du arbetar med dynamiskt allokerat minne är inkonsekvensen av malloc och fria instruktioner (i båda instruktionerna en och även pekaren ska användas) eller otillräcklig mängd ledigt minne.

Som ett exempel, överväga ingången / utgången av en endimensionell dynamisk uppsättning av en godtycklig längd som definieras från tangentbordet.

int jag, n, * massiv; // indexannons

cout.<\u003e n; // Ange storleken på arrayen

massiv \u003d (int *) malloc (n * sizo (int)); // dynamo.

om (! Massiv) // Kontrollera faktum av minnesallokering

{cout.<

cout.<

getch ();

returnera 0;)

cout.<

för (i \u003d 0; jag \u003e Massiv [I]; // Ange arrayen

cout.<

för (i \u003d 0; jag

gratis (massiv); // Release of Memory

I det här programmet används pekaren endast för att markera dynamiskt minne. Därefter, i programmet, utförs cirkulationen av matriselementen genom namnet på matrisen, vilket sammanfaller med pekarens namn.

För att dynamiskt allokera minnet kan du också använda funktionen Calloc (). Till skillnad från MOLLOC, initierar Calloc-funktionen, förutom fördelningen av minnesområdet under en mängd objekt, elementen i matrisen med nollvärden.

Beroende på C +++ som används för att fungera med stora dynamiska minnesfragment är Farmalloc (), Farcalloc (), Farcoreleft () och Farfree () -funktionerna.

Ditt program ska ge ett tillräckligt minne för att memorera de använda data. Några av dessa minnesceller distribueras automatiskt. Till exempel kan vi förklara

char Place \u003d "Bay of Pork Lever";

och minnet kommer att fördelas tillräckligt för att memorera den här raden.

Eller vi kan vara mer specifika och begära en viss mängd minne:

int-plattor;

Denna beskrivning allokerar 100 minnesceller, som var och en är avsedd att memorera hela värdet.

C-språket slutar inte på det. Det låter dig distribuera ytterligare minne medan programmet körs. Antag, till exempel skriver du ett dialogprogram och vet inte i förväg hur mycket data du måste ange. Du kan välja önskat dig (som du tror) mängden minne och sedan, om det behövs, behöver det ännu. I fig. 15.5 Avvisa det exempel på vilket funktionen används malloc ()Att göra exakt det. Var noga med att uppmärksamma hur ett sådant program tillämpar pekare.

/ * Lägger till minne om det behövs * /

#Omfatta.

#Define stop "" / * ingångsavslutningssignal * /

#Define block 100 / * minnesbyte * /

#Defini lim 40 / * gränslängd inmatad linje * /

#Defina max 50 / * Maximalt antal inmatningsrader * /

#Define drama 20000 / * stor tidsfördröjning * /

char butik; / * Källminnesblock * /

char symf; / * Mottagare Inmatningsrader * /

char * slutet; / * Indikerar slutet av minnet * /

char * startar; / * Indikerar strängens start * /

int-index \u003d 0; / * Antal angivna linjer * /

int count; / * Disken * /

char * malloc (); / * Memory Distributor * /

startar \u003d butik;

slut \u003d startar + block - 1;

sätter ("Namn några symfoniorkester.");

sätter ("Ange en efter en: Tryck på [ENTER] -knappen i början");

sätter ("rader för att slutföra din lista. Ok, jag är redo.");

medan (fyls (symf, lim, stdin), stopp)! \u003d 0 && index< MAX)

(Om (strlen (symf)\u003e slutar - startar)

(/ * Åtgärder med brist på minne för att memorera ingångsdata * /

sätter ("vänta en sekund. Jag ska försöka hitta extra minne.");

slut \u003d startar + block - 1;

för (räkning \u003d 0; räkna< DRAMA; count++);

sätter ("hittade lite!"); )

strcpy (startar, symf);

startar \u003d startar + strlen (symf) + 1;

om (++ Index< MAX)

Printf ("Denna% d. Fortsätt, om du vill.", Index); )

sätter ("Jo, det är vad jag fick:");

för (räkning \u003d 0; räkna< index; count ++)

Sätter (startar);

Fikon. 15,5. Ett program som lägger till minne på begäran.

Här är ett urval av programmet:

Namn flera symfoniorkestrar av orkestrarna.

Ange dem en efter en; Tryck på [ENTER] -knappen i början.

rader för att slutföra vår lista. OK jag är redo.

San Francisa Symphonic.

Detta 1. Fortsätt om du vill.

Chicago symfoni

Detta 2. Fortsätt om du vill.

Berlin Philharmonic

Detta är 3. Fortsätt om du vill.

Moskva kammare

Detta är 4. Fortsätt om du vill. London symfoni

Detta är 5. Fortsätt om du vill. Wien Philharmonic

Vänta en sekund. Jag ska försöka hitta extra minne.

Hittade lite!

Detta är 6. Fortsätt om du vill.

Pittsburgh Symphony

Detta är 7. Fortsätt om du vill.

Tja, det är vad jag fick:

San Francisky Syphonic

Chicago symfoni

Berlin Philharmonic

Moskva kammare

London symfoni

Wien Philharmonic

Pittsburgh Symphony

Först låt oss se vad funktionen gör malloc (). Det tar ett argument i form av ett helt tecken som representerar mängden minne byte som krävs. Så, malloc (block) kräver 100 byte. Funktionen returnerar en pekare till typen röding. Till början av ett nytt minnesblock. Vi använde beskrivning

char * malloc ();

att varna kompilatorn som malloc () Returnerar en pekare till typen röding.. Därför tilldelade vi värdet av den här pekaren till matriselementet startar. Med operatören

startar \u003d malloc (block);

Tja, låt oss nu överväga utkastet till program, vilket är att komma ihåg alla de ursprungliga raderna i rad i en stor matris lagra.. Vi vill använda startar. För hänvisning till början av första raden, börjar [l] - Andra raden etc. Vid mellanstadiet introducerar programmet en sträng i en array symf.. Vi använde fgets () istället får ()För att begränsa ingångssträngen i matrislängden symf..

Fikon. 15,6. Symf seriella strängar inspelade i butiksgruppen.

Innan du kopierar symf. på lagra.Vi måste kontrollera om den återstående platsen har tillräckligt för henne. Pekare slutet. hänvisar till slutet av minnet och det aktuella värdet startar. hänvisar till början av oanvänd minne. Således kan vi jämföra skillnaden mellan dessa två pekare med en längd symf. Och bestämma om minnet är tillräckligt.

Om det inte finns tillräckligt med utrymme, ringer vi malloc ()Att förbereda extra minne. Vi sätter startar. till början av ett nytt minnesblock, a slutet. - i slutet av det nya blocket. Observera att vi inte har något namn på det här nya minnet. Det är inte till exempel expansion lagra.. Vi har bara indikationer på pekare som hänvisar till ett nytt minnesområde.

När programmet fungerar, hänvisas ett element i uppsättningen av pekare till varje ny sträng. startar.. Vissa linjer är i lagra.Övrigt - i ett eller flera nya minnesområden.

Men medan vi har pekare kan vi arbeta med rader, eftersom vi visar en del av det program som utför utskrift.

Således används mallos (). Men antar att du vill arbeta med typminne int., men inte röding.. Du kan använda här mallos (). Så här är det gjort:

char * malloc (); / * Beskriv fortfarande som en pekare att char * /

int * Newmem;

newmem \u003d (int *) malloc (L00); / * Använd typ av typ * /

100 byte krävs igen. Användning av typ Förtydligande omvandlar värdet som returneras av pekaren till typen röding., i pekaren till typen int.. Om, som i vårt system, int. tar två byte av minne, det betyder det newmem + 1. Det kommer att öka pekaren till två byte, d.v.s. flytta den till nästa helhet. Det betyder också att 100 byte kan användas för att memorera 50 heltal.

En annan möjlighet till minnesallokering ger oss användningen av funktionen sallos ():

char * calloc ();

lång * Newmem;

newMem \u003d (lång *) calloc (100, sizeof (lång));

Tycka om malloc () fungera sallos () Returnerar pekaren till röding.. Du måste använda typen av aktuatortyp om du vill komma ihåg en annan typ. Den här nya funktionen har två argument, och båda måste vara heltal utan ett tecken. Det första argumentet innehåller antalet minneceller som krävs. Det andra argumentet är storleken på varje cell i byte. I vårat fall lång.