W języku C++ tablica jest strukturą danych używaną do przechowywania wielu wartości podobnych typów danych w ciągłym miejscu w pamięci.

Na przykład , jeśli musimy przechowywać oceny 4 lub 5 uczniów, możemy je łatwo przechowywać, tworząc 5 różnych zmiennych, ale co jeśli chcemy przechowywać oceny 100 uczniów lub powiedzmy 500 uczniów, wówczas utworzenie takiej liczby zmiennych staje się bardzo trudne i zarządzaj nimi. Teraz na obrazku pojawiają się tablice, które można to łatwo zrobić, po prostu tworząc tablicę o wymaganym rozmiarze.

Właściwości tablic w C++

• Tablica to zbiór danych tego samego typu, przechowywany w ciągłym miejscu pamięci.
• Indeksowanie tablicy rozpoczyna się od 0. Oznacza to, że pierwszy element jest przechowywany pod indeksem 0, drugi pod indeksem 1 i tak dalej.
• Dostęp do elementów tablicy można uzyskać za pomocą ich indeksów.
• Po zadeklarowaniu tablicy jej rozmiar pozostaje stały w całym programie.
• Tablica może mieć wiele wymiarów.
• Rozmiar tablicy w bajtach można określić za pomocą operatora sizeof, za pomocą którego możemy również znaleźć liczbę elementów w tablicy.
• Rozmiar typu elementów przechowywanych w tablicy możemy znaleźć, odejmując sąsiednie adresy.

Deklaracja tablicy w C++

W C++ możemy zadeklarować tablicę, po prostu określając najpierw typ danych, a następnie nazwę tablicy wraz z jej rozmiarem.

data_type array_name[Size_of_array];>

Przykład

int arr[5];>

Tutaj,

• int: Jest to typ danych, które mają być przechowywane w tablicy. Możemy także używać innych typów danych, takich jak char, float i double.
• Arr: Jest to nazwa tablicy.
• 5: Jest to rozmiar tablicy, co oznacza, że ​​w tablicy można przechowywać tylko 5 elementów.

Inicjalizacja tablicy w C++

W C++ możemy inicjować tablicę na wiele sposobów, ale omówimy kilka najpopularniejszych sposobów inicjowania tablicy. Tablicę możemy zainicjować w momencie deklaracji lub po deklaracji.

1. Zainicjuj tablicę wartościami w C++

Zainicjowaliśmy tablicę wartościami. Do tablicy przypisane są wartości ujęte w nawiasy klamrowe „{}”. Tutaj 1 jest przechowywane w tablicy [0], 2 w tablicy [1] i tak dalej. Tutaj rozmiar tablicy wynosi 5.

int arr[5] = {1, 2, 3, 4, 5};>

2. Zainicjuj tablicę z wartościami i bez rozmiaru w C++

Zainicjowaliśmy tablicę wartościami, ale nie zadeklarowaliśmy długości tablicy, dlatego długość tablicy jest równa liczbie elementów zawartych w nawiasach klamrowych.

Funkcja prototypowa w C++

int arr[] = {1, 2, 3, 4, 5};>

3. Zainicjuj tablicę po deklaracji (przy użyciu pętli)

Zainicjowaliśmy tablicę za pomocą pętli po zadeklarowaniu tablicy. Metodę tę stosuje się zwykle wtedy, gdy chcemy pobrać dane od użytkownika lub nie możemy przypisać elementów jeden po drugim do każdego indeksu tablicy. Możemy modyfikować warunki pętli lub zmieniać wartości inicjujące zgodnie z wymaganiami.

for (int i = 0; i   arr[i] = value; }>

4. Zainicjuj tablicę częściowo w C++

Tutaj zadeklarowaliśmy tablicę „partialArray” o rozmiarze „5” i tylko o wartościach „1” i „2”. Zatem wartości te są przechowywane przy pierwszych dwóch indeksach, a przy pozostałych indeksach przechowywane jest „0”.

int partialArray[5] = {1, 2};>

5. Zainicjuj tablicę zerem w C++

Możemy zainicjować tablicę ze wszystkimi elementami jako „0”, podając „0” w nawiasach klamrowych. Stanie się to w przypadku zera tylko wtedy, gdy spróbujemy zainicjować tablicę inną wartością, powiedzmy „2”, używając tej metody, wtedy „2” zostanie zapisane tylko w indeksie 0.

int zero_array[5] = {0};>

Dostęp do elementu tablicy w C++

Dostęp do elementów tablicy można uzyskać podając nazwę tablicy, a następnie indeks elementu zawartego w operatorze indeksu dolnego tablicy []. Na przykład arr[i].

Przykład 1: Program w C++ ilustrujący sposób uzyskiwania dostępu do elementów tablicy

