Home Blog Page 22794

Det Grunnleggende av C-Programmering

0

Ved hjelp av Pekere for Funksjon Parametere

De fleste C-programmerere første bruk pekere til å gjennomføre noe som kalles variable parametrene i funksjonene. Du har faktisk vært med variable parametre i scanf funksjon-som er grunnen til at du har hatt til å bruke & (adressen operatør) på variabler som brukes med scanf. Nå som du forstår tips du kan se hva du har virkelig stått på.

For å forstå hvordan variable parametere fungerer, kan du se hvordan vi kan gå frem for å implementere en swap – funksjonen i C. for Å gjennomføre en swap-funksjon, hva du ønsker å gjøre er å passere i to variable og har funksjonen bytte sine verdier. Her er et forsøk på en gjennomføring — gå inn og kjøre følgende kode, og se hva som skjer:

Opp Neste

  • Hvordan fungerer JavaScript fungerer og hvordan kan jeg bygge enkle kalkulatorer med det?
  • Hvordan C-Programmering Fungerer
  • Hvordan Fungerer HTML5
  • Hva er fordelene av å lære C programmering?
  • Er data mining og data warehousing i slekt?

#include <stdio.h>

void bytt(int i, int j)
{
int t;

t=i;
i=j;
j=t;
}

void main()
{
int a,b;

a=5;
b=10;
printf(“%d %dn”, a, b);
bytt(a,b);
printf(“%d %dn”, a, b);
}

Når du kjører dette programmet, vil du finne at ingen bytte foregår. Verdiene for a og b er gått til swap og swap-funksjon gjør bytt dem, men når funksjonen returnerer ingenting skjer.

For å gjøre denne funksjonen fungerer på riktig måte, kan du bruke markørene, som vist nedenfor:

#include <stdio.h>

void bytt(int *jeg, int *j)
{
int t;
t = *jeg;
*i = i *j;
*j = t;
}

void main()
{
int a,b;
a=5;
b=10;
printf(“%d %dn”,a,b);
swap(&a&b);
printf(“%d %dn”,a,b);
}

For å få en idé om hva denne koden gjør, skrive det ut, trekke to heltall a og b, og skriv inn 5 og 10 i dem. Nå trekker de to pekere jeg og j, sammen med heltall t. Når swap er kalt, det er gått adresser av a og b. Dermed, jeg peker til en (tegner en pil fra jeg til a) og j poeng til b (tegne en pil fra b til j). Når denne funksjonen er initialisert av funksjonen samtale *jeg er et annet navn for en, og *j er et annet navn for b. Nå kjører koden i bytte. Når koden bruker *jeg og *j, det betyr egentlig a og b. Når funksjonen er ferdig, a og b har vært byttet om.

Tenk deg at du tilfeldigvis glemmer & når swap – funksjonen er kalt, og at bytte linje ved et uhell ser ut som dette: bytt(a, b);. Dette fører til en segmentering feil. Når du la ut det og, verdien av en er gått i stedet for sin adresse. Derfor, jeg peker til en ugyldig sted i minnet, og systemet krasjer når *jeg er brukt.

Dette er også grunnen til at scanf krasjer hvis du glemmer & på variabler gått til det. Den scanf funksjon er å bruke funksjonen for å sette verdien leser tilbake i variabelen du har gått. Uten &, scanf er gått en dårlig adresse og krasjer.

Variable parametere er en av de mest utbredte bruken av pekere i C. Nå kan du forstå hva som skjer!

Det Grunnleggende av C-Programmering

0

Tips: Vanlige Feil

Feil #1 – ikke initialisert tips

En av de enkleste måtene å lage en peker feil er å prøve å referere til verdien av en peker selv om pekeren er ikke initialisert og ennå ikke peke til en gyldig adresse. For eksempel:

Opp Neste

  • Hvordan fungerer JavaScript fungerer og hvordan kan jeg bygge enkle kalkulatorer med det?
  • Hvordan C-Programmering Fungerer
  • Hvordan Fungerer HTML5
  • Hva er fordelene av å lære C programmering?
  • Er data mining og data warehousing i slekt?

int *p;

*p = 12;

