Seguici su Telegram, ne vale la pena ❤️ ➡ @trovalost
Vai al contenuto

Matrici in C++ (guida totale)

Le matrici in C++ sono strutture dati che rappresentano un insieme bidimensionale di elementi organizzati in righe e colonne. Sono utilizzate per memorizzare e manipolare dati in un formato tabellare.

Ecco una guida introduttiva completa sulle matrici in C++, che potete sfruttare per il vostro codice e per adattarlo a varie situazioni.

Definizione di una Matrice

Array Multidimensionale

Una matrice viene definita come un array a due dimensioni (con massima generalità, almeno due). In questo caso definiamo due costanti, una per il numero di righe (ROWS) ed una per il numero di colonne (COLS), poi andiamo a definite la matrice che sarà di dimensioni 3×3, conterrà 3×3=9 elementi e sarà composta da interi e di forma quadrata.

const int ROWS = 3;
const int COLS = 3;
int matrix[ROWS][COLS]; // Matrice 3x3 di interi

Matrice Inizializzata

Se volessi inizializzare la matrice con numeri, andrei a metterli tra parentesi graffe come indicato di seguito.

int matrix[3][3] =
{
 {1, 2, 3},
{4, 5, 6},
 {7, 8, 9}
}; // Matrice 3x3 inizializzata

Accesso agli Elementi

int value = matrix[1][2]; // Accesso all'elemento in posizione (1, 2)

Operazioni con le Matrici

Popolare (riempire di dati) una Matrice

int k=0; //inizializza
for (int i = 0; i < ROWS; ++i) {

for (int j = 0; j < COLS; ++j) {
matrix[i][j] = k++; // Assegnazione di valori interi progressivi 1, 2, 3, ...

}
}

Stampare una Matrice:

Per mostrare i valori della matrice, li stampiamo dentro un ciclo for.
for (int i = 0; i < ROWS; ++i) {
for (int j = 0; j < COLS; ++j) {
cout << matrix[i][j] << " "; // Stampa degli elementi
}
cout << std::endl; // mette una nuova riga per ogni riga della matrice
}

Operazioni Avanzate

  • Manipolazione: Esegui operazioni come somma, sottrazione, moltiplicazione tra matrici.
  • Transposizione: Scambia righe e colonne di una matrice.
  • Determinante: Calcola il determinante di una matrice quadrata.
  • Inversione: Trova l’inversa di una matrice quadrata.

Librerie Utili

  • iostream: Per l’input/output.
  • cmath: Per operazioni matematiche (es. calcolo della radice quadrata).
  • vector: Per rappresentare matrici dinamiche.

Considerazioni Importanti:

  • Le matrici in C++ sono rappresentate come array multidimensionali, quindi le operazioni dirette di manipolazione possono risultare complesse.
  • Per operazioni avanzate, considera l’uso di librerie esterne come Eigen per algebra lineare.

Le matrici sono una risorsa potente e versatile nella programmazione, utilizzate in matematica, grafica, elaborazione delle immagini, calcolo scientifico e molto altro ancora. Pratica con operazioni di base e gradualmente esplora operazioni più avanzate per sfruttare appieno il loro potenziale.

Esercizio: rilevare solo gli elementi diagonale principale

Per trovare gli elementi della diagonale secondaria di una matrice 3×3 in C++, puoi usare un ciclo for per scorrere gli elementi in modo tale che la somma degli indici di riga e colonna sia uguale a 2 (considerando che gli indici partono da 0).

Ecco un esempio di come puoi farlo:

#include <iostream>
using namespace std;

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

cout << "Elementi della diagonale principale:" << std::endl;

for (int i = 0; i < 3; ++i) {
cout << matrix[i][i] << " ";
}
cout << endl;

return 0;
}

Elementi diagonale secondaria

