I C är en pekarmatris en homogen samling av indexerade pekarvariabler som är referenser till en minnesplats. Det används vanligtvis i C-programmering när vi vill peka på flera minnesplatser av en liknande datatyp i vårt C-program. Vi kan komma åt data genom att referera pekaren som pekar på den.
Exempel på json-format
Syntax:
pointer_type *array_name [array_size];>
Här,
- pointer_type: Typ av data som pekaren pekar på. array_name: Namn på arrayen av pekare. array_size: Storleken på arrayen av pekare.
Notera: Det är viktigt att komma ihåg operatörens företräde och associativitet i samlingen av pekaredeklarationer av olika slag, eftersom en enda förändring kommer att betyda en helt annan sak. Om du till exempel omger *array_name inom parentes kommer det att innebära att array_name är en pekare till en array.
Exempel:
C
// C program to demonstrate the use of array of pointers> #include> int> main()> {> >// declaring some temp variables> >int> var1 = 10;> >int> var2 = 20;> >int> var3 = 30;> >// array of pointers to integers> >int>* ptr_arr[3] = { &var1, &var2, &var3 };> >// traversing using loop> >for> (>int> i = 0; i <3; i++) {> >printf>(>'Value of var%d: %d Address: %p
'>, i + 1, *ptr_arr[i], ptr_arr[i]);> >}> >return> 0;> }> |
>
>Produktion
Value of var1: 10 Address: 0x7fff1ac82484 Value of var2: 20 Address: 0x7fff1ac82488 Value of var3: 30 Address: 0x7fff1ac8248c>
Förklaring:
Som visas i exemplet ovan är varje element i arrayen en pekare som pekar på ett heltal. Vi kan komma åt värdet på dessa heltal genom att först välja array-elementet och sedan välja bort det för att få värdet.
Array av pekare till karaktär
En av huvudapplikationerna för arrayen av pekare är att lagra flera strängar som en array av pekare till tecken. Här är varje pekare i arrayen en teckenpekare som pekar på det första tecknet i strängen.
Syntax:
char *array_name [array_size];>
Efter det kan vi tilldela en sträng av valfri längd till dessa pekare.
Exempel:
C
char>* arr[5]> >= {>'gfg'>,>'geek'>,>'Geek'>,>'Geeks'>,>'techcodeview.com'> }> |
>
>
Denna metod att lagra strängar har fördelen med den traditionella uppsättningen av strängar. Tänk på följande två exempel:
Exempel 1:
C
jframe
// C Program to print Array of strings without array of pointers> #include> int> main()> {> >char> str[3][10] = {>'Geek'>,>'Geeks'>,>'Geekfor'> };> >printf>(>'String array Elements are:
'>);> >for> (>int> i = 0; i <3; i++) {> >printf>(>'%s
'>, str[i]);> >}> >return> 0;> }> |
>
varför sträng oföränderlig i java
>Produktion
String array Elements are: Geek Geeks Geekfor>
I programmet ovan har vi deklarerat de 3 raderna och 10 kolumnerna i vår array av strängar. Men på grund av fördefiniering av storleken på uppsättningen av strängar ökar utrymmesförbrukningen för programmet om minnet inte används på rätt sätt eller lämnas oanvänt. Låt oss nu försöka lagra samma strängar i en rad pekare.
Exempel 2:
C
// C program to illustrate the use of array of pointers to> // characters> #include> int> main()> {> >char>* arr[3] = {>'geek'>,>'Geeks'>,>'Geeksfor'> };> >for> (>int> i = 0; i <3; i++) {> >printf>(>'%s
'>, arr[i]);> >}> >return> 0;> }> |
>
>Produktion
geek Geeks Geeksfor>
Här är det totala minnet som används det minne som krävs för att lagra strängarna och pekarna utan att lämna något tomt utrymme, vilket sparar mycket slöseri. Vi kan förstå detta med hjälp av bilden nedan.
Utrymmet som upptas av arrayen av pekare till tecken visas av fasta gröna block exklusive minnet som krävs för att lagra pekaren medan utrymmet som upptas av arrayen av strängar inkluderar både solida och ljusgröna block.
En rad pekare till olika typer
Vi kan inte bara definiera arrayen av pekare för grundläggande datatyper som int, char, float, etc. utan vi kan också definiera dem för härledda och användardefinierade datatyper som arrayer, strukturer etc. Låt oss överväga exemplet nedan där vi skapar en rad pekare som pekar på en funktion för att utföra de olika operationerna.
Exempel:
C
javascript kommentar
// C program to illustrate the use of array of pointers to> // function> #include> // some basic arithmetic operations> void> add(>int> a,>int> b) {> >printf>(>'Sum : %d
'>, a + b);> }> void> subtract(>int> a,>int> b) {> >printf>(>'Difference : %d
'>, a - b);> }> void> multiply(>int> a,>int> b) {> >printf>(>'Product : %d
'>, a * b);> }> void> divide(>int> a,>int> b) {> >printf>(>'Quotient : %d'>, a / b);> }> int> main() {> >int> x = 50, y = 5;> >// array of pointers to function of return type int> >void> (*arr[4])(>int>,>int>)> >= { &add, &subtract, &multiply, ÷ };> >for> (>int> i = 0; i <4; i++) {> >arr[i](x, y);> >}> >return> 0;> }> |
>
>Produktion
Sum : 55 Difference : 45 Product : 250 Quotient : 10>
Tillämpning av Array of Pointers
En rad pekare är användbar i ett brett spektrum av fall. Några av dessa applikationer listas nedan:
- Det används oftast för att lagra flera strängar.
- Det används också för att implementera LinkedHashMap i C och även i Chaining-tekniken för kollisionslösning i Hashing.
- Det används i sorteringsalgoritmer som hinksortering.
- Det kan användas med vilken pekare som helst så det är användbart när vi har separata deklarationer av flera enheter och vi vill lagra dem på en enda plats.
Nackdelar med Array of Pointers
Arrayen av pekare har också sin beskärda del av nackdelar och bör användas när fördelarna överväger nackdelarna. Några av nackdelarna med arrayen av pekare är:
- Högre minnesförbrukning: En array av pekare kräver mer minne jämfört med vanliga arrayer på grund av det extra utrymme som krävs för att lagra pekare. Komplexitet: En array av pekare kan vara komplex att använda jämfört med en enkel array. Benägna till buggar: När vi använder pekare kommer alla buggar som är associerade med pekare med så vi måste hantera dem försiktigt.
Relaterad artikel: Pekare till en matris | Array Pointer