Pekeren p er ikke initialisert og peker på et tilfeldig sted i minnet når du erklærer det. Det kan være som peker inn i systemet stabelen, eller den globale variabler, eller i programmets kode plass, eller inn i operativsystemet. Når du sier *p=12;programmet vil bare prøve å skrive en 12 til hva tilfeldig sted p peker til. Programmet kan eksplodere med en gang, eller kan vente en halv time, og så å eksplodere, eller det kan subtilt ødelegge data som er i en annen del av ditt program, og du kan aldri innse det. Dette kan gjøre denne feilen svært vanskelig å spore opp. Sørg for at du initialisere alle pekere til en gyldig adresse før dereferencing dem.

Feil #2 – Ugyldig Peker Referanser

En ugyldig peker referanse oppstår når en peker verdi er det refereres til, selv om pekeren ikke peker mot en gyldig blokk.

En måte å skape denne feilen er å si p=q;når q er ikke initialisert. Pekeren p vil så bli ikke initialisert som godt, og det henvises til *p er en ugyldig peker som referanse.

Den eneste måten å unngå dette problemet er å tegne bilder av hvert trinn av programmet og sørge for at alle pekere punkt noe sted. Ugyldig peker referanser føre til at et program krasjer uforklarlig for de samme grunnene som er gitt i Feil #1.

Feil #3 – Null Pekeren Referanse

En null-peker referanse oppstår når en peker som peker til null er brukt i en uttalelse som forsøker å referere til en blokk. For eksempel, hvis s er en peker til et heltall, den følgende koden er ugyldig:

p = 0;
*p = 12;

Det er ingen blokk pekt på av s. Derfor, prøver å lese eller skrive noe som helst fra eller til at blokken er en ugyldig null pekeren referanse. Det er gode, gyldige grunner til å peke en peker til null, så vil vi se på i senere artikler. Dereferencing slik en peker, imidlertid, er ugyldig.

Alle disse feilene er dødelig for et program som inneholder dem. Du må se på koden slik at disse feilene ikke forekommer. Den beste måten å gjøre det på er å tegne bilder av koden er gjennomføringen trinn for trinn.

Det Grunnleggende av C-Programmering

0

Tips: Peker til den Samme Adressen

Her er en kul aspekt av C: en rekke pekere kan peke til samme adresse. Du kan For eksempel erklærer p, q, og r som heltall pekere og sett alle av dem til å peke til jeg, som vist her:

int i;
int *p *q *r;

s = &jeg;
q = &jeg;
r = p;

Merk at i denne koden, r peker til det samme som p peker til, som jeg. Du kan tilordne pekere til hverandre, og adressen er kopiert fra høyre til venstre side under oppdraget. Etter å ha kjørt koden ovenfor, dette er hvordan ting vil se ut:

Opp Neste

  • Hvordan fungerer JavaScript fungerer og hvordan kan jeg bygge enkle kalkulatorer med det?
  • Hvordan C-Programmering Fungerer
  • Hvordan Fungerer HTML5
  • Hva er fordelene av å lære C programmering?
  • Er data mining og data warehousing i slekt?

Variabelen jeg nå har fire navn: jeg, *p *q *r. Det er ingen begrensning på antall tips som kan holde (og derfor peker til) den samme adressen.

Det Grunnleggende av C-Programmering

0

Tips: Forstå Minneadresser

Variabelen f forbruker fire byte av RAM i minnet. At stedet har en bestemt adresse, i dette tilfellet 248,440.

© 2011 HowStuffWorks.com

Den tidligere diskusjonen blir litt klarere hvis du forstår hvordan minneadresser arbeid i en datamaskin er hardware. Hvis dere ikke har lest den allerede, nå ville være en god tid til å lese Hvordan Bits og Bytes Arbeid for å fullt ut forstå bits, bytes og ord.

