Matrici (C++)

Una matrice è una raccolta di oggetti simili.Il caso più semplice di una matrice è un vettore, che può essere dichiarato dalla seguente sequenza:

decl-specifier identifier [ constant-expression ]
decl-specifier identifier []
decl-specifier identifer [][ constant-expression] . . .
decl-specifier identifier [ constant-expression ]
[ constant-expression ] . . .

1.L'identificatore della dichiarazione:

• Un identificatore facoltativo della classe di archiviazione.

• facoltativo const e/o volatile identificatori.

• Il nome del tipo degli elementi della matrice.

2.il dichiaratore:

• Identificatore.

• Un'espressione costante di tipo integrale racchiusa tra parentesi, []. Se più dimensioni sono dichiarate con l'delle parentesi aggiuntivi, l'espressione costante può essere omesso sul primo set di parentesi quadre.

• Parentesi aggiuntivi facoltativi che includono espressioni costanti.

3.un inizializzatore facoltativo.vedere inizializzatori.

Il numero di elementi della matrice è fornito dall'espressione costante.Il primo elemento della matrice è il 0th elemento e l'ultimo elemento è (n-1) elemento, dove n indica il numero di elementi che la matrice può contenere.espressione costante deve essere di un tipo integrale e deve essere maggiore di 0.Una matrice di dimensioni zero è valida solo quando la matrice è l'ultimo campo in un oggetto struct o unione e quando le estensioni Microsoft (/Ze) abilitate.

Nell'esempio seguente viene illustrato come definire una matrice in fase di esecuzione:

// arrays.cpp
// compile with: /EHsc
#include <iostream>

int main() {
   using namespace std;
   int size = 3, i = 0;

   int* myarr = new int[size];

   for (i = 0 ; i < size ; i++)
      myarr[i] = 10;

   for (i = 0 ; i < size ; i++)
      printf_s("myarr[%d] = %d\n", i, myarr[i]);

   delete [] myarr;
}

Le matrici sono tipi derivati e può pertanto essere generate da qualsiasi tipo derivato o fondamentale altro ad eccezione delle funzioni, i riferimenti e void.

Le matrici generate da altre matrici sono matrici multidimensionali.Queste matrici multidimensionali sono specificate dalle espressioni costanti tra parentesi più nell'ordine.Ad esempio, si consideri questa dichiarazione:

int i2[5][7];

specifica una matrice di tipo intconcettualmente, disposti in una matrice bidimensionale di cinque righe e sette colonne, come illustrato nella figura seguente:

layout concettuale di matrice multidimensionale

Nelle dichiarazioni di matrici multidimensioned che hanno un elenco di inizializzatori (come descritto in inizializzatori), l'espressione costante che specifica i limiti della prima dimensione può essere omesso.Di seguito è riportato un esempio:

// arrays2.cpp
// compile with: /c
const int cMarkets = 4;
// Declare a float that represents the transportation costs.
double TransportCosts[][cMarkets] = { 
   { 32.19, 47.29, 31.99, 19.11 },
   { 11.29, 22.49, 33.47, 17.29 },
   { 41.97, 22.09,  9.76, 22.55 }
};

La dichiarazione precedente viene definita una matrice che rappresenta tre righe da quattro colonne.Le righe rappresentano le factory e le colonne rappresentano i mercati la cui nave officina.I valori sono i costi di trasporto dalle factory ai mercati.La prima dimensione della matrice viene lasciata all'esterno, ma il compilatore che la compila esaminando un inizializzatore.

Argomenti contenuti in questa sezione:

• Utilizzo di matrici

• Matrici nelle espressioni

• Interpretazione dell'operatore di indice

• riferimento indiretto sui tipi di matrice

• Ordine delle matrici C++

Esempio

La tecnica di omissione della specifica limiti della prima dimensione di una matrice multidimensionale può anche essere utilizzata nelle dichiarazioni di funzione come segue:

// multidimensional_arrays.cpp
// compile with: /EHsc
// arguments: 3
#include <limits>   // Includes DBL_MAX
#include <iostream>

const int cMkts = 4, cFacts = 2;

// Declare a float that represents the transportation costs
double TransportCosts[][cMkts] = { 
   { 32.19, 47.29, 31.99, 19.11 },
   { 11.29, 22.49, 33.47, 17.29 },
   { 41.97, 22.09,  9.76, 22.55 }  
};

// Calculate size of unspecified dimension
const int cFactories = sizeof TransportCosts /
                  sizeof( double[cMkts] );

double FindMinToMkt( int Mkt, double myTransportCosts[][cMkts], int mycFacts);

using namespace std;

int main( int argc, char *argv[] ) {
   double MinCost;

   if (argv[1] == 0) {
      cout << "You must specify the number of markets." << endl;
      exit(0);
   }
   MinCost = FindMinToMkt( *argv[1] - '0', TransportCosts, cFacts);
   cout << "The minimum cost to Market " << argv[1] << " is: "
       << MinCost << "\n";
}

double FindMinToMkt(int Mkt, double myTransportCosts[][cMkts], int mycFacts) {
   double MinCost = DBL_MAX;

   for( int i = 0; i < cFacts; ++i )
      MinCost = (MinCost < TransportCosts[i][Mkt]) ?
         MinCost : TransportCosts[i][Mkt];

   return MinCost;
}

Commenti

la funzione FindMinToMkt è scritto in modo da aggiungere nuove factory non richiede alcuna modifica al codice, solo la ricompilazione.

Vedere anche

Riferimenti

Dichiaratori estrai C++