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.
- 1) Definizione di una Matrice
- 2) Operazioni con le Matrici
- 3) Operazioni Avanzate
- 4) Librerie Utili
- 5) Esercizio: rilevare solo gli elementi diagonale principale
- 6) Elementi diagonale secondaria
- 7) Elementi con somma di indici pari (Scacchiera, un elemento sì e uno no)
- 8) Elementi dell’anti-diagonale
- 9) Elementi anti-diagonale con somma di indici pari
- 10) Manipolazione: Esegui somma tra matrici.
- 11) Transposizione: Scambia righe e colonne di una matrice.
- 12) Determinante: Calcola il determinante di una matrice quadrata.
- 13) Inversione: Trova l’inversa di una matrice quadrata.
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.
Usa il codice
189ed7ca010140fc2065b06e3802bcd5
per ricevere 5 € dopo l’iscrizione
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:
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
#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.
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.
#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.
#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 👇
- Internet 💻
- Lavoro 🔧
- Mondo Apple 🍎
- Sicurezza & Privacy 👁
- WordPress 🤵
- 💬 Il nostro canale Telegram: iscriviti
- 🔴 Perchè è difficile cambiare idea (dopo averla espressa in pubblico)?
- 🟢 4G LTE: caratteristiche, velocità, funzionamento
- 🔴 Cosa fare se la tastiera del cellulare Samsung con Android non funziona: ripristino software