Alle datamaskiner som har minnet, også kjent som RAM (random access memory). For eksempel du har, kan maskinen ha 16 eller 32 eller 64 mb RAM installert akkurat nå. RAM har programmer som datamaskinen kjører sammen med dataene de er for tiden manipulering (deres variabler og data strukturer). Minnet kan betraktes bare som en array av bytes. I denne matrisen, ethvert sted i minnet har sin egen adresse-adressen til første byte er 0, etterfulgt av 1, 2, 3, og så videre. Minne-adresser handle akkurat som indekser i en vanlig tabell. Datamaskinen kan få tilgang til hvilken som helst adresse i minnet til enhver tid (derav navnet “random access memory”). Det kan også gruppere byte sammen som det er behov for å danne større variabler, matriser, og strukturer. For eksempel, en ” floating point variabel bruker 4 sammenhengende byte i minnet. Du kan gjøre følgende globale erklæring i et program:

Opp Neste

  • Hvordan fungerer JavaScript fungerer og hvordan kan jeg bygge enkle kalkulatorer med det?
  • Hvordan C-Programmering Fungerer
  • Hvordan Fungerer HTML5
  • Hva er fordelene av å lære C programmering?
  • Er data mining og data warehousing i slekt?

float f;

Denne uttalelsen sier, “Erklærer et sted som heter f som kan holde en” floating point verdi.” Når programmet kjører, datamaskinen forbeholder seg retten plass for variabelen f et sted i minnet. At stedet har en fast adresse i minnet, som dette:

Mens du tror på variabelen f, datamaskinen tenker på en bestemt adresse i minnet (for eksempel 248,440). Derfor, når du oppretter en uttalelse som dette:

f = 3.14;

Kompilatoren kan oversette det til, “Legg verdien 3.14 inn i minnet beliggenhet 248,440.” Datamaskinen er alltid tenker på minne i form av adresser og verdier på disse adressene.

Det er forresten flere interessante bivirkninger til hvordan datamaskinen behandler minne. For eksempel, si at du inkluderer følgende kode i ett av programmene:

int i, s[4], t[4], u=0;

for (i=0; i<=4; i++)
{
s = i;
t =i;
}
printf(“s:tn”);
for (i=0; i<=4; i++)
printf(“%d:%dn”, s, t);
printf(“u = %dn”, u);

Den utgang som du ser av programmet vil sannsynligvis se ut som dette:

s:t
1:5
2:2
3:3
4:4
5:5
u = 5

Hvorfor er t[0] og u uriktige? Hvis du ser nøye på koden, kan du se at for-løkker er å skrive ett element forbi slutten av hver tabell. I minne, matriser er plassert ved siden av hverandre, som vist her:

Matriser plassert ved siden av hverandre

Derfor, når du prøver å skrive til s[4], som ikke eksisterer systemet skriver inn t[0] i stedet fordi t[0] er der s[4] burde være. Når du skriver inn t[4], du er virkelig skrive inn u. Så langt som datamaskinen er bekymret, s[4] er rett og slett en adresse i, og det kan skrive inn i det. Som du kan se men selv om datamaskinen kjører programmet, er det ikke riktig eller gyldig. Programmet ødelegger matrisen t i prosessen med å kjøre. Hvis du utføre følgende uttalelse, mer alvorlige konsekvenser resultat:

s[1000000] = 5;

Plasseringen s[1000000] er mer enn sannsynlig utenfor programmets plass i minnet. Med andre ord, du skriver i minnet at programmet ikke eier. På et system med beskyttet minne mellomrom (UNIX, Windows 98/NT), denne typen utsagn vil føre til at systemet til å stanse gjennomføring av programmet. På andre operativsystemer (Windows 3.1, Mac), men systemet er ikke klar over hva du gjør. Du ende opp med å skade kode eller variabler i et annet program. Effekten av brudd kan variere fra ingenting til et komplett system krasj. I minnet, i, s, t og u er alle plassert ved siden av hverandre på bestemte adresser. Derfor, hvis du skriver forbi grensene for en variabel, datamaskinen vil gjøre det du sier, men det vil ende opp med å ødelegge et annet sted i minnet.

Fordi C og C++ ikke utføre noen form for utvalget å sjekke når du åpner et element i en matrise, er det viktig at du, som en programmerer, vær nøye med å array spenner deg selv og holde seg innenfor matrisen er passende grenser. Utilsiktet lesing eller skriving utenfor matrisen grenser alltid fører til feil program atferd.

Som et annet eksempel, kan du prøve følgende:

#include <stdio.h>