In questo esempio, il ciclo for scorre gli elementi della diagonale secondaria utilizzando l’indice i e calcolando l’indice della colonna come 2 - i. Questo approccio si basa sul fatto che la somma degli indici di riga e colonna per gli elementi della diagonale secondaria è costante e uguale a 2 nella matrice 3×3.

Ti potrebbe interessare:  Le Riviste di Interior Design più Interessanti secondo l'Accademia Italiana Designer

Se i = 0, infatti 2-i = 2-0 = 2; se i = 1, 2-i = 2-1 = 1; Se i = 2, inifine, 2-i = 2-2 = 0.

#include <iostream>
using namespace std;

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

cout << "Elementi della diagonale secondaria:" << endl;

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if ( (i+j) == 2 ) //allora siamo sulla diagonale secondaria
cout << matrix[i][j] << " ";
}
cout << endl;

return 0;
}

Elementi con somma di indici pari (Scacchiera, un elemento sì e uno no)

Questo codice adatta l’approccio precedente per considerare solo le posizioni con una somma di indici pari.

La condizione (i + (k - i)) % 2 == 0 verifica se la somma degli indici è pari prima di estrarre e stampare l’elemento corrispondente.

Puoi utilizzare questa logica per estrarre solo gli elementi desiderati seguendo uno schema “a scacchiera”.

#include <iostream>

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

std::cout << "Elementi a scacchiera con somma di indici di riga e colonna pari: ";

for (int i = 0; i < SIZE; ++i) {
for (int j = 0; j < SIZE; ++j) {
if ((i + j) % 2 == 0) { // Controllo per la somma di indici pari
std::cout << matrix[i][j] << " ";
}
}
}

std::cout << std::endl;

return 0;
}

Elementi dell’anti-diagonale

Usata ad esempio per la convoluzione, consiste nel prendere la totalità delle diagonali secondarie (che sono nell’esempio 1, poi 2,4, poi 3,5,7).

Quindi ad esempio: [i][k - i] andrà a prendere [0][3 - 0], [1][3 - 1], [2][3 - 2], quindi 0,3 poi 1,2 e poi 2,1.

#include <iostream> 
using namespace std;

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

    // Estrazione degli elementi dell'anti-diagonale
    for (int k = 0; k < SIZE; ++k) {
        cout << "Elementi dell'anti-diagonale " << k + 1 << ": ";

        for (int i = 0; i <= k; ++i) {
            cout << matrix[i][k - i] << " ";
        }

        cout << endl;
    }

    return 0;
}

Elementi anti-diagonale con somma di indici pari

Ci sbizzarriamo, a questo punto.

#include <iostream>

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

// Estrazione degli elementi dell'anti-diagonale con somma di indici pari
for (int k = 0; k < SIZE; ++k) {
std::cout << "Elementi dell'anti-diagonale con somma di indici pari " << k + 1 << ": ";

for (int i = 0; i <= k; ++i) {
if ((i + (k - i)) % 2 == 0) { // Controllo per la somma di indici pari
std::cout << matrix[i][k - i] << " ";
}
}

std::cout << std::endl;
}

return 0;
}

Manipolazione: Esegui somma tra matrici.

#include <iostream>

const int ROWS = 3;
const int COLS = 3;

void sumMatrices(int mat1[ROWS][COLS], int mat2[ROWS][COLS], int result[ROWS][COLS]) {
for (int i = 0; i < ROWS; ++i) {
for (int j = 0; j < COLS; ++j) {
result[i][j] = mat1[i][j] + mat2[i][j]; // Somma degli elementi corrispondenti
}
}
}

void printMatrix(int matrix[ROWS][COLS]) {
for (int i = 0; i < ROWS; ++i) {
for (int j = 0; j < COLS; ++j) {
std::cout << matrix[i][j] << " "; // Stampa degli elementi
}
std::cout << std::endl;
}
}

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

int matrix2[ROWS][COLS] = {{9, 8, 7},
{6, 5, 4},
{3, 2, 1}};

