4.1 Οι πίνακες στη γλώσσα C++

Οι πίνακες στη γλώσσα C++ είναι μια δομή δεδομένων που μας επιτρέπει να αποθηκεύουμε και να διαχειριζόμαστε ομαδικά πολλές τιμές του ίδιου τύπου. Ένας πίνακας αποτελείται από μια σειρά στοιχείων που μπορούν να προσπελαστούν με τη χρήση ενός δείκτη και ενός ευρετηρίου

Για να δηλώσετε έναν πίνακα, πρέπει να καθορίσετε τον τύπο της μεταβλητής που θα αποθηκεύσει τον πίνακα, να δώσετε ένα όνομα στον πίνακα, ακολουθούμενο από αγκύλες, και να καθορίσετε τον αριθμό των στοιχείων που θα αποθηκεύονται στον πίνακα.

Σύνταξη:

type arrayName[ arraySize ];

Παράδειγμα:

#include <iostream>
using namespace std;

int main() {
   int myNumbers[5] = {1, 2, 3, 4, 5}; // Δήλωση πίνακα myNumbers με 5 στοιχεία
   cout << myNumbers[0] << endl; // Εκτύπωση του πρώτου στοιχείου του πίνακα
   return 0;
}

Ο παραπάνω κώδικας εκτυπώνει το πρώτο στοιχείο του πίνακα myNumbers. Αρχικά, δημιουργείται ο πίνακας myNumbers με πέντε στοιχεία, οι τιμές των οποίων είναι 1, 2, 3, 4 και 5. Στη συνέχεια, με τη χρήση της εντολής cout, το πρώτο στοιχείο του πίνακα (myNumbers[0]) εκτυπώνεται στην οθόνη.

Αν τρέξετε τον παραπάνω κώδικα, θα δείτε ότι εκτυπώνεται ο αριθμός 1, καθώς αναφερόμαστε στο πρώτο στοιχείο του πίνακα myNumbers με τη χρήση της δείκτης [0]. Η έξοδος του προγράμματος θα είναι:

1

Τέλος, η συνάρτηση main επιστρέφει την τιμή 0, υποδεικνύοντας ότι το πρόγραμμα ολοκληρώθηκε με επιτυχία.

Παράδειγμα

#include <iostream>
#include <string>

int main() {
  std::string myArray[4] = {"apple", "banana", "orange", "grape"};
  std::cout << myArray[0] << std::endl; // Εκτύπωση του πρώτου στοιχείου, που είναι "apple"

  return 0;
}

Ο παραπάνω κώδικας στη γλώσσα C++ περιλαμβάνει τις εξής λειτουργίες:

1. Ορίζει τη βιβλιοθήκη iostream, που παρέχει τις δυνατότητες εισόδου/εξόδου στο πρόγραμμα.
2. Ορίζει τη βιβλιοθήκη string, που παρέχει τις λειτουργίες για την εργασία με αλφαριθμητικά.
3. Ορίζει τη συνάρτηση main(), η οποία είναι η κύρια συνάρτηση του προγράμματος και εκτελείται αυτόματα κατά την εκτέλεση του προγράμματος.
4. Δημιουργεί έναν πίνακα myArray με τύπο στοιχείων string και μέγεθος 4, που περιέχει τις τέσσερις λέξεις “apple”, “banana”, “orange”, “grape”.
5. Χρησιμοποιεί το αντικείμενο std::cout για να εκτυπώσει το πρώτο στοιχείο του πίνακα myArray, που είναι η λέξη “apple”.
6. Η εντολή std::endl χρησιμοποιείται για να προσθέσει έναν χαρακτήρα νέας γραμμής μετά την εκτύπωση του πρώτου στοιχείου.

Συνολικά, ο κώδικας εκτυπώνει τη λέξη “apple” στην έξοδο της κονσόλας.

ειγμα, δημιουργούμε έναν πίνακα από τρεις ακέραιους αριθμούς με το όνομα myArray. Οι τιμές του πίνακα είναι 1, 2 και 3. Ο πίνακας αρχικοποιείται με τις τιμές αυτές κατά τη δήλωση του.

[adinserter block=”2″]