int main()
{
int i,j;
int *p; /* en peker til et heltall */
printf(“%d %dn”, s, &i);
s = &jeg;
printf(“%d %dn”, s, &i);
return 0;
}

Denne koden forteller kompilatoren til å skrive ut adresse holdt i s, sammen med adressen til jeg. Variabelen p starter med noen sprø verdi eller med 0. Adressen til jeg er vanligvis en stor verdi. For eksempel, når jeg kjørte denne koden, fikk jeg følgende output:

0 2147478276
2147478276 2147478276

noe som betyr at den adressen jeg er 2147478276. Når utsagnet p = &jeg; er blitt utført, s inneholder adressen til jeg. Prøve dette også:

#include <stdio.h>

void main()
{
int *p; /* en peker til et heltall */

printf(“%dn”,*p);
}

Denne koden forteller kompilatoren for å skrive ut den verdien som p peker til. Imidlertid, s har ikke blitt initialisert ennå; det inneholder adresse 0 eller noen random-adresse. I de fleste tilfeller, en segmentering feil (eller noen andre run-time error) resultater, noe som betyr at du har brukt en peker som peker til et ugyldig område av minnet. Nesten alltid, et ikke initialisert pekeren eller en dårlig pekeren adresse er årsaken til segmentering feil.

Etter å ha sagt alt dette, kan vi nå se på pekere i et helt nytt lys. Ta dette programmet, for eksempel:

#include <stdio.h>

int main()
{
int i;
int *p; /* en peker til et heltall */
s = &jeg;
*p=5;
printf(“%d %dn”, i, *p);
return 0;
}

Her er hva som skjer:

Variabelen jeg bruker 4 byte med minne. Pekeren p forbruker også 4 byte (på de fleste maskiner som er i bruk i dag, en peker bruker 4 byte med minne. Minne-adressene er 32-bits lang tid på de fleste Cpuer i dag, selv om det er en økende trend mot 64-bit adressering). Plasseringen av jeg har en bestemt adresse, i dette tilfellet 248,440. Pekeren p mener at adressen når du sier s = &i;. Variablene *p og jeg er derfor tilsvarende.

Pekeren p bokstavelig talt holder den adressen jeg. Når du sier noe sånt som dette i et program:

printf(“%d”, s);

det som kommer ut er den faktiske adressen til variabelen jeg.

Det Grunnleggende av C-Programmering

0

Pekeren Grunnleggende

I denne tegningen de tre variablene i, j og s har blitt erklært, men ingen av de tre som har blitt initialisert.

For å forstå pekere, det hjelper å sammenligne dem med normal variabler.

En “standard variabel” er et sted i minnet, som kan inneholde en verdi. For eksempel, når du deklarerer en variabel jeg som et heltall, fire byte med minne er satt til side for det. I programmet ditt, vil du se at plassering i minnet ved hjelp av navnet jeg. Ved machine nivå at stedet har en minneadresse. De fire byte på at adressen er kjent for deg, programmerer, som jeg, og de fire byte kan inneholde ett heltall.

Opp Neste

  • Hvordan fungerer JavaScript fungerer og hvordan kan jeg bygge enkle kalkulatorer med det?
  • Hvordan C-Programmering Fungerer
  • Hvordan Fungerer HTML5
  • Hva er fordelene av å lære C programmering?
  • Er data mining og data warehousing i slekt?

En peker er forskjellige. En peker er en variabel som peker til en annen variabel. Dette betyr at en peker holder minnet adressen til en annen variabel. Sagt på en annen måte, peker ikke holder en verdi i tradisjonell forstand; i stedet, det har adressen til en annen variabel. En pointer “poeng” at andre variable ved å holde en kopi av sin adresse.

Fordi en pekeren har en adresse i stedet for en verdi, det har to deler. Pekeren selv eier adressen. At adressen peker til en verdi. Det er pekeren og verdien pekte til. Dette faktum kan være litt forvirrende til du blir komfortabel med det, men når du kommer komfortable det blir ekstremt kraftig.

Det følgende eksempelet kode som viser en typisk pekeren:

#include <stdio.h>

int main()
{
int i,j;
int *p; /* en peker til et heltall */
s = &jeg;
*p=5;
j=i;
printf(“%d %d %dn”, i, j, *p);
return 0;
}