int result[ROWS][COLS];

sumMatrices(matrix1, matrix2, result); // Somma delle matrici

std::cout << "Matrice 1:" << std::endl;
printMatrix(matrix1);

std::cout << "Matrice 2:" << std::endl;
printMatrix(matrix2);

std::cout << "Risultato della somma:" << std::endl;
printMatrix(result);

return 0;
}

Transposizione: Scambia righe e colonne di una matrice.

Questo programma definisce una matrice 3×3 (matrix), esegue la trasposizione utilizzando la funzione transposeMatrix, e quindi stampa la matrice originale e la matrice trasposta. La funzione printMatrix è utilizzata per stampare le matrici. Durante la trasposizione, viene invertito il numero di righe e colonne, producendo la matrice trasposta

#include <iostream>

const int ROWS = 3;
const int COLS = 3;

void transposeMatrix(int matrix[ROWS][COLS], int result[COLS][ROWS]) {
for (int i = 0; i < ROWS; ++i) {
for (int j = 0; j < COLS; ++j) {
result[j][i] = matrix[i][j]; // Scambio di righe e colonne
}
}
}

void printMatrix(int matrix[ROWS][COLS], int rows, int cols) {
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
std::cout << matrix[i][j] << " "; // Stampa degli elementi
}
std::cout << std::endl;
}
}

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

int transposed[COLS][ROWS];

transposeMatrix(matrix, transposed); // Trasposizione della matrice

std::cout << "Matrice Originale:" << std::endl;
printMatrix(matrix, ROWS, COLS);

std::cout << "Matrice Trasposta:" << std::endl;
printMatrix(transposed, COLS, ROWS);

return 0;
}

Determinante: Calcola il determinante di una matrice quadrata.

Screenshot 2023 12 03 alle 14.21.57

#include <iostream>

const int SIZE = 3;

int determinant(int matrix[SIZE][SIZE]) {
int det = 0;

det = 
  matrix[0][0] * (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1])
- matrix[0][1] * (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0])
+ matrix[0][2] * (matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]);

return det;
}

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

int det = determinant(matrix); // Calcolo del determinante

std::cout << "Il determinante della matrice è: " << det << std::endl;

return 0;
}

Inversione: Trova l’inversa di una matrice quadrata.

Screenshot 2023 12 03 alle 14.22.57

#include <iostream>

const int SIZE = 3;

double determinant(int matrix[SIZE][SIZE]) {
double det = 0;

det = matrix[0][0] * (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1])
- matrix[0][1] * (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0])
+ matrix[0][2] * (matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]);

return det;
}

void inverseMatrix(int matrix[SIZE][SIZE], double inverse[SIZE][SIZE]) {
double det = determinant(matrix);

if (det == 0) {
std::cout << "La matrice non è invertibile (determinante zero)." << std::endl;
return;
}

double invDet = 1.0 / det;

inverse[0][0] = (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1]) * invDet;
inverse[0][1] = -(matrix[0][1] * matrix[2][2] - matrix[0][2] * matrix[2][1]) * invDet;
inverse[0][2] = (matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1]) * invDet;
inverse[1][0] = -(matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0]) * invDet;
inverse[1][1] = (matrix[0][0] * matrix[2][2] - matrix[0][2] * matrix[2][0]) * invDet;
inverse[1][2] = -(matrix[0][0

Da non perdere 👇👇👇

Ti potrebbe interessare:  Terminale Mac: guida ai principali comandi


Questo sito esiste da 4412 giorni (12 anni), e contiene ad oggi 3952 articoli (circa 3.161.600 parole in tutto) e 12 servizi online gratuiti. – Leggi un altro articolo a caso
Non ha ancora votato nessuno.

Ti sembra utile o interessante? Vota e fammelo sapere.

Questo sito contribuisce alla audience di sè stesso.
Il nostro network informativo: Lipercubo.it - Pagare.online - Trovalost.it.