Forskellen mellem Array og Pointer
Indhold
Der er et tæt forhold mellem matrix og markør. Markøren kan bruges til at få adgang til arrayelementerne, adgang til hele arrayet ved hjælp af pointer aritmetik gør adgangen hurtigere. Der er en grundlæggende forskel mellem en markør og en matrix, dvs. en matrix er en samling af variabler af lignende datatype, mens pointeren er en variabel, der gemmer adressen på en anden variabel. Der er nogle andre forskelle mellem en matrix og en markør, der diskuteres nedenfor i sammenligningstabellen.
- Sammenligningstabel
- Definition
- Vigtige forskelle
- Konklusion
Sammenligningstabel
| Grundlag for sammenligning | Array | Pointer |
|---|---|---|
| Erklæring | // I C ++ type var_navn; // I Java. type var-navn; var_name = ny type; | // I C ++ type * var_navn; |
| Arbejder | Gemmer værdien af variablen af homogen datatype. | Gem adressen til den anden variabel af samme datatype som markørvariablerne datatype. |
| Generation | En række markører kan genereres. | Der kan genereres en markør til en matrix. |
| Java-support | Understøt konceptet med matrix. | Understøtter ikke pointer. |
| Opbevaring | En normal matrix gemmer værdier for variabel og pointerarray gemmer adressen på variabler. | Pegere er specielt designet til at gemme adressen på variabler. |
| Kapacitet | En matrix kan gemme antallet af elementer, der er nævnt i størrelsen på arrayvariablen. | En markørvariabel kan gemme adressen på kun en variabel ad gangen. |
Definition af Array
En matrix er samlingen af elementerne i den samme datatype, og alle disse elementer henvises med et almindeligt navn, som er navnet på en matrixvariabel. Et bestemt arrayelement kan fås ved at få adgang til det specifikke indeks for det array, hvor det element er lagret. Arrays kan være en endimensionel matrix, en to-dimensionel array eller multidimensionel array. Et array med pegere kan også genereres, dvs. en matrix, der indeholder alle variabler som markørvariabel. I 'C ++' er matriserne statisk tildelt, mens i 'Java' er matriserne dynamisk tildelt.
// I C ++ type var_navn; // I Java. type var-navn; var_name = ny type;
Her angiver 'type' datatypen for en matrixvariabel, 'var_name' betegner det navn, der er givet til arrayvariablen, 'størrelse' angiver kapaciteten for arrayvariablen, dvs. hvor mange elementer af 'type' kan gemmes i den arrayvariabel . Der er to metoder til at få adgang til en matrix, først 'pointer aritmetic' og anden 'array indexing', hvor 'pointer arithmetic' er hurtigere.
// adgang ved hjælp af pointer aritmetisk Void display_array (int * S) {while (* s) {cout (<< "værdi er" << * s); * S ++; }}
Brug af "pointer aritmetic" ville arbejde hurtigere sammenlignet med "array indexering", dvs. adgang til arrayvariablen ved hjælp af dets indeks. Hvis du har brug for at videregive en række pointer til en funktion, kan det gøres ved at bruge den samme metode, du bruger til at videregive en normal matrix, dvs. direkte kalde funktionen med navnet på arrayen, uden indeks.
Lad os forstå det med eksemplet
// At erklære arrayet af pointer. int * p;
Her viser det, at ‘p’ er en matrix af heltalstype, den vil indeholde adressen på 10 variabler af heltalstypen. Lad os overføre ovennævnte markørarray til et funktionsdisplay ().
display (p); // Ring til funktionsdisplayet. tomt display (int * d) {// Funktion, der henter pointerarray igen. for (int i = 0; i <10; i ++) {cout << ("indeks" <
Denne funktion viser værdierne, der er til stede i variablerne, hvis adresser er lagret i denne markørgruppe i rækkefølge.
Definition af Pointer
Markøren er en variabel, der indeholder hukommelsesadressen til en anden variabel. Datatypen for begge, markørvariablen og variablen, hvis adresse er tildelt en markørvariabel, skal være den samme. Markørvariablen er som deklareret som følger.
// Erklæring i C ++ type * navn;
Her er 'type' en datatype, 'navn' er navnet på markørvariablen. 'Type' definerer, hvilken type variabel adresse kan gemmes i markørvariablen. For eksempel gemmer heltalemarkøren adressen på heltalvariablen. Der er to markøroperatører '*' og '&'. Operatøren '*' returnerer den værdi, der er placeret på adressen, der gemmes i variablen efterfulgt af '*' -tegnet. Operatøren ‘&’ returnerer adressen på variablen efterfulgt af ‘&’ tegnet.
// for eksempel int b = 10 int a = & b; // Her gemmes adressen på b i variablen a. // lader adressen på b er 2000, så nu er = 2000. int c = * a; // Her vil heltalemarkørvariablen * a returnere den værdi, der er placeret på den adresse, der er gemt i en .ie. c = 10.
Der er kun to aritmetiske operatører, som du kan bruge til pointere, dvs. tilføjelse og subtraktion. Hvis du anvender inkrement på en heltal-pointervariabel, øges den med størrelsen på datatype, dvs. med 2 bytes, da det er en heltal-pointer, når den er steget, skal den pege på næste heltalvariabel. Det samme er tilfældet med dekrement.
// p er en heltal pointerindholdsværdi 2000. p ++; // nu p = 2002. P--; // nu p indeholder igen 2000 som dekrementeret af to bytes.
- En matrix gemmer variablerne af lignende datatyper, og datatyperne for variablerne skal svare til array-typen. På den anden side gemmer markørvariablen adressen til en variabel, af en type, der ligner en type pekervariabeltype.
- Vi kan generere en række pointere, dvs. array, hvis variabler er pointervariablerne. På den anden side kan vi oprette en markør, der peger på en matrix.
- Java understøtter matrix, men understøtter ikke pointer.
- En matrixstørrelse bestemmer antallet af variabler, den kan gemme, hvorimod; en markørvariabel kan gemme adressen på kun variablen
Bemærk:
Java understøtter ikke eller undgår strengt point.
Konklusion:
Når vi er nødt til at arbejde på dataelementer af lignende datatype, kan vi i stedet for at arbejde separat på variabler oprette en matrix af disse variabler af lignende datatyper og derefter arbejde på den. Pegere er nødvendige for noget program, det giver en enorm kraft, men desværre, hvis en markør indeholder en forkert værdi, vil det være den sværeste fejl at finde.