Den første erklæringen i dette programmet erklærer to normal heltall variabler heter jeg og j. Linjen int *p erklærer en markør som heter s. Denne linjen spør kompilatoren å deklarere en variabel p som er en peker til et heltall. Den * indikerer at en pekeren blir erklært heller enn en vanlig variabel. Du kan lage en peker til noe: en dupp, en struktur, en røye, og så videre. Bare bruke en * for å angi at du ønsker en peker snarere enn en normal variabel.

Linjen p = &jeg; vil definitivt være nye for deg. I C, og kalles adresse operatør. Uttrykket &jeg betyr, “minnet adressen til variabelen jeg.” Dermed uttrykk p = &jeg; betyr, “Tilordne til p – adressen til jeg.” Når du utfører denne uttalelsen, s “poeng” jeg. Før du gjør det, s inneholder en tilfeldig, ukjent adresse, og bruken vil sannsynligvis føre til en segmentering feil eller lignende program krasjer.

En god måte å visualisere hva som skjer er å tegne et bilde. Etter at jeg, j og s er erklært, verden ser ut som på bildet ovenfor.

I denne tegningen de tre variablene jeg, j og s har blitt erklært, men ingen av de tre som har blitt initialisert. De to heltall variablene er derfor trukket som bokser som inneholder spørsmålstegn — de kan inneholde en hvilken som helst verdi på dette punktet i programmets gjennomføring. Pekeren er trukket som en sirkel for å skille den fra en vanlig variabel som har en verdi, og den tilfeldige pilene indikerer at det kan være peke hvor som helst på dette tidspunktet.

Etter linjen p = &I;, p er initialisert, og det peker til jeg, som dette:

En gang p poeng til jeg, minneplasseringen jeg har to navn. Det er fortsatt kjent som jeg, men nå er det kjent som *p så vel. Dette er hvordan C snakker om de to delene av en peker-variabel: p er plasseringen holde adresse, mens *p er plasseringen peker til den aktuelle adressen. Derfor *p=5 betyr at stedet peker til s skal være satt til 5, som denne:

Fordi plasseringen *p er også jeg, jeg tar også på verdien 5. Følgelig, j=i; sett j 5, og den printf uttalelse produserer 5 5 5.

Den viktigste funksjonen av en peker er de to-en del av naturen. Pekeren i seg selv har en adresse. Pekeren peker også til en verdi av en bestemt type – verdien på adressen punktet har. Pekeren seg selv, i dette tilfellet, er p. Verdien pekt på er *s.

Det Grunnleggende av C-Programmering

0

Tips: Hvorfor?

Tenk deg at du ønsker å opprette et tekstredigeringsprogram – et program som lar deg redigere vanlig ASCII-tekst-filer, som “vi” på UNIX eller “Notisblokk” på Windows. En tekst editor er en ganske vanlig ting for noen å lage, fordi, hvis du tenker på det, en tekst editor, er trolig en programmerer mest brukte stykke programvare. Tekst-editor er en programmerer intime kobling til datamaskin-det er der du skriver inn alle dine tanker, og deretter manipulere dem. Selvfølgelig, med noe du bruker ofte, og jobbe med det som er nært, du vil den skal være helt rett. Derfor er mange programmerere lage sine egne redaktører og tilpasse dem til å passe sine egne arbeidsmetoder og egne preferanser.

Så en dag du setter deg ned for å begynne å arbeide på din editor. Etter å ha tenkt på de funksjonene du ønsker, du begynner å tenke på “data-struktur” for din editor. Det vil si at du begynner å tenke på hvor du vil lagre dokumentet du redigerer i minnet, slik at du kan manipulere det i programmet. Hva du trenger er en måte å lagre informasjonen du har skrevet inn i et skjema som kan manipuleres raskt og enkelt. Du tror at den eneste måten å gjøre det på er å organisere data på grunnlag av linjer med tegn. Gitt det vi har diskutert så langt, det eneste du har til disposisjon på dette punktet er en matrise. Du tenker, “Vel, en typisk linje er 80 tegn, og en typisk filen er ikke mer enn 1000 linjer lang.” Derfor kan du deklarere en to-dimensjonal array, som dette:

