Home Blog Page 21553

Det Grundlæggende i Programmering C

0

Ved hjælp af Henvisninger med Arrays

Arrays og henvisninger er tæt forbundet i C. for At bruge arrays effektivt, er du nødt til at vide, hvordan at bruge henvisninger med dem. Fuldt ud at forstå forholdet mellem de to sandsynligvis kræver flere dage studier og eksperimenter, men det er indsatsen værd.

Lad os starte med et simpelt eksempel af arrays i C:

Op Næste

  • Hvordan virker JavaScript arbejde, og hvordan kan jeg opbygge simple lommeregnere med det?
  • Hvordan C Programmering Virker
  • Hvordan HTML5 Virker
  • Hvad er fordelene ved at lære C-programmering?
  • Er data mining og data warehousing relateret?

#define MAX 10

int main()
{
int a;
int b;
int i;
for(i=0; i<MAX; i++)
en=jeg;
b=a;
return 0;
}

Indtast denne kode og prøve at samle det. Du vil opdage, at C ikke vil kompilere det. Hvis du vil kopiere fra a til b, er du nødt til at indtaste noget i retning af følgende i stedet:

for (i=0; i<MAX; i++)
b=a;

Eller, for at sige det mere præcist:

for (i=0; i<MAX; b=a, i++);

Bedre endnu, skal du bruge memcpy nytte i snor.h.

Arrays i C er usædvanligt i, at variablerne a og b er ikke teknisk, arrays sig selv. I stedet er de permanente pointere til arrays. a og b permanent point til de første elementer af deres respektive arrays — de holder adresser på [0] og b[0] hhv. Da de faste pejlemærker, du kan ikke ændre deres adresser. Oversigten a=b; derfor virker ikke.

Fordi a og b er henvisninger, kan du gøre flere interessante ting med pointers og arrays. For eksempel, følgende kode virker:

#define MAX 10

void main()
{
int a;
int i;
int *p;

p=a;
for(i=0; i<MAX; i++)
en=jeg;
printf(“%dn”,*p);
}

Den stat, der af de variabler, som lige før for-løkken starter udførelse.

HowStuffWorks.kom

Oversigten p=a; virker, fordi en er en pointer. Teknisk set, et point til adresse 0 element i den faktiske array. Dette element er et heltal, så et er en pointer til en enkelt heltal. Derfor erklære s som en pointer til en integer, og sætte den lig med en arbejder. En anden måde at sige præcis de samme ting, ville være at erstatte p=a; med s=&a[0];. Da en indeholder adressen på a[0], a og &a[0] betyder det samme.

Nu, som p peger på 0 element af en, du kan gøre nogle ret mærkelige ting med det. Det er en variabel er en permanent pointer og kan ikke ændres, men s er ikke underlagt sådanne begrænsninger. C-faktisk opfordrer dig til at flytte det rundt ved hjælp af pointer aritmetik . For eksempel, hvis du siger, p++;compileren ved, at p point til et heltal, så er denne udtalelse intervaller p passende antal bytes til at flytte til det næste element i arrayet. Hvis p var der peger på et array af 100-byte-lang strukturer, p++; ville flytte s i løbet af 100 bytes. C tager sig af detaljerne i element størrelse.

Du kan kopiere array a til b ved hjælp af henvisninger samt. Følgende kode kan erstatte (for i=0; i<MAX; a=b, i++); :

p=a;
q=b;
for (i=0; i<MAX; i++)
{
*q = *p;
q++;
p++;
}

Du kan forkorte denne kode, som følger:

p=a;
q=b;
for (i=0; i<MAX; i++)
*q++ = *p++;

Og du kan yderligere at forkorte det til:

for (s=a,q=b,i=0; i<MAX; *q++ = *p++, jeg++);

Hvad hvis du går ud over enden af matrixen a eller b med de pejlemærker, p eller q? C er ligeglad-det gladeligt går langs forøgelse p og q, kopiering væk i forhold til andre variabler, med opgive. Du er nødt til at være forsigtig, når indeksering i arrays i C, da C forudsætter, at du ved, hvad du laver.

Kan du give et array som a eller b for at en funktion på to forskellige måder. Forestil dig en funktion, dump , der accepterer et array af heltal som parameter, og udskriver indholdet af array til stdout. Der er to måder at kode dump:

void dump(int a[],int nia)
{
int i;
for (i=0; i<nia; i++)
printf(“%dn”,a);
}

eller:

void dump(int *p,int nia)
{
int i;
for (i=0; i<nia; i++)
printf(“%dn”,*p++);
}

Den nia (number_in_array) variablen er påkrævet, således at størrelsen af array er kendt. Bemærk, at det kun er en pointer til arrayet, snarere end indholdet af den array, der overføres til funktionen. Bemærk også, at C-funktioner, kan modtage variabel størrelse arrays som parametre.

Hvordan Fungerer Caching

0

