C ++ Endre arraystørrelse

Når en rekke. Derfor kan vi unngå dette problemet ved dynamisk å generere en ny matrise, kopiere over innholdet og deretter slette den gamle matrisen. Denne artikkelen fokuserer på hvordan du tildeler minne dynamisk i en matrise og justerer matrisestørrelse basert på brukerinngang. Det er en svært viktig strategi for programmering siden den sikrer effektiv minneutnyttelse. Når vi prøver å sette inn et nytt element i en dynamisk matrise, øker det automatisk til det ikke er mer lagring for det nye elementet. Vanligvis dobler regionen i størrelse.

Hva er et dynamisk utvalg?

En dynamisk matrise er identisk med en standard matrise i utseende, men størrelsen kan endres mens koden kjører. Dynamiske array -komponenter tar opp en sammenhengende minneblokk. Etter at en matrise er definert, er det ikke mulig å endre størrelsen. I kontrast er en dynamisk matrise ikke som en statisk matrise. Selv etter at det er okkupert, kan en dynamisk matrise utvide størrelsen. Elementer kan legges kontinuerlig til den dynamiske matriserens sluttposisjon ved å bruke det reserverte rommet til det er helt okkupert.

Nøkkelfaktorer for dynamisk matrise i C ++:

Ytelsen til matrisen bestemmes av startstørrelse og vekstfaktor. Legg merke til følgende punkter:

• Hvis en matrise er beskjeden i størrelse og har en langsommere vekstfaktor, vil den fortsette å omfordele hukommelsen oftere. Som et resultat vil matrisens ytelse lide.
• Hvis en matrise er større og har en høy vekstfaktor, vil den ha en stor mengde ubrukt minne. Som et resultat kan det ta lengre tid. Arrayens ytelse vil også lide som et resultat

Eksempel 1:

Det nye nøkkelordet brukes til å bygge et dynamisk utvalg i følgende C ++ -program. Etter det returnerer nøkkelordet en referanse til det første elementet. Header -delen har den inkluderte iostream -bibliotekfilen for å bruke metodene. Navnetfilen er også inkludert som gjør det mulig å bruke klassen uten å bli kalt. Deretter påberopes hovedfunksjonen der vi har erklært to variabler “P” og “Num” av heltalldatatype.

I neste trinn skriver cout -setningen ut uttalelsen "Angi tallene". CIN -kommandoen tar innspill fra brukeren og tildeler den til variabelen “Num”. Neste trinn har pekervariabelen “Array” som holder heltallverdiene til variabelen “Num”. Brukerens innlisede nummer vil bli skrevet ut ved hjelp av COUT -kommandoen. Da har vi for sløyfetilstand som itererer over hvert element som er lagt inn av brukeren. Arrayen som "matrise" er erklært i CIN -kommandoen som leser inndata som er lagt inn av brukeren.

Etter avslutningen av sløyfen vil uttalelsen “Dine tall” skrives ut på konsollskjermen. Igjen, vi har en for sløyfetilstand Men denne gangen dette for sløyfetilstand itererer over en rekke elementer. Merk at vi har tillatt en bruker å angi arraystørrelse. Som et resultat er matrisens størrelse definert ved kjøretid.