Opp Neste

  • Hvordan fungerer JavaScript fungerer og hvordan kan jeg bygge enkle kalkulatorer med det?
  • Hvordan C-Programmering Fungerer
  • Hvordan Fungerer HTML5
  • Hva er fordelene av å lære C programmering?
  • Er data mining og data warehousing i slekt?

røye dok[1000][80];

Denne erklæringen forespørsler et utvalg på 1 000 80-tegn linjer. Denne tabellen har en total størrelse på 80 000 tegn.

Når du tenker på din editor ” og datastruktur noen flere, men du kan realisere tre ting:

  • Noen dokumenter er lange lister. Hver linje er kort, men det er tusenvis av linjer.
  • Noen spesielle formål tekstfiler som har svært lange linjer. For eksempel, en bestemt datafil, kan ha linjer som inneholder 542 tegn, med hvert tegn som representerer aminosyre par i segmenter av DNA.
  • I de fleste moderne redaktører, kan du åpne flere filer på en gang.

La oss si at du angir et maksimalt 10 åpne filer på en gang, en maksimal ledningslengde på 1000 tegn og en maksimal filstørrelse på 50 000 linjer. Din erklæring nå ser ut som dette:

røye doc[50000][1000][10];

At ikke virke som en urimelig ting, før du drar ut kalkulatoren, må du multiplisere 50,000 av 1000 med 10 og realisere tabellen inneholder 500 millioner tegn! De fleste datamaskiner i dag kommer til å ha et problem med en matrise som størrelse. De rett og slett ikke har RAM, eller selv den virtuelle minne ved å støtte en matrise som store. Hvis brukerne var å prøve å kjøre tre-eller fire kopier av dette programmet samtidig på selv de største multi-user system, det ville sette en alvorlig belastning på anlegg.

Selv om datamaskinen skulle akseptere en forespørsel for et så stort utvalg, du kan se at det er en ekstravagant sløsing med plass. Det virker rart å erklære en 500 millioner karakter array da, i de aller fleste tilfeller, vil du kjøre denne editoren til å se på 100 linje filer som bruker på de fleste på 4 000 eller 5 000 byte. Problemet med en matrise er det faktum at du har til å erklære det for å få maksimal størrelse i hver dimensjon fra begynnelsen. De maksimale størrelser ofte multiplisere sammen for å danne svært store tall. Også, hvis du skje til å trenge å være i stand til å redigere en odd-fil med en 2000 tegnet linje i det, da er du ute av lykken. Det er virkelig ingen måte for deg å forutsi og håndtere maksimal linjelengde av en tekstfil, fordi, teknisk sett, at antallet er uendelig.

Pekere er designet for å løse dette problemet. Med pekere, kan du opprette dynamiske datastrukturer. I stedet for å forkynne ditt verste minne forbruk up-front i en array, kan du i stedet allokere minne fra haugen mens programmet kjører. På den måten kan du bruke den eksakte mengden minne som er et dokument behov, uten sløsing. I tillegg, når du lukker et dokument du kan returnere minne til haugen, slik at andre deler av programmet kan bruke det. Med pekere, minne kan bli resirkulert mens programmet kjører.

Forresten, hvis du har lest den forrige diskusjon og en av de store spørsmål du har er, “Hva ER en byte, egentlig?,” så artikkelen Hvordan Bits og Bytes Arbeidet vil hjelpe deg å forstå begrepene, samt ting som “mega,” “giga” og “tera.” Ta en titt og så komme tilbake.

Det Grunnleggende av C-Programmering

0

Tips

Markørene brukes overalt i C, så hvis du ønsker å bruke C-språk fullt ut må du har en veldig god forståelse av pekere. De har for å bli behagelig for deg. Målet med denne delen og den neste flere som følger er å hjelpe deg å bygge en fullstendig forståelse av pekere og hvordan C bruker dem. For de fleste folk det tar litt tid og litt øvelse for å bli helt komfortabel med tips, men når du mestrer dem du er en fullverdig C programmerer.

C bruker pekere på tre ulike måter:

Opp Neste

  • Hvordan fungerer JavaScript fungerer og hvordan kan jeg bygge enkle kalkulatorer med det?
  • Hvordan C-Programmering Fungerer
  • Hvordan Fungerer HTML5
  • Hva er fordelene av å lære C programmering?
  • Er data mining og data warehousing i slekt?
  • C bruker tips for å lage dynamiske datastrukturer — data strukturer bygget opp fra blokker av minne som er allokert fra haugen på kjøre-time.
  • C bruker tips for å håndtere variable parametere som sendes til funksjoner.
  • Pekere i C gir deg en alternativ måte å få tilgang til informasjonen som er lagret i tabeller. Pekeren teknikker er spesielt nyttig når du arbeider med strenger. Det er en intim forbindelse mellom matriser og pekere i C.

I noen tilfeller, C programmerere også bruke pekere fordi de gjør koden litt mer effektiv. Hva du vil finne er at når du er helt komfortabel med tips, du har en tendens til å bruke dem hele tiden.

Vi vil starte denne diskusjonen med en grunnleggende introduksjon til tips og konsepter rundt pekere, og deretter gå videre til tre teknikkene som er beskrevet ovenfor. Spesielt på denne artikkelen, vil du ønsker å lese ting to ganger. Den første gangen du kan lære alle konsepter. Andre gang gjennom at du kan arbeide på bindende begrepene sammen til en integrert helhet i ditt sinn. Når du gjør din vei gjennom materialet for annen gang, vil det gjøre mye fornuftig.

Grunderna i C-Programmering

0

Med hjälp av Pekare för funktionsparametrar

De flesta C-programmerare först använda pekare för att genomföra något som kallas variabla parametrar i funktioner. Du har faktiskt varit med variabla parametrar i scanf-funktionen-det är därför du varit tvungen att använda den & (adress operatör) på variabler som används med scanf. Nu när du förstår tips du kan se vad som verkligen händer.

För att förstå hur variabla parametrar arbete, kan se hur vi kan gå om att genomföra en swap – funktion i C. för Att genomföra en swap-funktion, vad du skulle vilja göra är att passera i två variabler och har till uppgift att byta sina värderingar. Här är ett försök till ett genomförande — skriv in och exekvera följande kod och se vad som händer:

Nästa

  • Hur fungerar JavaScript för att fungera och hur kan jag bygga en enkel miniräknare med det?
  • Hur C-Programmering Fungerar
  • Hur HTML5 Fungerar
  • Vad är fördelarna med att lära sig C-programmering?
  • Är data mining och data warehousing?

#include <stdio.h>

void swap(int i, int j)
{
int t;

t=i;
jag=j;
j=t;
}

void main()
{
int a,b;

a=5;
b=10;
printf(“%d %dn”, a, b),
swap(a,b),
printf(“%d %dn”, a, b),
}

När du kör programmet kommer du att finna att ingen växling sker. Värdena för a och b är godkänd för att byta och byta funktion inte byta dem, men när funktionen returnerar inget händer.

För att göra denna funktion fungerar korrekt kan du använda pekare, som visas nedan:

#include <stdio.h>

void swap(int *, int *j)
{
int t;
t = *jag;
*i = i *j;
*j = t;
}

void main()
{
int a,b;
a=5;
b=10;
printf(“%d %dn”,a,b),
swap(&a,&b);
printf(“%d %dn”,a,b),
}

För att få en uppfattning om vad den här koden gör, skriv ut den, rita två heltal a och b, och ange 5 och 10 i dem. Nu rita två pekare jag och j, tillsammans med heltal t. När swap kallas, det är passerat adresser i en och b. Alltså, jag poäng till ett (rita en pil från jag till en) och j poäng till b (rita en pil från b till j). När pekare initieras av funktionen samtal *jag är ett annat namn för en, och *j är ett annat namn för b. Nu kör koden i swap. När koden använder *jag och *j, det betyder verkligen a och b. När funktionen är klar, att a och b har bytts.

Anta att du råkar glömma det & när swap funktionen anropas, och att byta linje av misstag ser ut så här: swap(a, b);. Detta orsakar segmenteringsfel. När du lämnar ut &, – värdet av en leds i stället av dess adress. Därför jag pekar på en ogiltig plats i minnet och systemet kraschar när *jag är som används.

