Tablice w języku C/C++

Ogólna postać definicji tablicy:

typ_elementu    nazwa_tablicy [wymiar_1][wymiar_2] . . . [wymiar_N] ;

np.

              int  tablica [ 10 ];              // 10-cio elementowa tablica liczb całkowitych

              char tekst [ 255 ];              // 255-cio elementowa tablica znaków

              float macierz [ 5 ] [ 2 ];              // dwuwymiarowa tablica: 5 wierszy po 2 kolumny,

UWAGA:

Þ           w języku C tablice są zawsze indeksowane od zera
np. pierwszym elementem tablicy «macierz» jest:  macierz[ 0 ][ 0 ]

      a ostatnim elementem jest:              macierz[ wymiar_1 - 1 ][wymiar_2 - 1]
                     tzn.               macierz[ 4 ][ 1 ]

Þ w języku C nie jest sprawdzana zgodność indeksu z wymiarami tablicy !!!
często jest to przyczyną trudnych do wykrycia błędów.
np. odwołanie: macierz[ 1 ][ 2 ] zwróci w rzeczywistości wartość pierwszego elementu z trzeciego wiersza tzn. macierz[ 2 ][ 0 ]

reprezentacja tej macierzy  ¯  w pamięci komputera

              ­

              macierz[ 1 ][ 2 ]

Þ Obszar pamięci zajmowany przez tablicę musi być mniejszy od 64 kB

W implementacji C++ firmy Borland to ograniczenie można obejść używając przy definicji tablicy słowo kluczowe huge .
                            np. definicja:      long double huge tab[ 20000 ];
jest poprawna, chociaż tablica  «tab»  zajmuje 200 000 bajtów  »  196 kB

Definicję tablicy można połączyć z inicjacją jej zawartości:

                 int                            tab[ 10 ];                            // ¬ sama definicja bez inicjacji

                 int                            tab_inicjowana[ 10 ]   =              { 20, -3, 12, 1, 0, 7, -5, 100, 2, 5 }; 

              char                            tab_znakow[ 5 ]     =              { ‘a’,  ‘B’,  ‘\n’,  ‘1’,  ‘\0’ };

              float                            macierz_A[ 3 ][ 2 ]    =              {  {1,1},  {3.5,7.0},  {-15,100}  };

              float                            macierz_B[ 3 ][ 2 ]    =              {  1,  1,  3.5,  7.0,  -15,  100  };

Þ          Kolejne „inicjatory” zawsze wstawiane są do kolejnych „komórek” tablicy
(w związku z tym można pominąć wewnętrzne nawiasy klamrowe).

Þ          Jeżeli lista inicjatorów jest krótsza niż ilość elementów tablicy to pozostałe elementy są uzupełniane zerami lub wskaźnikami NULL

np.  definicja:

                                          int   tab[ 10 ]  =  { 20, -3, 12, 1 };

                            jest równoważna:

                                          int   tab[ 10 ]  =  { 20, -3, 12, 1, 0, 0, 0, 0, 0, 0 };

a definicja:

                                          float   macierz[ 3 ][ 2 ]  =  {  {1},  {3.5,7.0}  };

                            jest równoważna:

                                          float   macierz[ 3 ][ 2 ]  =  {  {1,0},  {3.5,7.0},  {0,0}  };

                            lub:

                                          float   macierz[ 3 ][ 2 ]  =  {  1,  0,  3.5,  7.0,  0,  0  };

Þ          W języku C inicjatorami muszą być stałe, natomiast w języku C++ inicjatorami mogą być zarówno stałe jak i zmienne.

Wykorzystanie stałych do definiowania ilości elementów tablicy:

              int   tablica [ 100 ] ;                                          // rozmiar zadany bezpośrednio

              #define  ROZMIAR  100              // definicja stałej w stylu języka C

              int   tablica [ ROZMIAR ] ;

              const    ROZMIAR_2 = 100 ;              // definicja stałej w stylu języka C++

              int   tablica_2 [ ROZMIAR_2 ] ;

              for( int i=0 ; i < ROZMIAR ; i++ )              // przykład dalszego wykorzystania stałej

                            printf ( ”%d” , tablica[ i ] );

Przypisywanie / odczytywanie wartości elementów tablicy

              void main( )

              {

                            const              ROZM = 4 ;             

                            int                            Tab [ ROZM ] ;

                            // bezpośrednie przypisanie wartości

                            Tab[ 0 ] = 0 ;

                            Tab[ 1 ] = 10 ;

                            Tab[ 2 ] = - 20 ;

                            Tab[ 3 ] = 3 ;

                            // wczytanie zawartości z klawiatury

                            scanf( ”%d” , &Tab[ 0 ] ) ;

                            scanf( ”%d %d” , &Tab[ 1 ] , &Tab[ 2 ] ) ;

                            printf( ” Podaj 4 element tablicy = ” );

                            scanf( ”%d” , &Tab[ 3 ] ) ;

                            // wykorzystywanie i wyświetlanie zawartości elementów tablicy

                            long suma = Tab[0] + Tab[1] + Tab[2] + Tab[3] ;

                            printf( ” Tab[1] = %5d ” , Tab[0] );

                            printf( ” Tab[2] = %5d ” , Tab[1] );

                            printf( ” Tab[3] = %5d ” , Tab[2] );

                            printf( ” Tab[4] = %5d ” , Tab[3] );

                            // pośrednie zadawanie wartości indeksu za pomocą zmiennej pomocniczej

                            int  i = 2 ;

                            Tab[ i ] = 10;                                             // równoważne poleceniu:   Tab[ 2 ] = 10;

                            // zadawanie indeksu elementu z klawiatury

                            printf( ” Podaj indeks elementu którego wartość chcesz wczytać ” );

                            scanf( ”%d” , &i );

              ...