Μπορείτε να αποκτήσετε πρόσβαση στα στοιχεία του πίνακα χρησιμοποιώντας τον αριθμό της θέσης του στοιχείου στον πίνακα, ξεκινώντας από το 0. Για παράδειγμα, το πρώτο στοιχείο του πίνακα myArray θα είναι το myArray[0], το δεύτερο θα είναι το myArray[1] και το τρίτο θα είναι το myArray[2].

To αποκτάτε πρόσβαση σε ένα στοιχείο ενός πίνακα αναφέρεστε στον αριθμό της θέσης του στοιχείου μέσα σε αγκύλες [].

Η παρακάτω εντολή αποκτά πρόσβαση στην τιμή του πρώτου στοιχείου του πίνακα numbers:

int numbers[5] = {42, 7, 13, 0, -8};
int firstElement = numbers[0]; // η firstElement θα έχει την τιμή 42

Εδώ, δημιουργούμε έναν πίνακα από πέντε ακέραιους αριθμούς με το όνομα numbers. Το πρώτο στοιχείο του πίνακα έχει την τιμή 42. Στη συνέχεια, δημιουργούμε μια μεταβλητή firstElement που αναφέρεται στην τιμή του πρώτου στοιχείου του πίνακα, χρησιμοποιώντας την παραπάνω σύνταξη.

Για να αλλάξετε την τιμή ενός συγκεκριμένου στοιχείου του πίνακα, αναφερθείτε στον αριθμό της θέσης του στοιχείου:

int numbers[5] = {42, 7, 13, 0, -8};
numbers[2] = 100; // η τιμή του τρίτου στοιχείου του πίνακα τώρα είναι 100

Εδώ, δημιουργούμε έναν πίνακα από πέντε ακέραιους αριθμούς με το όνομα numbers. Η τιμή του τρίτου στοιχείου του πίνακα είναι 13. Στη συνέχεια, αλλάζουμε την τιμή του τρίτου στοιχείου του πίνακα σε 100, χρησιμοποιώντας την παραπάνω σύνταξη. Η νέα τιμή του τρίτου στοιχείου είναι τώρα 100.

Μπορείτε να επαναλάβετε τα στοιχεία του πίνακα χρησιμοποιώντας τη δομή επανάληψης for.

Το παρακάτω παράδειγμα εξάγει όλα τα στοιχεία του πίνακα PC CPU:

#include <iostream>

int main() {
  // Δημιουργία ενός πίνακα strings με τις ονομασίες των επεξεργαστών
  std::string cpu[3] = {"Intel Core i7", "AMD Ryzen 9", "Apple M1"};

  // Εκτύπωση των ονομασιών των επεξεργαστών
  for (int i = 0; i < 3; i++) {
    std::cout << cpu[i] << std::endl;
  }

  return 0;
}

Ο παραπάνω κώδικας εκτελεί τις ακόλουθες ενέργειες:

1. Δημιουργεί έναν πίνακα με τρία στοιχεία τύπου std::string με τις ονομασίες τριών διαφορετικών επεξεργαστών: “Intel Core i7”, “AMD Ryzen 9” και “Apple M1”.
2. Χρησιμοποιώντας έναν βρόχο for, εκτυπώνει τα στοιχεία του πίνακα cpu[] μία φορά για κάθε στοιχείο. Η εντολή std::cout << cpu[i] << std::endl; εκτυπώνει την τρέχουσα τιμή του πίνακα cpu[] και προσθέτει έναν χαρακτήρα νέας γραμμής για κάθε εκτύπωση.
3. Επιστρέφει την τιμή 0 από τη συνάρτηση main(), υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε με επιτυχία.

Συνολικά, ο κώδικας εκτυπώνει τις ονομασίες τριών διαφορετικών επεξεργαστών στην έξοδο του προγράμματος.

Έξοδος:

Intel Core i7
AMD Ryzen 9
Apple M1

Αυτό το παράδειγμα εξάγει τον δείκτη κάθε στοιχείου μαζί με την τιμή του:

#include <iostream>

int main() {
  int numbers[5] = {42, 7, 13, 0, -8};

  for (int i = 0; i < 5; i++) {
    // Εκτύπωση του στοιχείου και της αντίστοιχης τιμής
    std::cout << "Element " << i << " has value: " << numbers[i] << std::endl;
  }

  return 0;
}