Detta är också anledningen till att scanf kraschar om du har glömt & på variabler som skickas till den. Den scanf – funktionen använder pekare för att sätta det värde som det står tillbaka till den variabel som du har gått. Utan &, scanf är vidare en felaktig adress och kraschar.

Variabla parametrar är en av de vanligaste användningarna av pekare i C. Nu förstår ni vad som händer!

Grunderna i C-Programmering

0

Tips: Vanliga Fel

Bugg #1 – Oinitierade tips

Ett av de enklaste sätten att skapa en pekare bugg är att försöka att referera till värdet av en pekare även om pekaren är oinitierad och ännu inte peka på en giltig adress. Till exempel:

Nästa

  • Hur fungerar JavaScript för att fungera och hur kan jag bygga en enkel miniräknare med det?
  • Hur C-Programmering Fungerar
  • Hur HTML5 Fungerar
  • Vad är fördelarna med att lära sig C-programmering?
  • Är data mining och data warehousing?

int *p;

*p = 12;

Pekaren p är oinitierad och pekar på en slumpmässig plats i minnet när du förklarar det. Det kan vara pekar i systemet stack, eller globala variabler, eller i programmets kod utrymme, eller i operativsystemet. När du säger *p=12;kommer programmet att helt enkelt prova att skriva en 12 till vad slumpmässig plats p poäng till. Programmet kan explodera omedelbart eller får vänta en halvtimme för att sedan explodera, eller det kan subtilt korrupt data i en annan del av ditt program och du kan aldrig inse det. Detta kan göra detta fel är mycket svårt att spåra. Se till att du initiera alla pekare till en giltig adress innan dereferencing dem.

Fel #2 – Invalid Pointer Referenser

En ogiltig pekare, referens uppstår när en pekare värde refereras även om pekaren inte peka till en giltig block.

Ett sätt att skapa detta fel är att säga att p=q;, när q är oinitierad. Pekaren p kommer då att bli initierad, och alla hänvisningar till *s är en ogiltig pekare, referens.

Det enda sättet att undvika detta fel är att rita bilder av varje steg i programmet och se till att alla pekare punkt någonstans. Ogiltig pekare, referenser orsaka att program kraschar oförklarligt för samma skäl som anges i Felrapport #1.

Fel #3 – Noll-Pekare, Referens

En noll-pekare hänvisning sker när en pekare som pekar till noll används i ett uttalande att försök att referera till ett block. Till exempel, om p är en pekare till ett heltal, följande kod är ogiltig:

p = 0,
*p = 12;

Det finns inget block pekade på av s. Därför försöker läsa eller skriva något från eller till att blocket är en ogiltig noll-pekare referens. Det finns goda och giltiga skäl att peka en pekare till noll, som vi kommer att se i senare artiklar. Dereferencing en sådan pekare, dock, är ogiltig.

Alla dessa buggar är dödlig till ett program som innehåller dem. Du måste titta på din kod så att dessa fel inte uppstår. Det bästa sättet att göra det är att rita bilder av kodens genomförande, steg för steg.

Grunderna i C-Programmering

0

Tips: Peka till Samma Adress

Här är en cool aspekt av C: Valfritt antal pekare kan peka på samma adress. Du kan till exempel deklarera p, q och r som heltal tips och ställa dem alla till en punkt att jag, som visas här:

int i;
int *p *q *r;

p = &i;
q = &i;
r = p;

Observera att i denna kod, r punkter till samma sak som p pekar på, som är jag. Du kan tilldela en pekare till en annan, och adressen är kopierad från höger sida till vänster sida under uppdraget. Efter att utföra ovanstående kod, detta är hur saker och ting skulle se ut:

Nästa

  • Hur fungerar JavaScript för att fungera och hur kan jag bygga en enkel miniräknare med det?
  • Hur C-Programmering Fungerar
  • Hur HTML5 Fungerar
  • Vad är fördelarna med att lära sig C-programmering?
  • Är data mining och data warehousing?

Den rörliga jag nu har fyra namn: jag, *p *q *r. Det finns ingen gräns på antal tips som kan hålla (och därför peka på) samma adress.