// C++ Program to Illustrate How to Access Array Elements #include  using namespace std; int main() {  int arr[3];  // Inserting elements in an array  arr[0] = 10;  arr[1] = 20;  arr[2] = 30;  // Accessing and printing elements of the array  cout << 'arr[0]: ' << arr[0] << endl;  cout << 'arr[1]: ' << arr[1] << endl;  cout << 'arr[2]: ' << arr[2] << endl;  return 0; }>

arr[0]: 10 arr[1]: 20 arr[2]: 30>

Zaktualizuj element tablicy

Aby zaktualizować element tablicy, możemy użyć indeksu, który chcemy zaktualizować, zawartego w operatorze indeksu dolnego tablicy i nadać mu nową wartość.

arr[i] = new_value;>

Przechodzenie przez tablicę w C++

Po tablicy możemy przechodzić za pomocą pętli przy użyciu indeksowania w C++. Najpierw zainicjowaliśmy tablicę „table_of_two” wielokrotnością 2. Następnie uruchamiamy pętlę for od 0 do 9, ponieważ indeksowanie tablicy rozpoczyna się od zera. Dlatego korzystając z indeksów wypisujemy wszystkie wartości zapisane w tablicy.

Przykład 2: Program w C++ ilustrujący sposób przechodzenia przez tablicę

// C++ Program to Illustrate How to Traverse an Array #include  using namespace std; int main() {  // Initialize the array  int table_of_two[10]  = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };  // Traverse the array using for loop  for (int i = 0; i < 10; i++) {  // Print the array elements using indexing  cout << table_of_two[i] << ' ';  }  return 0; }>

2 4 6 8 10 12 14 16 18 20>

Rozmiar tablicy w C++

W C++ nie mamy funkcji długości, jak w Javie, służącej do znajdowania rozmiaru tablicy, ale możemy obliczyć rozmiar tablicy za pomocą operatora sizeof(). sztuczka. Najpierw znajdujemy rozmiar zajmowany przez całą tablicę w pamięci, a następnie dzielimy go przez rozmiar typu elementu przechowywanego w tablicy. To da nam liczbę elementów przechowywanych w tablicy.

data_type size = sizeof(Array_name) / sizeof(Array_name[index]);>

Przykład 3: Program w C++ ilustrujący, jak znaleźć rozmiar tablicy

// C++ Program to Illustrate How to Find the Size of an // Array #include  using namespace std; int main() {  int arr[] = { 1, 2, 3, 4, 5 };  // Size of one element of an array  cout << 'Size of arr[0]: ' << sizeof(arr[0]) << endl;  // Size of array 'arr'  cout << 'Size of arr: ' << sizeof(arr) << endl;  // Length of an array  int n = sizeof(arr) / sizeof(arr[0]);  cout << 'Length of an array: ' << n << endl;  return 0; }>

Size of arr[0]: 4 Size of arr: 20 Length of an array: 5>

Relacja między tablicami i wskaźnikami w C++

W C++ tablice i wskaźniki są ze sobą ściśle powiązane. Nazwa tablicy traktowana jest jako wskaźnik przechowujący adres pamięci pierwszego elementu tablicy. Jak wspomnieliśmy wcześniej, elementy tablicy In są przechowywane w sąsiadujących miejscach pamięci, dlatego dostęp do wszystkich elementów tablicy możemy uzyskać za pomocą nazwy tablicy.

Przykład 4: Ilustrowanie związku między tablicą a wskaźnikami

// C++ Program to Illustrate that Array Name is a Pointer // that Points to First Element of the Array #include  using namespace std; int main() {  // Defining an array  int arr[] = { 1, 2, 3, 4 };  // Define a pointer  int* ptr = arr;  // Printing address of the arrary using array name  cout << 'Memory address of arr: ' << &arr << endl;  // Printing address of the array using ptr  cout << 'Memory address of arr: ' << ptr << endl;  return 0; }>

Memory address of arr: 0x7fff2f2cabb0 Memory address of arr: 0x7fff2f2cabb0>

Wyjaśnienie:

W powyższym kodzie najpierw definiujemy tablicę przyr a następnie zadeklaruj wskaźnik pt i przypisz do niego tablicę arr. Jesteśmy w stanie przypisać arr do ptr, ponieważ arr jest także wskaźnikiem. Następnie drukujemy adres pamięci przyr używając operatora odniesienia ( & ), a także wydrukuj adres zapisany we wskaźniku pt i widzimy arr i ptr, oba przechowują ten sam adres pamięci.

Przykład 5: Drukowanie elementów tablicy bez indeksowania w C++