Ο παραπάνω κώδικας εκτυπώνει τα στοιχεία ενός πίνακα στην οθόνη. Αρχικά, ορίζεται ένας πίνακας με όνομα “numbers” που περιλαμβάνει 5 ακέραιες τιμές. Έπειτα, μέσω ενός βρόχου “for”, εκτυπώνονται τα στοιχεία του πίνακα.

Κατά τη διάρκεια του βρόχου, η εντολή std::cout << "Element " << i << " has value: " << numbers[i] << std::endl; χρησιμοποιείται για να εκτυπωθεί το κείμενο “Element ” ακολουθούμενο από τον δείκτη “i”, το κείμενο ” has value: ” και την τιμή του στοιχείου του πίνακα με δείκτη “i” (δηλαδή τον αριθμό που αντιστοιχεί στη θέση “i” του πίνακα). Η std::endl χρησιμοποιείται για να προκαλέσει μια αλλαγή γραμμής μετά την εκτύπωση του στοιχείου.

Έτσι, κατά την εκτέλεση του κώδικα, τα στοιχεία του πίνακα θα εκτυπώνονται σε μια νέα γραμμή, κάθε στοιχείο ανά γραμμή, με τη μορφή “Element i has value: number[i]”. Η μεταβλητή “i” αυξάνεται κατά ένα σε κάθε επανάληψη του βρόχου, εξασφαλίζοντας έτσι την πρόσβαση σε κάθε στοιχείο του πίνακα.

Έξοδος:

Element 0 has value: 42
Element 1 has value: 7
Element 2 has value: 13
Element 3 has value: 0
Element 4 has value: -8

[adinserter block=”3″]

Αυτό το παράδειγμα δείχνει πώς μπορείτε να προπελάσετε έναν πίνακα από ακέραιους αριθμούς:

#include <iostream>

int main() {
  int myArray[] = {2, 4, 6, 8, 10}; // Δημιουργία πίνακα με 5 ακεραίες τιμές

  for (int i = 0; i < 5; i++) {
    std::cout << myArray[i] << std::endl; // Εκτύπωση του i-οστού στοιχείου του πίνακα
  }

  return 0;
}

Ο παραπάνω κώδικας εκτελεί την ακόλουθη λειτουργία:

1. Δημιουργεί έναν πίνακα myArray που περιέχει τις τιμές {2, 4, 6, 8, 10}. Ο πίνακας αυτός περιέχει 5 ακέραιες τιμές.
2. Χρησιμοποιεί μια δομή επανάληψης for για να εκτελέσει μια ενέργεια για κάθε στοιχείο του πίνακα. Η επανάληψη ξεκινάει από τον δείκτη i με αρχική τιμή 0 και εκτελείται όσο ο δείκτης i είναι μικρότερος από 5.
3. Μέσα στην επανάληψη, εκτυπώνει το στοιχείο του πίνακα myArray[i] χρησιμοποιώντας τη συνάρτηση std::cout. Έπειτα, προσθέτει έναν χαρακτήρα νέας γραμμής std::endl για να προχωρήσει στην επόμενη γραμμή εξόδου.
4. Ο κώδικας ολοκληρώνεται με την επιστροφή της τιμής 0 από τη συνάρτηση main, υποδεικνύοντας ότι το πρόγραμμα ολοκληρώθηκε χωρίς σφάλματα.

Έξοδος:

2
4
6
8
10

Υπάρχει επίσης ένας “for-each loop” (εισήχθη στην έκδοση C++11 (2011)), ο οποίος χρησιμοποιείται αποκλειστικά για να προσπελάσει τα στοιχεία ενός πίνακα:

#include <iostream>

int main() {
  int myArray[] = {2, 4, 6, 8, 10}; // Δήλωση ενός πίνακα με 5 ακέραιες τιμές

  for (int x : myArray) { // Επανάληψη για κάθε στοιχείο x στον πίνακα myArray
    std::cout << x << std::endl; // Εκτύπωση της τιμής του στοιχείου x στην οθόνη
  }

  return 0; // Επιστροφή της τιμής 0 ως ένδειξη επιτυχούς ολοκλήρωσης του προγράμματος
}

