Når du kjører et program under Valgrind, instrumenterer det dynamisk programmets kjørbare, slik at det kan overvåke programmets minnebruk og kjøringsatferd.
Minnelekkasjer i C++
Det er viktig å merke seg at Valgrind først og fremst er designet for C- og C++-programmer og kanskje ikke fungerer like effektivt med andre språk eller i alle scenarier. I tillegg kan det å kjøre et program under Valgrind redusere kjøringen betydelig, så det brukes ofte under utvikling og feilsøking i stedet for i produksjonsmiljøer.
Når et dynamisk opprettet minne ikke er riktig utgitt, kan det forårsake minnelekkasjer i C/C++ som sakte vil tømme de tilgjengelige minneressursene. Dette kan resultere i for høyt minneforbruk og redusert ytelse til programmet.
Valgrid installasjon
For å installere Valgrind på et Linux-system, åpne en terminal og oppdater pakkedepotene dine ved å bruke pakkebehandlingen som er spesifikk for din Linux-distribusjon. Følgende kommando fungerer for Ubuntu og Debian-baserte systemer:
$ sudo passende oppdatering
Bruk pakkebehandlingen til å installere Valgrind. Igjen, kommandoen kan variere avhengig av Linux-distribusjonen din. Bruk følgende kommando for Ubuntu og Debian-baserte systemer:
$ sudo apt installere valgporten
Når du blir bedt om det, skriv inn brukerpassordet ditt og trykk 'Enter'. Merk at brukerkontoen din trenger administratorrettigheter for å installere programvaren. Pakkebehandlingen laster ned og installerer Valgrind sammen med eventuelle nødvendige avhengigheter. Prosessen kan ta noen minutter.
Etter at installasjonsprosessen er fullført, kan du bekrefte vellykket installasjon av Valgrind ved å utføre følgende kommando som et verifiseringstrinn:
$ valgporten --versjonDenne kommandoen viser versjonsinformasjonen til Valgrind hvis den er vellykket installert.
Det er det! Valgrind skal nå være installert på Linux-systemet ditt, og du kan bruke det til å analysere og feilsøke C/C++-programmene dine for minnelekkasjer og andre problemer.
Opprette en fil i Ubuntu
For å begynne å jobbe med programmet, må vi først lage en fil i Ubuntu. For filoppretting bruker vi nanotekstredigereren. Så vi skriver kommandoen på terminalen som følger:
$ nano fil 1Her er nano navnet på tekstredigeringsprogrammet som kjøres. Argumentet 'fil1' representerer navnet på filen du har tenkt å åpne eller opprette ved hjelp av nanotekstredigering. Nano åpner filen for redigering hvis den allerede eksisterer; hvis ikke, genererer den en ny fil med det oppgitte navnet. Siden vi ikke har en slik fil, oppretter den et nytt dokument med navnet 'fil1'.
Når du kjører kommandoen, åpnes nano-editoren, og gir deg et tomt lerret for å legge inn eller redigere innholdet i 'file1'-filen. Du kan begynne å skrive eller lime inn det eksisterende innholdet i redigeringsprogrammet.
Nå som alle forutsetninger er oppnådd, lager vi noen eksempler for å bruke Valgrind til å oppdage minnelekkasjene i C++-programmer.
Eksempel 1:
Det første eksemplet vi gir viser et enkelt eksempel på dynamisk minneallokering ved å bruke 'malloc'-funksjonen fra
int hoved- ( )
{
røye * en = malloc ( 102 ) ;
komme tilbake 0 ;
}
Her er en oversikt over koden:
Vi inkluderer først standard bibliotekhodefilen
Linjen int main() erklærer hovedfunksjonen. Deretter er char *a = malloc(102); erklærer en pekervariabel 'a' av typen char* (peker til char). Den bruker 'malloc'-funksjonen for å dynamisk tildele minnet for en rekke 102 tegnelementer (102 byte totalt). Minnetildelingsstørrelsen, uttrykt i byte, sendes som en inngang til malloc-funksjonen, og den sender ut en peker til den nyopprettede minneblokken. Tegn*-pekeren 'a' er tildelt denne pekerverdien. Til slutt, 'retur 0;' betyr slutten på hovedfunksjonen.
Kort sagt, denne koden tildeler minnet dynamisk for en rekke av 102 tegnelementer ved å bruke 'malloc' og tildeler minneadressen til pekeren 'a'. Vær imidlertid oppmerksom på at koden ikke bruker eller manipulerer det tildelte minnet på noen måte og inkluderer ikke deallokering av minnet ved bruk av gratis.
Når vi kjører dette programmet gjennom Valgrind med alternativet '–leak-check=full', utfører det en minnelekkasjesjekk og gir en utdatarapport.
Utgangsrapporten som er produsert av Valgrid er gitt som følger:
Eksempel 2:
For å begynne med denne illustrasjonen oppretter vi først en 'test2' fil ved å bruke nanotekstredigereren som forklart tidligere ved å skrive kommandoen:
$ nano test 2Nå skriver vi et C++-program for å sjekke om det er noen minnelekkasje ved å bruke Valgrind:
#include#include
#inkluder
const int a_s = 3000 ;
int main ( ) {
int * ia = malloc ( størrelsen av ( int ) * som ) ;
til ( int i = 0 ; Jeg < som; i++ ) {
den [ Jeg ] = i;
}
srand ( tid ( NULL ) ) ;
int rn = rand ( ) % som;
printf ( 'det[%d]: %d \n ' , rn, det [ rn ] ) ;
komme tilbake 0 ;
}
La oss gå gjennom programmet.
Koden inkluderer de nødvendige header-filene og definerer konstantvariabelen 'a_s' med en verdi på 3000. Inne i main()-funksjonen deklareres en peker 'ia' av typen int* og minnet tildeles dynamisk ved hjelp av 'malloc' funksjon. 'sizeof(int) * a_s'-uttrykket bestemmer det totale nødvendige minnet for å lagre 'a_s'-tallet med heltall. Alle elementene i 'ia'-matrisen initialiseres av 'for'-løkken med dens tilsvarende indeksverdi. For eksempel vil ia[0] være 0, ia[1] vil være 1, og så videre.
Tilfeldig tallgeneratoren sees ved hjelp av 'srand'-funksjonen ved å bruke gjeldende tid. Dette sørger for at programmet produserer et unikt sett med tilfeldige heltall hver gang det kjøres. Funksjonen 'rand' genererer et tilfeldig tall, og 'rn' tildeles resultatet av rand() % a_s. Modulusoperatoren '%' begrenser området til det tilfeldige tallet til å være mellom 0 og a_s – 1 som tilsvarer en gyldig indeks innenfor 'ia'-matrisen.
Til slutt bruker programmet 'printf'-funksjonen til å skrive ut verdien ved den tilfeldig valgte indeksen 'rn' til 'ia'-matrisen, sammen med den tilsvarende indeksen.
Når du kjører dette programmet gjennom Valgrind, genererer det følgende utdatarapport:
Konklusjon
Vi oppdaget bruken av Valgrind-verktøyet for å oppdage minnelekkasjene i et C++-program. Installasjonsveiledningen til Valgrind leveres innledningsvis. Etter det utdypet vi opprettelsen av en fil i Ubuntu ved å bruke nanotekstredigereren. Til slutt, ved å bruke disse forutsetningene, utførte vi to C++-eksempler for å sjekke minnelekkasjene i dem. Rapporten som er generert av Valgrind er også vedlagt som viser minnelekkasjene i den medfølgende filen.