Zwykle uzyskujemy dostęp do elementów tablicy i drukujemy je za pomocą indeksowania. Na przykład, aby uzyskać dostęp do pierwszego elementu, którego używamy nazwa_tablicy[0]. Omówiliśmy powyżej, że nazwa tablicy jest wskaźnikiem przechowującym adres pierwszego elementu, a elementy tablicy są przechowywane w sąsiadujących lokalizacjach. Teraz będziemy uzyskać dostęp do elementów tablicy, używając wyłącznie nazwy tablicy.

// C++ Program to Print Array Elements without Indexing #include  using namespace std; int main() {  // Define an array  int arr[] = { 11, 22, 33, 44 };  // Print elements of an array  cout << 'first element: ' << *arr << endl;  cout << 'Second element: ' << *(arr + 1) << endl;  cout << 'Third element: ' << *(arr + 2) << endl;  cout << 'fourth element: ' << *(arr + 3) << endl;  return 0; }>

first element: 11 Second element: 22 Third element: 33 fourth element: 44>

Wyjaśnienie

W powyższym kodzie najpierw zadeklarowaliśmy tablicę przyr z czterema elementami. Następnie drukujemy elementy tablicy. Porozmawiajmy o tym, jak to robimy. Omówiliśmy, że nazwa tablicy jest wskaźnikiem przechowującym adres pierwszego elementu tablicy, więc aby wydrukować pierwszy element, wyłuskaliśmy ten wskaźnik (*arr) za pomocą operatora dereferencji (*) który drukuje dane przechowywane pod tym adresem.

Aby wydrukować drugi element tablicy, najpierw dodajemy 1 Do przyr co jest równoważne (adres tablicy + rozmiar_jednego_elementu *1), który przenosi wskaźnik do adresu tuż za pierwszym, a następnie usuwamy referencję do tego wskaźnika, aby wydrukować drugi element. Podobnie wypisujemy resztę elementów tablicy bez użycia indeksowania.

Przekazywanie tablicy do funkcji w C++

Aby efektywnie używać tablic, powinniśmy wiedzieć, jak przekazywać tablice do funkcji. Możemy przekazywać tablice do funkcji jako argument w taki sam sposób, w jaki przekazujemy zmienne do funkcji, ale wiemy, że przy użyciu tej koncepcji nazwa tablicy jest traktowana jako wskaźnik. Możemy przekazać tablicę do funkcji jako argument, a następnie uzyskać dostęp do wszystkich elementów tej tablicy za pomocą wskaźnik.

Więc ostatecznie tablice są zawsze przekazywane jako wskaźniki do funkcji. Przyjrzyjmy się 3 sposobom przekazania tablicy do najczęściej używanej funkcji.

1. Przekazywanie tablicy jako wskaźnika

W tej metodzie po prostu przekazujemy nazwę tablicy w wywołaniu funkcji, co oznacza, że ​​przekazujemy adres do pierwszego elementu tablicy. W tej metodzie możemy modyfikować elementy tablicy w ramach funkcji.

Składnia