#inkludere
ved hjelp av navneområdet STD;
int main ()
int p, num;
cout<< "Enter the numbers:" num;
int *array = new int (num);
cout<< "Enter " << num << " numbers" <for (p = 0; p> array [p];

cout<< "Your numbers are: ";
for (p = 0; p < num; p++)
cout<< Array[p] << " ";

cout<< "\n ";
retur 0;

Brukeren blir bedt om å legge inn nummeret i konsollprompt. Etter inngang viser nummeret for array -størrelse antall spesifiserte matrisestørrelser. Den resulterende matrisen vises på konsollpromptet til Ubuntu.

Eksempel 2:

En initialiseringsliste kan brukes til å angi en dynamisk matrise. La oss illustrere dette med et eksempel for å se hvordan dette fungerer. Først la vi til IOSTREAM -filen og STD -navnefilen i overskriftsdelen. Etter det påkalte vi hovedfunksjonen. Logikken til programmet skal inkluderes i funksjonens kropp. Da har vi definert en variabel som "A" av heltalldatatype.

Etter å ha erklært heltallvariabelen, har vi en dynamisk array -erklæring som "ARR" som bruker en initializer -liste. Vi har fire heltalloppføringer i matrisen. COUT -kommandoen vil skrive ut uttalelsen “Elements of Array” før du viser matriseelementene.

I neste trinn har vi det A for sløyfe som itererer over elementer som er til stede i en spesifisert matrise. Gjennom cout -kommandoen vil elementene i den gitte matrisen bli skrevet ut på konsollprompt.

#inkludere
ved hjelp av navneområdet STD;
int main (void)
int a;
int *arr new int [4] 9, 23, 1, 17;
cout<< "Elements of Array: " <for (a = 0; a < 4; a++)
cout<
retur 0;

Følgende er resultatet vi fikk fra utførelsen av programmet ovenfor:

Eksempel 3:

Når målet med den dynamiske matrisen er oppnådd, bør den fjernes fra datamaskinminnet. Slettuttrykket kan brukes til å gjøre dette at minneområdet er gratis og brukes til å lagre tilleggsdata. Vi må bruke Delete [] for å fjerne den dynamiske matrisen fra minnet om systemet. Den firkantede braketten [] med nøkkelordet sletter kommandoer CPU for å fjerne mange variabler i stedet for bare en.

La oss begynne implementeringen av programmet. Vi har importert den nødvendige filen i overskriftsdelen. Deretter kalles hovedfunksjonen. Heltallvariablene “jeg” og “nei” er erklært i hovedfunksjonen. Etter å ha definert disse variablene, har vi COUT -setningen "inngangsnummer" som er for brukeren å oppgi nummeret. Vi får et nummer fra brukeren og lagrer det i variabelen “Nei” ved hjelp av CIN -kommandoen.

Deretter erklærer en pekervariabel “Myarr” som lagrer heltallene i minnet. Nummeret som er lagt inn av brukeren vil bli skrevet ut i den andre cout -kommandoen til dette programmet. De for sløyfe Uttalelse brukes for iterasjonen over den angitte brukeren. Til slutt har vi konstruert Delete [] -erklæringen som sletter matrisen gitt i programmet og frigjør plass i minnet.

#inkludere
ved hjelp av navneområdet STD;
int main ()
int jeg, nei;
cout<< "Input Number:" no;
int *myarr = ny int (nei);
cout<< "Input " << no << " numbers" <for (i = 0; i> myarr [i];

cout<< "Input numbers are: ";
for (i = 0; i< no; i++)
cout<
cout<slett [] myarr;
retur 0;

Ved utførelse av programmet fikk vi følgende utdata. Når programmet avsluttes, blir matrisen slettet.

Eksempel 4:

Vi kan definere en pekerutvalg av størrelse “x” dynamisk og deretter tildele minne om størrelse “y” dynamisk for hver rad ass sett i følgende eksempel. Til å begynne med har vi definert matrisen i overskriftsdelen. I neste trinn har vi hovedfunksjonen der vi har en pekervariabel “ARR”. Pekervariabelen inneholder en rekke størrelse “x”.

Nå, den for sløyfeuttalelse tildeler hver rad en minnestørrelse “y”. Deretter har vi en nestet sløyfe for dynamisk å tildele verdier til et minne som er tilsatt. RAND -funksjonen vil generere et tilfeldig tall for 2D -matrisen. I den neste nestede sløyfen har vi skrevet ut 2D -matrisen gjennom STD :: cout -uttalelsen. Etter programmets avslutning vil den spesifiserte 2D -arrayen bli slettet fra det tildelte minneområdet, da vi har brukt slett [] til slutt.

#inkludere
#Define x 3
#Define y 4
int main ()

int ** arr = new int*[x];
for (int i = 0; i< X; i++)
arr [i] = new int [y];

for (int i = 0; i< X; i++)

for (int j = 0; j < Y; j++)
arr [i] [j] = rand () % 10;


for (int i = 0; i< X; i++)

for (int j = 0; j < Y; j++)
std :: cout<
std :: cout<< std::endl;

for (int i = 0; i< X; i++)
slett [] arr [i];

slett [] arr;
retur 0;

2D -matrisen er generert og vist på konsollskjermen nedenfor.

Konklusjon

Det handler om den endrede matrisen i C++. Vi ble kjent med at C ++ matriser ikke har en innebygd metode for å endre størrelse på størrelse. Men gjennom den dynamiske array -tildelingen i C ++ kan matrisstørrelsen modifiseres. Vi har illustrert i eksemplet for å endre størrelsen på den dynamiske matrisen ved hjelp av et nytt nøkkelord. Vi kan også bruke en initializer -liste for å initialisere en matrise. Etter å ha endret størrelse kan vi også frigjøre plass i minnet ved å bruke sletting []. Denne artikkelen vil vise deg hvordan du kan endre størrelse på en matrise i C++.