Ο παραπάνω κώδικας εκτελεί τις ακόλουθες λειτουργίες:

1. Ορίζει έναν πίνακα με όνομα myArray που περιλαμβάνει τις τιμές {2, 4, 6, 8, 10}.
2. Χρησιμοποιεί τη δομή επανάληψης for-each για να επαναλάβει μέσα από τον πίνακα.
3. Κατά τη διάρκεια κάθε επανάληψης, αντιστοιχεί την τιμή του τρέχοντος στοιχείου στη μεταβλητή x.
4. Εντός του βρόχου εκτελεί μια εντολή που εκτυπώνει την τιμή του x στην οθόνη, ακολουθούμενη από έναν χαρακτήρα νέας γραμμής.
5. Ο κώδικας επιστρέφει την τιμή 0, υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε με επιτυχία.

Συνολικά, ο κώδικας εκτυπώνει τα στοιχεία του πίνακα myArray στη σειρά στην οθόνη. Στην περίπτωση αυτή, θα εμφανιστούν οι αριθμοί 2, 4, 6, 8 και 10, καθένας σε μια νέα γραμμή.

Έξοδος:

2
4
6
8
10

Στη C++, δεν απαιτείται να καθορίσετε το μέγεθος του πίνακα εξαρχής. Ο μεταγλωττιστής μπορεί να αποφασίσει το μέγεθος του πίνακα βάσει του αριθμού των δεδομένων που εισάγονται:

int myArray[] = {1, 2, 3, 4, 5}; // ο μεταγλωττιστής υπολογίζει αυτόματα το μέγεθος του πίνακα

Σε αυτήν την περίπτωση, ο μεταγλωττιστής θα δεσμεύσει τον απαιτούμενο χώρο μνήμης για έναν πίνακα με 5 στοιχεία (τα 1, 2, 3, 4, 5). Αυτό επιτρέπει την ευκολότερη δήλωση και αρχικοποίηση των πινάκων, καθώς δεν χρειάζεται να γνωρίζουμε εκ των προτέρων το μέγεθός τους.

Αξίζει να σημειωθεί ότι αυτή η σύνταξη είναι διαθέσιμη μόνο στη C++ και όχι στην αρχική γλώσσα C.

[adinserter block=”4″]

Είναι επίσης δυνατόν να δηλωθεί ένας πίνακας χωρίς να καθοριστούν τα στοιχεία του κατά τη δήλωση και να προστεθούν αργότερα:

int my_array[5];
my_array[0] = 10;
my_array[1] = 20;
my_array[2] = 30;
my_array[3] = 40;
my_array[4] = 50;

Στο παραπάνω παράδειγμα, δηλώνουμε έναν πίνακα my_array με πέντε στοιχεία, αλλά δεν ορίζουμε ακόμη τα στοιχεία του κατά τη δήλωση. Στη συνέχεια, προσθέτουμε τις τιμές 10, 20, 30, 40 και 50 στις αντίστοιχες θέσεις του πίνακα χρησιμοποιώντας τον τελεστή δείκτη [ ].

Είναι σημαντικό να σημειωθεί ότι, όταν χρησιμοποιείτε αυτήν την τεχνική, πρέπει να έχετε προσέξει ώστε να μην ξεπεραστεί το μέγεθος του πίνακα ή να αφήσετε κενά στοιχεία που δεν έχουν αρχικοποιηθεί.

Για να ανακτήσετε το μέγεθος ενός πίνακα στη γλώσσα C++, μπορείτε να χρησιμοποιήσετε τον τελεστή sizeof(). Ο τελεστής sizeof() επιστρέφει τον αριθμό των bytes που απαιτούνται για να αποθηκευτούν όλα τα στοιχεία του πίνακα.

Παρακάτω παραθέτω ένα ολοκληρωμένο παράδειγμα στη γλώσσα C++ για τον υπολογισμό του μεγέθους ενός πίνακα χρησιμοποιώντας τον τελεστή sizeof():

#include <iostream>

int main() {
  int numbers[] = {1, 2, 3, 4, 5}; // Ορισμός πίνακα numbers με ακέραιες τιμές
  int size = sizeof(numbers) / sizeof(numbers[0]); // Υπολογισμός του μεγέθους του πίνακα

  std::cout << "Το μέγεθος του πίνακα είναι: " << size << std::endl; // Εκτύπωση του μεγέθους του πίνακα

  return 0;
}