return_type   function_name   (   data_type *array_name   ) {     // set of statements  }>

2. Przekazywanie tablicy jako tablicy o niewymiarowym rozmiarze

W tej metodzie funkcja akceptuje tablicę za pomocą prostej deklaracji tablicy bez rozmiaru jako argumentu.

Składnia

return_type   function_name    ( data_type array_name[]   ) {    // set of statements  }>

3. Przekazywanie tablicy jako tablicy o określonym rozmiarze

W tej metodzie funkcja akceptuje tablicę za pomocą prostej deklaracji tablicy z argumentem size. Używamy tej metody, ustalając rozmiar tablicy tylko po to, aby wskazać rozmiar tablicy.

Składnia

return_type function_name(data_type array_name[size_of_array]){  // set of statements }>

Notatka: Tablica będzie traktowana jako wskaźnik w przekazanej funkcji bez względu na to, jakiej metody użyjemy. Gdy tablica będzie przekazywana jako wskaźniki, utracą one informacje o jej rozmiarze, co doprowadzi do zjawiska zwanego as Rozpad układu.

Przykład: ilustrowanie różnych sposobów przekazywania tablic do funkcji

#include  using namespace std; // passing array as a sized array argument void printArraySized(int arr[3], int n) {  cout << 'Array as Sized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << arr[i] << ' ';  }  cout << endl; } // passing array as an unsized array argument void printArrayUnsized(int arr[], int n) {  cout << 'Array as Unsized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << *(arr + i) << ' ';  }  cout << endl; } // Passing array as a pointer argument void printArrayPointer(int* ptr, int n) {  // Print array elements using pointer ptr  // that store the address of array passed  cout << 'Array as Pointer Argument: ';  for (int i = 0; i < n; i++) {  cout << ptr[i] << ' ';  } } // driver code int main() {  int arr[] = { 10, 20, 30 };  // Call function printArray and pass  // array and its size to it.  printArraySized(arr, 3);  printArrayUnsized(arr, 3);  printArrayPointer(arr, 3);  return 0; }>

Array as Sized Array Argument: 10 20 30 Array as Unsized Array Argument: 10 20 30 Array as Pointer Argument: 10 20 30>

Tablice wielowymiarowe w C++

Tablice zadeklarowane z więcej niż jednym wymiarem nazywane są tablicami wielowymiarowymi. Najszerzej stosowanymi tablicami wielowymiarowymi są tablice 2D i tablice 3D. Tablice te są zazwyczaj reprezentowane w postaci wierszy i kolumn.

Deklaracja tablicy wielowymiarowej

Data_Type Array_Name[Size1][Size2]...[SizeN];>

Gdzie,

• Typ danych: Typ danych, które mają być przechowywane w tablicy.
• Nazwa_tablicy: Nazwa tablicy.
• Rozmiar1, Rozmiar2,…, RozmiarN: Rozmiar każdego wymiaru.

Tablica dwuwymiarowa w C++

W C++ tablica dwuwymiarowa to grupa elementów ułożonych w wiersze i kolumny. Dostęp do każdego elementu odbywa się za pomocą dwóch indeksów: jednego dla wiersza i jednego dla kolumny, co ułatwia wizualizację jako tabelę lub siatkę.

Składnia tablicy 2D

data_Type array_name[n][m];>

Gdzie,

• N: Liczba rzędów.
• M: Liczba kolumn.
  

Przykład: program C++ ilustrujący tablicę dwuwymiarową

// c++ program to illustrate the two dimensional array #include  using namespace std; int main() {  // Declaring 2D array  int arr[4][4];  // Initialize 2D array using loop  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  arr[i][j] = i + j;  }  }  // Printing the element of 2D array  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  cout << arr[i][j] << ' ';  }  cout << endl;  }  return 0; }>

0 1 2 3 1 2 3 4 2 3 4 5 3 4 5 6>

Wyjaśnienie

W powyższym kodzie zadeklarowaliśmy tablicę 2D z 4 wierszami i 4 kolumnami, a następnie inicjowaliśmy tablicę wartością (i+j) w każdej iteracji pętli. Następnie drukujemy tablicę 2D za pomocą zagnieżdżonej pętli, a na poniższym wyjściu widzimy, że są 4 wiersze i 4 kolumny.

Tablica trójwymiarowa w C++

Tablica 3D wykorzystuje trzy wymiary. Do jego przedstawienia można wykorzystać zbiór różnych dwuwymiarowych tablic ułożonych jedna na drugiej. Trzy indeksy — indeks wiersza, indeks kolumny i indeks głębokości służą do jednoznacznej identyfikacji każdego elementu w tablicy 3D.

Deklaracja tablicy trójwymiarowej w C++

Aby zadeklarować tablicę 3D w C++, musimy określić jej trzeci wymiar wraz z wymiarami 2D.

Data_Type Array_Name[D][R][C];>

Gdzie,

• Typ danych: Typ danych, które mają być przechowywane w każdym elemencie.
• Nazwa_tablicy: Nazwa tablicy
• D: Liczba tablic 2D lub głębokość szyku.
• R: Liczba wierszy w każdej tablicy 2D.
• C: Liczba kolumn w każdej tablicy 2D.

Przykład

int array[3][3][3];>

Przykład: program C++ do zilustrowania tablicy 3D

// C++ program to illustrate the 3d array #include  using namespace std; int main() {  // declaring 3d array  int arr[3][3][3];  // initializing the array  for (int i = 0; i < 3; i++) {  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  arr[i][j][k] = i + j + k;  }  }  }  // printing the array  for (int i = 0; i < 3; i++) {  cout << i << 'st layer:' << endl;  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  cout << arr[i][j][k] << ' ';  }  cout << endl;  }  cout << endl;  }  return 0; }>

0st layer: 0 1 2 1 2 3 2 3 4 1st layer: 1 2 3 2 3 4 3 4 5 2st layer: 2 3 4 3 4 5 4 5 6>

Wyjaśnienie

W powyższym kodzie zadeklarowaliśmy tablicę 3D, a następnie zainicjowaliśmy ją za pomocą trzech zagnieżdżonych pętli for. Następnie ponownie wydrukowaliśmy wszystkie warstwy tablicy 3D, używając trzech zagnieżdżonych pętli for, jak widać na wynikach.

Powiązane artykuły

• Tablice wielowymiarowe w C++
• Właściwości tablicy
• Rozpad układu