Caching øker hastigheten på datamaskinen trekker bits og bytes fra minnet. Se mer minne datamaskinen bilder.

2008 HowStuffWorks

Hvis du har vært på shopping for en datamaskin, så har du hørt ordet “buffer.” Moderne datamaskiner har både L1 og L2 cacher, og mange av dem som nå også har L3-cache. Du kan også ha fått råd om dette emnet fra velmenende venner, kanskje noe som “ikke kjøpe det Celeron chip, den ikke har noen buffer i det!”

Opp Neste

  • Hvordan Secure Digital Minnekort Arbeid
  • SD-Minnekort Quiz
  • Datamaskinens Minne Bilder
  • Tech Talk: RAM Quiz
  • Tech Talk: Datamaskin Minne Quiz

Det viser seg at caching er en viktig datamaskin-vitenskap prosess som vises på hver datamaskin i en rekke former. Det er minne cacher, maskinvare og programvare disk cacher, side cacher og mer. Virtuelt minne er enda en form av mellomlagring. I denne artikkelen vil vi utforske caching slik at du kan forstå hvorfor det er så viktig.

Det Grunnleggende av C-Programmering

0

Binære Filer

Binære filer er svært lik matriser av strukturer, bortsett fra de strukturer som finnes i en fil på harddisken i stedet for i et array i minnet. Fordi strukturene i en binær fil på disken, kan du skape svært store samlinger av dem (bare begrenset av tilgjengelig diskplass). De er også permanent og alltid tilgjengelig. Den eneste ulempen er at den treghet som kommer fra disk tilgang tid.

Binære filer har to kjennetegn som skiller dem fra tekst filer:

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?
  • Du kan hoppe umiddelbart til noen struktur i filen, som gir random access som i en matrise.
  • Du kan endre innholdet i en struktur hvor som helst i filen til enhver tid.

Binære filer også har vanligvis raskere lese og skrive ganger enn tekst-filer, fordi et binært bilde av oppføringen er lagret direkte fra minnet til disk (eller vice versa). I en tekst-fil, har alt som skal konverteres tilbake og frem til tekst, og dette tar tid.

C støtter file-av-strukturer konseptet veldig rent. Når du åpner filen kan du lese en struktur, skrive en struktur, eller søke å få til en struktur i filen. Denne filen konseptet støtter konseptet om en fil pekeren. Når filen er åpnet, pekeren poeng for å spille inn 0 (den første oppføringen i filen). Enhver operasjon leser for øyeblikket peker til struktur og flytter pekeren ned én struktur. Alle skrive drift skriver for tiden peker til struktur og flytter pekeren ned én struktur. Søker flytter pekeren til den valgte oppføringen.

Husk at C tenker på alt i fil på harddisken som blokker av byte lese fra disk til minne eller lese fra minnet på disk. C bruker en fil pekeren, men det kan peke på noen byte posisjon i filen. Du er derfor nødt til å holde styr på ting.

Følgende program illustrerer disse begrepene:

#include <stdio.h>

/* tilfeldig record-beskrivelse – kan være noe */
sin struct rec
{
int x,y,z,
};

/* skriver og deretter leser 10 vilkårlig poster
fra filen “junk”. */
int main()
{
int i,j;
FILE *f;
sin struct rec r;

/* opprette filen på 10 poster */
f=fopen(“søppelpost”,”w”);
if (!f)
return 1;
for (i=1;i<=10; i++)
{
r.x=i;
fwrite(&r,sizeof(sin struct rec),1,f);
}
fclose(f);

/* les de 10 postene */
f=fopen(“søppelpost”,”r”);
if (!f)
return 1;
for (i=1;i<=10; i++)
{
fread(&r,sizeof(sin struct rec),1,f);
printf(“%dn”,r.x);
}
fclose(f);
printf(“n”);

/* bruk fseek å lese 10 oppføringer
i omvendt rekkefølge */
f=fopen(“søppelpost”,”r”);
if (!f)
return 1;
for (i=9; i>=0; i–)
{
fseek(f,sizeof(sin struct rec)*jeg,SEEK_SET);
fread(&r,sizeof(sin struct rec),1,f);
printf(“%dn”,r.x);
}
fclose(f);
printf(“n”);

/* bruk fseek å lese alle andre album */
f=fopen(“søppelpost”,”r”);
if (!f)
return 1;
fseek(f,0,SEEK_SET);
for (i=0;i<5; i++)
{
fread(&r,sizeof(sin struct rec),1,f);
printf(“%dn”,r.x);
fseek(f,sizeof(sin struct rec),SEEK_CUR);
}
fclose(f);
printf(“n”);

/* bruk fseek å lese 4. spille inn,
endre den og skrive den tilbake */
f=fopen(“søppelpost”,”r+”);
if (!f)
return 1;
fseek(f,sizeof(sin struct rec)*3,SEEK_SET);
fread(&r,sizeof(sin struct rec),1,f);
r.x=100;
fseek(f,sizeof(sin struct rec)*3,SEEK_SET);
fwrite(&r,sizeof(sin struct rec),1,f);
fclose(f);
printf(“n”);

/* les de 10 postene for å sikre
4. spille inn ble endret */
f=fopen(“søppelpost”,”r”);
if (!f)
return 1;
for (i=1;i<=10; i++)
{
fread(&r,sizeof(sin struct rec),1,f);
printf(“%dn”,r.x);
}
fclose(f);
return 0;
}