Σε αυτό το παράδειγμα, δημιουργούμε έναν πίνακα numbers με πέντε ακέραιες τιμές. Στη συνέχεια, υπολογίζουμε το μέγεθος του πίνακα χρησιμοποιώντας τον τελεστή sizeof(). Προκειμένου να πάρουμε τον αριθμό των στοιχείων του πίνακα, διαιρούμε το μέγεθος του πίνακα με το μέγεθος ενός στοιχείου του πίνακα (sizeof(numbers[0])). Το αποτέλεσμα αποθηκεύεται στη μεταβλητή size. Τέλος, εκτυπώνουμε το μέγεθος του πίνακα στην οθόνη.

Το παρακάτω παράδειγμα κώδικα χρησιμοποιεί τη συνάρτηση sizeof() για την επανάληψη μέσω των στοιχείων ενός πίνακα:

#include <iostream>

int main() {
  int numbers[] = {1, 2, 3, 4, 5}; // Ορισμός πίνακα numbers με ακέραιες τιμές
  int size = sizeof(numbers) / sizeof(numbers[0]); // Υπολογισμός του μεγέθους του πίνακα

  for (int i = 0; i < size; i++) { // Επανάληψη μέσω των στοιχείων του πίνακα
    std::cout << numbers[i] << " "; // Εκτύπωση του τρέχοντος στοιχείου
  }
  std::cout << std::endl; // Αλλαγή γραμμής μετά την εκτύπωση όλων των στοιχείων

  return 0;
}

Στο παραπάνω παράδειγμα, ο πίνακας numbers δημιουργείται με ακέραιες τιμές. Χρησιμοποιώντας την sizeof() συνάρτηση, υπολογίζουμε το μέγεθος του πίνακα σε bytes και το διαιρούμε με το μέγεθος ενός στοιχείου του πίνακα για να πάρουμε τον αριθμό των στοιχείων του. Το μέγεθος αποθηκεύεται στη μεταβλητή size.

Στη συνέχεια, χρησιμοποιούμε μια for επανάληψη για να περάσουμε από κάθε στοιχείο του πίνακα. Στο εσωτερικό της επανάληψης, το τρέχον στοιχείο εκτυπώνεται χρησιμοποιώντας την

std::cout. Έπειτα, μετά την ολοκλήρωση της επανάληψης, εκτυπώνεται ένα κενό διάστημα για να αλλάξει η γραμμή και τα στοιχεία να εμφανίζονται οριζόντια.

Στην έκδοση C++ 11 (2011), προστέθηκε η δυνατότητα χρήσης της “for-each” εντολής (ή range-based for loop) για την επανάληψη μέσω των στοιχείων ενός πίνακα ή ενός εύρους τιμών. Η σύνταξη της “for-each” είναι η εξής:

for (type variable : collection) {
    // Κώδικας που εκτελείται για κάθε στοιχείο
}

Ο τύπος (type) πρέπει να είναι ο τύπος δεδομένων των στοιχείων στη συλλογή, η μεταβλητή (variable) είναι η μεταβλητή που αντιστοιχεί σε κάθε στοιχείο και η συλλογή (collection) είναι ο πίνακας ή το εύρος τιμών που επιθυμούμε να επαναλάβουμε.

Έτσι, για παράδειγμα, μπορούμε να τροποποιήσουμε το προηγούμενο παράδειγμα κώδικα χρησιμοποιώντας την “for-each” εντολή ως εξής:

#include <iostream>

int main() {
  int numbers[] = {1, 2, 3, 4, 5};  // Δημιουργία ενός πίνακα με ακέραιους αριθμούς

  for (int number : numbers) {  // Επανάληψη για κάθε αριθμό στον πίνακα
    std::cout << number << " ";  // Εκτύπωση του αριθμού
  }
  std::cout << std::endl;  // Εκτύπωση νέας γραμμής

  return 0;
}

Η “for-each” εντολή επιτρέπει την απλοποίηση της σύνταξης και τη βελτίωση της αναγνωσιμότητας του κώδικα όταν επαναλαμβάνουμε μέσω των στοιχείων ενός πίνακα ή ενός εύρους τιμών.

