C - Wskaźniki zastosowanie

W tym poście chciałbym przedstawić kilka krótki zastosowań wskaźników.

Poruszone zostaną następujące zagadnienia: przesłanie łańcucha znakowego do funkcji, przekazywanie wskaźnika do funkcji, przekazywanie tablicy oraz wskaźnika do tablicy do funkcji, zwracanie wskaźnika przez funkcje.

Łańcuch znaków do funkcji:

Przekazywanie łańcucha znakowego do funkcji, przepisywanie do do nowej tablicy oraz odwracanie podanego ciągu:

1. #include <stdio.h>
2. #include <stdint.h>
4. int main(void)
5. {
6.     void copyTwoStrings(uint8_t *toCopyTo, uint8_t *toCopyFrom);
7.     void reverseTwoStrings(uint8_t *stringToReverse, uint8_t *reversedString);
9.     uint8_t charTable[] = "abcdefghijklmnoprst";
10.     uint8_t charTable2[50];
12.     copyTwoStrings(charTable2, charTable);
13.     printf("Kopiowanie: %s\n", charTable2);
15.     copyTwoStrings(charTable2, (uint8_t*)"Znaki do skopiowania");
16.     printf("Kopiowanie: %s\n", charTable2);
18.     reverseTwoStrings(charTable2, charTable);
19.     printf("Odwrocenie: %s\n", charTable2);
21.     return 0;
22. }
24. void copyTwoStrings(uint8_t *toCopyTo, uint8_t *toCopyFrom)
25. {
26.     for ( ; *toCopyFrom != '\0'; toCopyFrom++, toCopyTo++ )
27.     {
28.             *toCopyTo = *toCopyFrom;
29.     }
31.     *toCopyTo = '\0';
32. }
34. void reverseTwoStrings(uint8_t *stringToReverse, uint8_t *reversedString)
35. {
36.     uint8_t length = strlen(stringToReverse)-1;
38.     for ( ; *stringToReverse != '\0'; length--, stringToReverse++)
39.     {
40.             *stringToReverse = *(reversedString+length);
41.     }
42.     *reversedString = '\0';
43. }

Funkcje zdeklarowane w programie posiadają dwa argumenty zdeklarowane jako wskaźniki. W pętlach for obu funkcji następuje przechodzenie po poszczególnych elementach. W pierwszej funkcji znaki są kopiowane do nowej tablicy, w drugiej następuje przechodzenie pomiędzy elementami najniższymi jednego ciągu, do których następuje przypisanie wartości od największej ciągu drugiego. Wyjście z pętli następuje po napotkaniu znaku null. Do nowego ciągu znaków jest on następnie dodawany po wyjściu z pętli.

W języku c deklarując łańcuch znaków w wywołaniu funkcji nie otrzymuje się konkretnie tego łańcucha tylko wskaźnik na niego.

Przekazywanie wskaźników do funkcji:

Poniżej krótki program, który będzie przekazywał wskaźnik do zdefiniowanej wartości do funkcji. W niej nastąpi modyfikacja tej wartości:

1. #include <stdio.h>
2. #include <stdint.h>
4. void passPointerToFunction(uint8_t *pointerToValue)
5. {
6.     *pointerToValue +=50;   //Modyfikacja przekazanej wartości
7. }
8. int main (void)
9. {
10.     void test (uint8_t *pointerToValue);
11.     uint8_t  value = 50;
12.     uint8_t *pointer = &value;
14.     printf("Przed funckja value = %u\n", value);
16.     passPointerToFunction(pointer);
17.     printf("Po pierwszym wywołaniu value = %u\n", value);
19.     passPointerToFunction(&value);
20.     printf("Po drugim wywołaniu value = %u\n", value);
22.     return 0;
23. }

Do funkcji przekazywany jest wskaźnik przez jego osobne zdeklarowanie bądź przez przekazanie adresu bezpośrednio do funkcji.

Przekazywanie tablicy do funkcji:

Poniżej przedstawię dwie funkcje których zadaniem będzie sumowanie elementów zdeklarowanych w tablicy. Jedna z nich będzie przekazywała tablicę, druga natomiast wskaźnik na tą tablicę. Obie będzie operowały na wskaźnikach:

1. #include <stdio.h>
2. #include <stdint.h>
4. uint8_t sumPassArray(uint8_t arrayOfNumbers[], const uint8_t endNumber)
5. {
6.     uint8_t  sum = 0;        //Suma
7.     uint8_t  *tmpPointer;    //Wskaznik
9.     uint8_t  * const endOfArray = arrayOfNumbers + endNumber;  //Długość tablicy
11.     for(tmpPointer=arrayOfNumbers; tmpPointer<endOfArray; tmpPointer++) //Przejście po każdym elemencie, zwiększanie wskaźnika
12.     {
13.         sum += *tmpPointer;
14.     }
16.     return sum;
17. }
19. uint8_t sumPassArrayPointer(uint8_t *arrayOfNumbers, const uint8_t endNumber)
20. {
21.     uint8_t  sum = 0;
22.     uint8_t  * const endOfArray = arrayOfNumbers + endNumber;
24.     for (; arrayOfNumbers<endOfArray; ++arrayOfNumbers)
25.     {
26.         sum += *arrayOfNumbers;
27.     }
28.     return sum;
29. }
31. int main (void)
32. {
33.     uint8_t  sumPassArray(uint8_t arrayOfNumbers[], const uint8_t n);
34.     uint8_t  sumPassArrayPointer(uint8_t *array, const uint8_t n);
36.     uint8_t  valuesToPass[15] = {3, 7, 5, 3, 6, 1, 7, 9, 1, 0, 20, 3, 94, 56, 22};
38.     uint8_t len = sizeof(valuesToPass) / sizeof(valuesToPass[0]);
40.     printf("Wielkość tablicy: %u\n", len);
42.     printf("Suma valuesToPass: %u\n", sumPassArray(valuesToPass, len));
43.     printf("Suma sumPassArrayPointer: %u\n", sumPassArrayPointer(valuesToPass, len));
45.     return 0;
46. }

Powyżej przygotowane są dwie funkcje, których zadaniem jest zsumowanie wartości podanych w tablicy. Do funkcji przekazywana jest jej długość oraz sama tablica. W pierwszej funkcji tablica jest przypisana do wskaźnika, po czym na tym wskaźniku wykonywane są operacje, a dokładniej przechodzenie do następnego elementu poprzez zwiększenie wskaźnika. Jest to rozwiązanie szybsze niż przechodzenie po poszczególnych elementach tablicy bezpośrednio.

Druga funkcja też otrzymuje tablice, tylko tym razem rozpatrywane jest to jako sam wskaźnik, dzięki temu pomija się deklarację dodatkowego wskaźnika.

Zwracanie wskaźnika przez funkcje:

Zwracanie wskaźnika następuje w normalny sposób tak jak przy zwracaniu normalnej wartości:

1. #include <stdio.h>
2. #include <stdint.h>
4. uint8_t passPointerToFunction(uint8_t *pointerToValue)
5. {
6.     *pointerToValue +=50;   //Modyfikacja przekazanej wartości
8.     return *pointerToValue;
9. }
11. int main (void)
12. {
13.     void test (uint8_t *pointerToValue);
14.     uint8_t  value = 50;
15.     uint8_t returnValue = 0;
16.     uint8_t *pointer = &value;
18.     printf("Przed funckja value = %u\n", value);
20.     returnValue = passPointerToFunction(pointer);
21.     printf("returnValue = %u, value %u\n", returnValue, value);
23.     return 0;
24. }

Można to wykonać także przez deklarację wskaźnika lokalnie w funkcji. Należy przy tym pamiętać, że ta zmienna jest tracona, chyba, że zostanie zdefiniowana jako statyczna