I dette programmet, en struktur beskrivelse rec har vært brukt, men du kan bruke hvilken som helst struktur beskrivelse du vil. Du kan se at fopen og fclose fungerer akkurat som de gjorde for tekst-filer.

De nye funksjonene her er fread, fwrite og fseek. Den fread funksjonen tar fire parametre:

  • En minneadresse
  • Antallet byte som er å lese per kvartal
  • Antall blokker for å lese
  • Filen variabel

Dermed linje fread(&r,sizeof(sin struct rec),1,f); står å lese 12 byte (størrelsen på rec) fra fil – f (fra gjeldende plassering av filen pekeren) til minne adresse &r. En blokk med 12 byte er bedt om. Det ville være like lett å lese 100 kvartaler fra disk til en array i minnet ved å endre 1 til 100.

Den fwrite funksjonen fungerer på samme måte, men beveger blokken av bytes fra minnet til fil. Den fseek funksjon flytter pekeren til en fil byte på filen. Generelt, flytter du pekeren i sizeof(rec sin struct) trinn for å holde pekeren på posten grenser. Du kan bruke tre valg når du søker:

  • SEEK_SET
  • SEEK_CUR
  • SEEK_END

SEEK_SET flytter pekeren x byte fra begynnelsen av filen (fra byte 0 i filen). SEEK_CUR flytter pekeren x byte ned fra dagens pekeren posisjon. SEEK_END flytter pekeren fra slutten av filen (så du må bruke negative kvoter med dette alternativet).

Flere ulike alternativer vises i koden ovenfor. I særlig oppmerksom på den delen der filen er åpnet med r+ – modus. Dette åpner filen for å lese og skrive, noe som gjør poster som skal endres. Koden søker til en oppføring, leser det, og endringer i et felt, det så søker tilbake fordi lese fordrevne pekeren, og skriver endre tilbake.

For mer informasjon om C og relaterte emner, sjekk ut linkene på neste side.

Det Grunnleggende av C-Programmering

0

Kommandolinje-Argumenter

C gir en ganske enkel mekanisme for å gjenopprette kommandolinje parametere som angis av brukeren. Det går en argv parameteren til den viktigste funksjonen i programmet. argv strukturer vises i en god del av de mer avanserte bibliotek samtaler, slik forståelse dem er nyttig for alle C-programmerer.

Skriv inn følgende kode og kompilere:

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>

int main(int argc, char *argv[])
{
int x;

printf(“%dn”,argc);
for (x=0; x<argc; x++)
printf(“%sn”,argv);
return 0;
}

I denne koden, er det viktigste programmet aksepterer to parametre, argv og argc. Den argv parameteren er en rekke pekere til streng som inneholder de oppgitte parameterne når programmet ble startet på UNIX-kommando linje. Den argc heltall inneholder et antall parametere. Denne bestemt stykke kode typer ut kommandolinje parametere. For å prøve dette, kan du kompilere koden til en kjørbar fil som heter aaa og type aaa xxx yyy zzz. Koden vil skrive ut kommandolinje parametere xxx, yyy og zzz, ett per linje.

Den char *argv[] line er en rekke pekere til string. Med andre ord, hvert element i matrisen er en peker, og hver pekeren peker til en streng (teknisk, til det første tegnet i strengen). Dermed, argv[0] peker til en streng som inneholder den første parameteren på kommandolinjen (programmets navn), argv[1] peker til den neste parameteren, og så videre. Den argc variabel som forteller deg hvor mange av pekere i tabellen er gyldig. Du vil finne at den forrige koden gjør noe mer enn å skrive ut hver av de gyldige strenger peker til argv.

Fordi argv finnes, kan du la programmet reagerer på kommandolinje parametere som angis av brukeren ganske enkelt. For eksempel kan du ha programmet oppdage ordet hjelp som første parameter følgende navnet på programmet, og dumpe en hjelpe-fil til stdout. Filnavn kan også være bestått i og brukes i fopen uttalelser.

Det Grunnleggende av C-Programmering

0

Operatør Forrang

C inneholder mange operatører, og på grunn av måten som operatør forrang fungerer, interaksjoner mellom flere operatører kan bli forvirrende.

x=5+3*6;

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?

X får verdien 23, ikke 48, fordi i C multiplikasjon og divisjon har høyere prioritet enn addisjon og subtraksjon.

char *[10];