Οι πολυδιάστατοι πίνακες στη C++ είναι πίνακες που αποτελούνται από πίνακες.

Για να δηλώσετε έναν πολυδιάστατο πίνακα, πρέπει να καθορίσετε τον τύπο των στοιχείων του πίνακα, να δώσετε ένα όνομα για τον πίνακα και να χρησιμοποιήσετε αγκύλες για να καθορίσετε τον αριθμό των στοιχείων που έχει ο κύριος πίνακας. Στη συνέχεια, ακολουθούν ακόμη μία ή περισσότερες σειρές αγκυλών που καθορίζουν τον αριθμό των στοιχείων που έχει κάθε υποπίνακας

Ας δούμε ένα παράδειγμα πολυδιάστατου πίνακα στη C++:

#include <iostream>

int main() {
  int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
  };

  // Εκτύπωση του πίνακα
  for (int i = 0; i < 3; i++) { // Επανάληψη για τις γραμμές του πίνακα
    for (int j = 0; j < 3; j++) { // Επανάληψη για τις στήλες του πίνακα
      std::cout << matrix[i][j] << " "; // Εκτύπωση του στοιχείου στη θέση [i][j] του πίνακα
    }
    std::cout << std::endl; // Αλλαγή γραμμής μετά από κάθε γραμμή του πίνακα
  }

  return 0;
}

Σε αυτό το παράδειγμα, έχουμε έναν δισδιάστατο πίνακα μεγέθους 3×3. Ο πίνακας αρχικοποιείται με τιμές από το 1 έως το 9. Έπειτα, χρησιμοποιούμε δύο εμφωλευμένους βρόχους for για να εκτυπώσουμε το περιεχόμενο του πίνακα στην οθόνη. Κάθε στοιχείο του πίνακα προσπελαύνεται χρησιμοποιώντας τις δύο δείκτες i και j, αντιστοίχως.

Η έξοδος του προγράμματος θα είναι:

1 2 3
4 5 6
7 8 9

Αυτό είναι ένα απλό παράδειγμα για να κατανοήσετε πώς μπορούν να χρησιμοποιηθούν πολυδιάστατοι πίνακες στη C++. Μπορείτε να προσαρμόσετε τον κώδικα για να δημιουργήσετε πίνακες με διαφορετικά μεγέθη και να εκτελέσετε διάφορες ενέργειες σε αυτούς.

[adinserter block=”5″]

Μπορούμε να αποκτήσουμε πρόσβαση σε συγκεκριμένα στοιχεία του πίνακα χρησιμοποιώντας τους δείκτες:

int myNumbers[2][3] = {
  {1, 2, 3},
  {4, 5, 6}
};
std::cout << myNumbers[1][2]; // Εκτυπώνει 6

Στο παραπάνω παράδειγμα, εκτυπώνουμε το στοιχείο στη δεύτερη γραμμή και την τρίτη στήλη του πίνακα, που είναι ίσο με 6.

Αλλαγή στοιχείων σε έναν πολυδιάστατο πίνακα

Για να αλλάξετε την τιμή ενός στοιχείου, αναφερθείτε στον αριθμό ευρετηρίου του στοιχείου σε κάθε διάσταση:

int myNumbers[2][3] = {
  {1, 2, 3},
  {4, 5, 6}
};
myNumbers[0][1] = 9;
std::cout << myNumbers[0][1]; // Εκτυπώνει 9

Στο παραπάνω παράδειγμα, αλλάζουμε την τιμή του στοιχείου στην πρώτη γραμμή και τη δεύτερη στήλη του πίνακα σε 9, και στη συνέχεια εκτυπώνουμε την τιμή του συγκεκριμένου στοιχείου για να το επιβεβαιώσουμε.

Επανάληψη μέσω πολυδιάστατου πίνακα

Για να επαναλάβετε έναν πολυδιάστατο πίνακα, χρειάζεστε έναν βρόχο για κάθε διάσταση του πίνακα.

Το παρακάτω παράδειγμα εμφανίζει όλα τα στοιχεία στον πίνακα letters:

char letters[2][3] = {
  {'a', 'b', 'c'},
  {'d', 'e', 'f'}
};
for (int i = 0; i < 2; ++i) {
  for (int j = 0; j < 3; ++j) {
    std::cout << letters[i][j] << std::endl;
  }
}

Στο παραπάνω παράδειγμα, έχουμε έναν πίνακα 2×3 με χαρακτήρες. Ο πρώτος δείκτης αναφέρεται στις γραμμές (2), ενώ ο δεύτερος δείκτης αναφέρεται στις στήλες (3). Χρησιμοποιούμε δύο βρόχους for για να επαναλάβουμε κάθε διάσταση του πίνακα, και στη συνέχεια εκτυπώνουμε το κάθε στοιχείο.

Οι πολυδιάστατοι πίνακες είναι εξαιρετικοί για την αναπαράσταση πλέγματος. Το παρακάτω παράδειγμα δείχνει ένα πρακτικό χρήσης για αυτούς. Στο παρακάτω παράδειγμα χρησιμοποιούμε έναν πολυδιάστατο πίνακα για να αναπαραστήσουμε ένα μικρό παιχνίδι Battleship:

#include <iostream>

int main() {
    // Δημιουργία πίνακα 5x5 για το παιχνίδι
    char board[5][5] = {
        {'O', 'O', 'O', 'O', 'O'},
        {'O', 'X', 'O', 'O', 'O'},
        {'O', 'O', 'O', 'O', 'O'},
        {'O', 'O', 'O', 'X', 'O'},
        {'O', 'O', 'O', 'O', 'O'}
    };

    // Εκτύπωση του πίνακα
    for (int i = 0; i < 5; ++i) {
        for (int j = 0; j < 5; ++j) {
            std::cout << board[i][j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

Αρχικά, συμπεριλαμβάνεται η βιβλιοθήκη <iostream>, η οποία περιέχει τις απαραίτητες δηλώσεις για την είσοδο και έξοδο δεδομένων στην οθόνη.

Στη συνέχεια, ορίζεται η συνάρτηση main(), η οποία είναι η κύρια συνάρτηση του προγράμματος.

Δημιουργείται ένας δισδιάστατος πίνακας με όνομα board διαστάσεων 5×5. Ο πίνακας αυτός χρησιμοποιείται για να αναπαραστήσει ένα παιχνίδι, όπου ο χαρακτήρας 'O' αντιπροσωπεύει μια κενή θέση και ο χαρακτήρας 'X' αντιπροσωπεύει μια συγκεκριμένη κατάσταση.

Στη συνέχεια, χρησιμοποιείται μια εμφωλευμένη επανάληψη (for) για να εκτυπωθούν τα στοιχεία του πίνακα. Η εξωτερική επανάληψη διατρέχει τις γραμμές του πίνακα (i από 0 έως 4) και η εσωτερική επανάληψη διατρέχει τις στήλες (j από 0 έως 4). Κατά τη διάρκεια κάθε επανάληψης, το στοιχείο του πίνακα στη θέση [i][j] εκτυπώνεται στην οθόνη χρησιμοποιώντας την εντολή std::cout. Μετά από κάθε γραμμή του πίνακα, γίνεται αλλαγή γραμμής με τη χρήση της εντολής std::endl.

Τέλος, η συνάρτηση main() επιστρέφει την τιμή 0, υποδηλώνοντας ότι το πρόγραμμα ολοκληρώθηκε επιτυχώς.

Το αποτέλεσμα εκτέλεσης του κώδικα είναι:

O O O O O 
O X O O O 
O O O O O 
O O O X O 
O O O O O 

Ο πίνακας εκτυπώνεται στην οθόνη με τους χαρακτήρες 'O' και 'X' ταξινομημένους σε μια πλέγματική μορφή 5×5. Ο χαρακτήρας 'O' αντιπροσωπεύει μια κενή θέση, ενώ ο χαρακτήρας 'X' αντιπροσωπεύει μια συγκεκριμένη κατάσταση.

Το παραπάνω αποτέλεσμα είναι το αναμενόμενο αποτέλεσμα κατά την εκτέλεση του κώδικα που δημιουργεί τον πίνακα board με τις συγκεκριμένες τιμές και στη συνέχεια τον εκτυπώνει στην οθόνη με τη χρήση της std::cout.