Er en en enkelt peker til en matrise av 10 tegn, eller er det et utvalg av 10 henvisninger til karakter? Med mindre du kjenner konvensjoner forrang i C, det er ingen måte å finne ut. På samme måte, i E. 11 vi så at på grunn av forrang setninger som *s.jeg = 10; ikke fungerer. I stedet, form (*p).jeg = 10; må brukes til å tvinge riktig prioritering.

Følgende tabell fra C Programming Language, ved Kernighan og Ritchie, viser forrang hierarkiet i C. Den øverste linjen har høyest prioritet.

Operatører Assosiativitet
( [ – . Fra venstre til høyre
! – ++ -{- + * & (type-cast) sizeof Høyre til venstre
(i linjen ovenfor, +, – og * er mono-skjemaer)
* / % Venstre til høyre
+ – Venstre til høyre
<< >> Venstre til høyre
< <= > >= Venstre til høyre
== != Fra venstre til høyre
& Venstre til høyre
^ Venstre til høyre
| Venstre til høyre
&& Venstre til høyre
|| Fra venstre mot høyre
?: Fra venstre til høyre
= += -= *= /= %= &= ^= |= <<= >>= Høyre til venstre
Fra venstre mot høyre

Ved hjelp av denne tabellen, kan du se at char *[10]; er en samling av 10 henvisninger til karakter. Du kan også se hvorfor parentes er nødvendig hvis (*p).jeg skal håndteres på riktig måte. Etter litt øvelse, du vil huske mest mulig ut av denne tabellen, men hver nå og igjen, noe som ikke vil fungere fordi du har blitt fanget av en subtil foran problemet.

Det Grunnleggende av C-Programmering

0

Spesielle Oppmerksom på Strenger

Spesielle Oppmerksom på String Konstanter

Anta at du oppretter følgende to koden fragmenter og kjøre dem:

Fragment 1

{
char *s;

s=”hei”;
printf(“%sn”,s);
}

Fragment 2

{
char s[100];

strcpy(s,”hei”);
printf(“%sn”,s);
}

Disse to fragmenter produsere samme effekt, men deres interne virkemåten er ganske forskjellige. I fragment 2, du kan ikke si s=”hei”;. For å forstå forskjellene, må du forstå hvordan string konstant tabell arbeider i C.

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?

Når programmet er kompilert, kompilatoren former objektkoden-fil, som inneholder din maskin kode og en tabell over alle string konstanter som er angitt i programmet. I fragment 1, oppstilling s=”hei”; forårsaker s til å peke til adressen til strengen hallo i strengen konstant bordet. Siden denne strengen er i strengen konstant bordet, og derfor teknisk sett en del av kjørbar kode, kan du ikke endre det. Du kan bare vise til det og bruke det i en skrivebeskyttet måte.

I fragment 2, string hei finnes også i konstant bordet, slik at du kan kopiere det inn i rekken av tegn som heter s. Siden s er ikke en peker, oppstilling s=”hei”; vil ikke fungere i del 2. Det vil ikke engang kompilere.

Spesielle Oppmerksom på ved Hjelp av Strenger med malloc

La oss anta at du skriver følgende program:

int main()
{
char *s;

s=(char *) malloc (100);
s=”hei”;
gratis(s);
return 0;
}

Det kan kompilere riktig, men gir en segmentering feil på fri linje når du kjører det. Den malloc linje tildeler en blokk 100 bytes lang og poeng s på det, men nå er det s=”hei”; line er et problem. Det er syntaktisk riktig fordi s er en peker, men når s=”hei”; er utført, s peker til strengen i strengen konstant bordet og de tildelte blokker er foreldreløse. Siden s er peker til strengen konstant bordet, strengen kan ikke endres; gratis mislykkes fordi det ikke deallocate en blokk i en kjørbar regionen.

Den riktige koden følger:

int main()
{
char *s;
s=(char *) malloc (100);
strcpy(s,”hei”);
gratis(s);
return 0;
}

Prøv Dette!

  • Lag et program som leser i en streng som inneholder et fornavn etterfulgt av en blank etterfulgt av et etternavn. Skriv funksjoner for å fjerne eventuelle innledende eller etterfølgende mellomrom eller tabulatorer. Skrive en annen funksjon som returnerer etternavn.
  • Skriv en funksjon som konverterer en streng til store bokstaver.
  • Skriv en funksjon som blir det første ordet fra en streng og returnerer resten av strengen.

C-Feil å Unngå

Å miste karakter, som er lett hvis du ikke er forsiktig, kan føre til noen veldig små bugs. Sørg for at du kopiere når du kopierer strenger. Hvis du vil opprette en ny streng, sørg for at du setter i det. Og hvis du kopierer en streng til en annen, må du kontrollere at du mottar strengen er stor nok til å holde kilde streng, herunder . Til slutt, hvis du peker et tegn peker til noen tegn, sørg for at de ender med .

Det Grunnleggende av C-Programmering

0

Strenger

HowStuffWorks.com

Strenger i C er sammenvevd med pekere til en stor grad. Du må bli kjent med pekeren konsepter som er dekket i tidligere artikler til bruk C strenger effektivt. Når du blir vant til dem, men du kan ofte utføre streng manipulasjoner svært effektivt.

En streng i C er rett og slett en rekke tegn. Følgende linje erklærer en array som kan holde en streng på opptil 99 tegn.

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?

char str[100];

Den inneholder tegn som du ville forvente: str[0] er det første tegnet i strengen, str[1] er det andre tegnet, og så videre. Men hvorfor er en 100-element utvalg i stand til å holde opp til 100 tegn? Fordi C bruker null-avsluttet strenger, noe som betyr at på slutten av en streng er merket med ASCII-verdi 0 (null-tegn), som også er representert i C som ‘’.

Null oppsigelse er svært forskjellig fra den måten mange andre språk håndtere strenger. For eksempel, i Pascal, hver streng består av en rekke tegn, med en lengde byte som holder tellingen på antall tegn som er lagret i tabellen. Denne strukturen gir Pascal en klar fordel når du spør etter lengden av en streng. Pascal kan bare tilbake lengde byte, mens C har til å telle tegn til det finner ‘’. Dette faktum gjør C mye tregere enn Pascal i visse tilfeller, men i andre, for det gjør det raskere, som vi vil se i eksemplene nedenfor.

Fordi C gir ingen eksplisitt støtte for strenger i språket selv, alle av string-håndtering funksjoner er implementert i bibliotekene. Strengen jeg/0 operasjoner (får, setter, og så videre) er implementert i <stdio.h>, og et sett av ganske enkel string manipulasjon funksjoner er implementert i <string.h> (på enkelte systemer, <strenger.h> ).

Det faktum at strengene ikke er innfødt til C tvinger deg til å lage noen ganske rundkjøringen kode. Anta For eksempel at du vil tilordne en streng til en annen streng, det vil si at du ønsker å kopiere innholdet av en streng til en annen. I C, som vi så i den siste artikkelen, kan du ikke bare gi en array til en annen. Du har til å kopiere det element for element. Strengen bibliotek (<string.h> eller <strenger.h> ) inneholder en funksjon som heter strcpy for denne oppgaven. Her er et svært vanlig kodebit som du finner i en vanlig C-program:

char s[100];
strcpy(s, “hei”);

Etter disse to linjene utføre følgende diagram viser innholdet av s:

Det øverste diagrammet viser tabellen med sine karakterer. Det nederste diagrammet viser den tilsvarende ASCII-kode verdier for karakterene, og hvordan C faktisk mener om streng (som en array av bytes som inneholder heltall). Se Hvordan Bits og Bytes Arbeide for en diskusjon av ASCII-koder.

Følgende kode viser hvordan du bruker strcpy i C:

#include <string.h>
int main()
{
røye s1[100],s2[100];
strcpy(s1,”hei”); /* kopier “hei” til s1 */
strcpy(s2,s1); /* kopi s1 til s2 */
return 0;
}

strcpy brukes når en streng er initialisert i C. Du bruker strcmp funksjon i strengen biblioteket for å sammenligne to strenger. Den returnerer et heltall som angir resultatet av sammenligningen. Null betyr at de to strengene er lik, vil en negativ verdi betyr at s1 er mindre enn s2, og en positiv verdi betyr at s1 er større enn s2.

#include <stdio.h>
#include <string.h>
int main()
{
røye s1[100],s2[100];
får(s1);
får(s2);
hvis (strcmp(s1,s2)==0)
printf(“lik” n”);
else if (strcmp(s1,s2)<0)
printf(“s1 mindre enn s2n”);
annet
printf(“s1 større enn s2n”);
return 0;
}

Andre vanlige funksjoner i strengen bibliotek inkluderer strlen, som returnerer lengden av en streng, og strcat som setter sammen to strenger. Strengen biblioteket inneholder en rekke andre funksjoner, som du kan lese ved å lese mannen side.

For å komme i gang å bygge string funksjoner, og for å hjelpe deg å forstå andre programmerere’ – koden (alle synes å ha sitt eget sett av streng funksjoner for spesielle formål i et program), vil vi se på to eksempler, strlen og strcpy. Følgende er et strengt Pascal-lignende versjon av strlen:

int strlen(char s[])
{
int x;
x=0;
mens (s != ‘’)
x=x+1;
return(x);
}

De fleste C-programmerere unngå denne metoden fordi det virker ineffektiv. I stedet er de ofte bruke en markør-basert tilnærming:

int strlen(char *s)
{
int x=0;
mens (*s != ‘’)
{
x++;
s++;
}
return(x);
}

Du kan forkorte denne koden til følgende:

int strlen(char *s)
{
int x=0;
mens (*s++)
x++;
return(x);
}

Jeg kan tenke meg en sann C ekspert vil kunne gjøre denne koden enda kortere.

Når jeg kompilere disse tre biter av koden på en MicroVAX med gcc, bruker ingen optimalisering, og kjøre hver 20,000 ganger på en 120-tegnstreng, den første del av koden gir en tid på 12,3 sekunder, den andre med 12,3 sekunder, og den tredje på 12,9 sekunder. Hva betyr dette? For meg, og det betyr at du skal skrive koden på den måten som er enklest for deg å forstå. Tips generelt gir raskere kode, men strlen koden ovenfor viser at det er ikke alltid tilfelle.

Vi kan gå gjennom den samme utviklingen med strcpy:

strcpy(char s1[],char s2[])
{
int x;
for (x=0; x<=strlen(s2); x++)
s1=s2;
}

Merk her at <= er viktig i for – løkke fordi koden deretter kopierer ‘’. Sørg for å kopiere ‘’. Store bugs oppstå senere på hvis du la det ut, fordi strengen har ingen ende, og derfor er et ukjent lengde. Merk også at denne koden er svært ineffektiv, fordi strlen blir kalt hver gang gjennom for – løkke. For å løse dette problemet, kan du bruke følgende kode:

strcpy(char s1[],char s2[])
{
int x,len;
len=strlen(s2);
for (x=0; x<=len; x++)
s1=s2;
}

Pekeren versjonen er lik.

strcpy(char *s1,char *s2)
{
mens (*s2 != ‘’)
{
*s1 = *s2;
s1++;
s2++;
}
}

Du kan komprimere denne koden videre:

strcpy(char *s1,char *s2)
{
mens (*s2)
*s1++ = *s2++;
}

Hvis du ønsker, kan du si mens (*s1++ = *s2++);. Den første versjonen av strcpy tar 415 sekunder å kopiere en 120-tegnstreng 10.000 ganger, den andre versjonen tar 14.5 sekunder, den tredje versjon 9.8 sekunder, og den fjerde 10.3 sekunder. Som du kan se, pekere gi en betydelig økning i ytelse her.

Prototypen for strcpy funksjon i strengen bibliotek viser at det er egnet til å gi en peker til en streng:

char *strcpy(char *s1,char *s2)

De fleste av strengen funksjoner som returnerer en streng pekeren som et resultat, og strcpy returnerer verdien av s1 som resultat.

Bruk pekere med strenger kan noen ganger resultere i klare forbedringer i hastighet, og du kan dra nytte av disse hvis du tror om dem litt. Anta For eksempel at du ønsker å fjerne den ledende feltene fra en streng. Du kan være tilbøyelig til å skifte tegn over på toppen av feltene for å fjerne dem. I C, kan du unngå bevegelse helt:

#include <stdio.h>
#include <string.h>

int main()
{
char s[100],*p;
får(s);
p=s;
mens (*p==’ ‘)
p++;
printf(“%sn”,s);
return 0;
}

Dette er mye raskere enn den bevegelse teknikk, spesielt for lange strenger.

Du vil plukke opp mange andre triks med strenger som du går sammen og lese andre koder. Praksis er nøkkelen.

Det Grunnleggende av C-Programmering

0

Bruk Pekere med Matriser

Matriser og pekere er nært knyttet sammen i C. Å bruke matriser effektivt, må du vite hvordan du skal bruke pekere med dem. Fullt ut å forstå forholdet mellom de to trolig krever flere dager med studier og eksperimentering, men det er vel verdt innsatsen.

La oss starte med et enkelt eksempel på arrays i C:

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?

#define MAKS 10

int main()
{
int a;
int b;
int i;
for(i=0; i<MAX; i++)
a=i;
b=a;
return 0;
}

Skriv inn denne koden og prøve å gjere det. Du vil finne at C ikke vil gjere det. Hvis du ønsker å kopiere en til b, må du taste inn noe som det følgende i stedet:

for (i=0; i<MAX; i++)
b=a;

Eller, for å si det mer konsist:

for (i=0; i<MAX; b=a, jeg++);

Bedre ennå, kan du bruke memcpy verktøyet i strengen.h.

Matriser i C er uvanlig i at variablene a og b er ikke, teknisk sett, matriser seg selv. I stedet er de permanente pekere til matriser. a og b permanent peker til første elementer av deres respektive rekker — de holder adresser av a[0] og b[0] hhv. Siden de er permanent tips du kan ikke endre deres adresser. Uttalelsen a=b; derfor ikke fungerer.

Fordi a og b er pekere, kan du gjøre flere interessante ting med pekere og tabeller. For eksempel, følgende koden fungerer:

#define MAKS 10

void main()
{
int a;
int i;
int *p;

s=a;
for(i=0; i<MAX; i++)
a=i;
printf(“%dn”,*p);
}

Staten av variablene før for-løkke begynner å kjøre.

HowStuffWorks.com

Uttalelsen p=a; fungerer fordi en er en peker. Teknisk sett, en peker til-adresse til den 0th element av den faktiske utvalg. Dette elementet er et heltall, så en er en peker til et enkelt heltall. Derfor erklærte p som en peker til et heltall og sette den lik en som fungerer. En annen måte å si nøyaktig den samme tingen ville være å erstatte p=a; med p=&a[0];. Siden en inneholder adressen til a[0], a og &a[0] betyr det samme.

Nå som p peker på 0th element i en, kan du gjøre noen ganske merkelige ting med det. I en variabel er en permanent peker og kan ikke endres, men p er ikke underlagt slike restriksjoner. C-faktisk oppfordrer deg til å flytte den rundt ved hjelp av pekeren matematikk . Hvis du For eksempel si p++;, kompilatoren kjenner som p peker til et heltall, så denne erklæringen trinn p riktig antall byte for å flytte til det neste elementet i matrisen. Hvis s var peker til en rekke 100-byte lang strukturer, s++; ville flytte p over av 100 bytes. C tar vare på detaljer for element størrelse.

Du kan kopiere matrisen a til b ved hjelp av pekere, så vel. Følgende kode kan erstatte (for i=0; i<MAX; a=b, jeg++); :

s=a;
q=b;
for (i=0; i<MAX; i++)
{
*q = *p;
q++;
p++;
}

Du kan forkorte denne koden som følger:

s=a;
q=b;
for (i=0; i<MAX; i++)
*q++ = *p++;

Og du kan videre forkorte det til:

for (p=a,q=b,i=0; i<MAX; *q++ = *p++, jeg++);

Hva om du går utover slutten av matrisen a eller b med pekere p eller q? C bryr seg ikke-det gladelig går langs økes p og q, kopiering bort over andre variabler med abandon. Du må være forsiktig når indeksering til matriser i C, fordi C forutsetter at du vet hva du gjør.

Du kan sende en matrise, som for eksempel a eller b til en funksjon i to forskjellige måter. Tenk deg en funksjon dump som aksepterer en tabell av heltall som parameter, og skriver ut innholdet av arrayet til stdout. Det er to måter å kode dump:

ugyldige dump(int a[],int nia)
{
int i;
for (i=0; i<nia; i++)
printf(“%dn”,a);
}

eller:

ugyldige dump(int *p,int nia)
{
int i;
for (i=0; i<nia; i++)
printf(“%dn”,*p++);
}

Den nia (number_in_array) variabel er nødvendig, slik at størrelsen på matrisen er kjent. Merk at bare en peker til matrisen, snarere enn innholdet av tabellen, er sendt til funksjonen. Legg også merke til at C-funksjoner kan motta variabel størrelse tabeller som parametre.

Hur Cachning Fungerar

0

Caching kraftigt ökar hastigheten med vilken din dator drar bits och bytes från minnet. Se mer av datorns minne bilder.

2008 HowStuffWorks

Om du har varit shopping för en dator, då har du hört ordet “cache.” Moderna datorer har både L1 och L2 cache, och många nu även har L3-cache. Du kan också ha fått råd om ämnet från välmenande vänner, kanske något i stil med “köp inte som Celeron chip, att det inte har någon cache i det!”

Nästa

  • Hur Secure Digital Minneskort Arbete
  • SD-Minneskort Quiz
  • Datorns Minne Bilder
  • Tech Talk: RAM-Quiz
  • Tech Talk: Datorns Minne Quiz

Det visar sig att caching är en viktig dator-science process som verkar på varje dator i en mängd olika former. Det finns minne cachar, hårdvara och programvara disk cachar, cachar sidan och mer. Virtuellt minne är även en form av cachning. I denna artikel, kommer vi att undersöka caching så kan du förstå varför det är så viktigt.

Grunderna i C-Programmering

0

Binära Filer

Binära filer är mycket liknande till kedjor av strukturer, utom de strukturer som finns i en fil på datorn snarare än i en matris i minnet. Eftersom strukturer i en binär fil på disk, kan du skapa mycket stora samlingar av dem (begränsas endast av ditt tillgängliga diskutrymme). De är också permanent och alltid tillgänglig. Enda nackdelen är att den långsamhet som kommer från hårddisken tillgång.

Binära filer som har två egenskaper som skiljer dem från en textfil:

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?
  • Du kan hoppa direkt till någon struktur i filen, vilket ger random access som i en array.
  • Du kan ändra innehållet i en struktur som helst i filen som helst.

Binära filer också har oftast snabbare att läsa och skriva gånger än text-filer, eftersom en binär bild av posten lagras direkt från minnet till hårddisken (eller vice versa). I en text fil, allt som ska konverteras och tillbaka för att sms: a, och detta tar tid.

C stöder file-av-strukturer konceptet är mycket rent. När du öppnar filen kan du läsa en struktur, skriva en struktur, eller söka till någon struktur i filen. Den här filen konceptet stöder konceptet av en fil pekaren. När filen öppnas, det pekaren pekar på att spela in 0 (den första posten i den filen). Någon läsning läser för närvarande påpekade-att strukturera och flyttar pekaren nedåt en struktur. Alla skrivoperationer skriver att det för närvarande påpekade-att strukturera och flyttar pekaren nedåt en struktur. Söker flyttar du pekaren till den begärda posten.

Tänk på att C tycker att allt i disken filen som block av bytes läsa från disk till minnet eller läsa från minnet på skivan. C använder en fil pekare, men det kan peka på att något byte plats i filen. Du måste därför hålla reda på saker.

Följande program illustrerar dessa begrepp:

#include <stdio.h>

/* slumpmässiga post beskrivning – kan vara allt */
struct rec
{
int x,y,z;
};

/* skriver och läser sedan 10 godtycklig poster
från filen “skräp”. */
int main()
{
int i,j;
FILE *f;
struct rec r;

/* skapa filen av 10 poster */
f=fopen(“skräppost”,”w”);
if (!f)
return 1;
for (i=1;i<=10; i++)
{
r.x=i;
fwrite(&r,sizeof(struct rec),1,f);
}
fclose(f);

/* läs 10 poster */
f=fopen(“skräppost”,”r”);
if (!f)
return 1;
for (i=1;i<=10; i++)
{
fread(&r,sizeof(struct rec),1,f);
printf(“%dn”,r.x);
}
fclose(f);
printf(“n”);

/* använd fseek att läsa 10 poster
i omvänd ordning */
f=fopen(“skräppost”,”r”);
if (!f)
return 1;
for (i=9; i>=0; i–)
{
fseek(f,sizeof(struct rec)*jag,SEEK_SET);
fread(&r,sizeof(struct rec),1,f);
printf(“%dn”,r.x);
}
fclose(f);
printf(“n”);

/* använd fseek att läsa alla andra skiva */
f=fopen(“skräppost”,”r”);
if (!f)
return 1;
fseek(f,0,SEEK_SET);
for (i=0;i<5; i++)
{
fread(&r,sizeof(struct rec),1,f);
printf(“%dn”,r.x);
fseek(f,sizeof(struct rec),SEEK_CUR);
}
fclose(f);
printf(“n”);

/* använd fseek att läsa 4: e-post,
ändra det, och skriva det på baksidan */
f=fopen(“skräppost”,”r+”);
if (!f)
return 1;
fseek(f,sizeof(struct rec)*3,SEEK_SET);
fread(&r,sizeof(struct rec),1,f);
r.x=100;
fseek(f,sizeof(struct rec)*3,SEEK_SET);
fwrite(&r,sizeof(struct rec),1,f);
fclose(f);
printf(“n”);

/* läs 10 poster för att försäkra
4: e-posten har ändrats */
f=fopen(“skräppost”,”r”);
if (!f)
return 1;
for (i=1;i<=10; i++)
{
fread(&r,sizeof(struct rec),1,f);
printf(“%dn”,r.x);
}
fclose(f);
return 0;
}

I det här programmet, en struktur beskrivning rec har använts, men du kan använda vilken struktur beskrivning du vill. Du kan se att fopen och fclose fungera exakt som de gjorde för text filer.

Nya funktioner här är fread, fwrite och fseek. Den fread funktion tar fyra parametrar:

  • Ett minne adress
  • Antalet byte för att läsa per block
  • Antalet block för att läsa
  • Filen variabel

Således linje fread(&r,sizeof(struct rec),1,f), står att läsa 12 byte (storleken på rec) från filen f (från aktuell plats för filen pekaren) till minne adress &r. Ett block av 12 byte krävs. Det skulle vara lika lätt att läsa 100 block från disk till en matris i minnet genom att ändra 1 till 100.

Den fwrite funktion fungerar på samma sätt, men flyttar block av bytes från minne till filen. Den fseek funktion flyttar filpekaren till ett byte i filen. I allmänhet, du flyttar pekaren i sizeof(struct rec) steg för att hålla pekaren på posten gränser. Du kan använda tre olika alternativ när du söker:

  • SEEK_SET
  • SEEK_CUR
  • SEEK_END

SEEK_SET flyttar pekaren x byte ned från början av filen (från byte 0 i filen). SEEK_CUR flyttar pekaren x byte ner från den nuvarande pekaren position. SEEK_END flyttar pekaren från slutet av fil (så att du måste använda negativa förskjutningar som med detta alternativ).

Flera olika alternativ visas i koden ovan. Särskilt notera de avsnitt där filen öppnas med r+ – läge. Detta öppnar filen för läsning och skrivning, vilket gör att poster att ändras. Koden syftar till en post, läser det, och förändringar i ett område, är det då syftar tillbaka på grund läsa fördrivna pekaren, och skriver att ändra tillbaka.

För mer information om C och relaterade ämnen, kolla in länkarna på nästa sida.