[C++] Vector di vector

[RooccoXXI]

Ciao a tutti.
Devo fare un programma con i vector che permetta di moltiplicare due matrici di qualsiasi taglia (dopo aver verificato che la taglia è compatibile per la moltiplicazione).

Questo è il mio programma; compila ma non funziona...

Credo di non aver capito bene come funzionano i vector di vector (i vettori a una dimensione li so usare!).

Ecco il mio programma:

#include<iostream>
using std::cout;
using std::cin;
using std::endl;
using std::cerr;

#include<vector>
using std::vector;

// ======================================================================

typedef vector< vector<double> > Matrix;

// ======================================================================

Matrix read_Matrix()
{
    int l(0), c(0);
    double d(0);
    Matrix M;
    
    cout << "Matrix dimension: ";
    cin >> l >> c;
    
    for(int i(0); i < l; i++)
    {
        for(int j(0); j < c; j++)
        {
            cout << "M_" << i << "_" << j << ": ";
            cin >> d;
            
            M[i][j] = d;
        }
    }
    
    return M;
}

// ======================================================================

Matrix multiply_Matrix(const Matrix& M1, const Matrix& M2)
{
    Matrix M;
    
    if(M1[0].size() != M2.size())
    {
        cerr << "Error: impossible moltiplication." << endl;
        
        return M;
    }
    
    for(int i(0); i < M1[0].size(); i++)
    {
        for(int j(0); j < M1.size(); j++)
        {
            M[i][j] = M1[j][i] * M2[i][j];
        }
    }
    
    return M;
}

// ======================================================================

void print_Matrix(const Matrix& M)
{
    cout << "Matrix:" << endl;
    
    for(int i(0); i < M[0].size(); i++)
    {
        for(int j(0); j < M.size(); j++)
        {
            cout << M[i][j];
        }
        
        cout << endl;
    }
}

// ======================================================================

int main()
{
    Matrix M1, M2, M;
    
    M1 = read_Matrix();
    M2 = read_Matrix();
    
    M = multiply_Matrix(M1, M2);
    
    print_Matrix(M1);
    
	return 0;
}

Avrei bisogno di un aiuto, perché ho un test di informatica giovedì... =S.

Grazie!

Ps: Non sono ancora in grado di utilizzare gli iteratori e non potrò utilizzarli durante il test.

[shodan]

Originariamente inviato da RooccoXXI
Questo è il mio programma; compila ma non funziona...

Hai l * c crash, vero?

Credo di non aver capito bene come funzionano i vector di vector (i vettori a una dimensione li so usare!).

Grosso modo come gli array di array, con la minima differenza che i vector ne semplificano la gestione. In ambedue i casi, però, per usare l'operatore[] DEVI specificare una dimensione prima.
In read_Matrix() tu non specifici ne la dimensione del vector esterno ne quella del vector interno (che in questo caso è superflua).

Matrix read_Matrix()
{
    int l(0), c(0);
    double d(0);
    Matrix M;
    
    cout << "Matrix dimension: ";
    cin >> l >> c;
    
    M.resize(l);

    for(int i(0); i < l; i++)
    {
        for(int j(0); j < c; j++)
        {

            cout << "M_" << i << "_" << j << ": ";
            cin >> d;
            M[i].resize(c);
            M[i][j] = d;
            // o in alternativa
            M[i].push_back(d);
        }
    }
 
    return M;
}

[RooccoXXI]

Originariamente inviato da shodan
Hai l * c crash, vero?


Grosso modo come gli array di array, con la minima differenza che i vector ne semplificano la gestione. In ambedue i casi, però, per usare l'operatore[] DEVI specificare una dimensione prima.
In read_Matrix() tu non specifici ne la dimensione del vector esterno ne quella del vector interno (che in questo caso è superflua).

Ok, grazie.
Ma può i spiegarmi esattamente com'è il concetto dei vector di vector? Io conosco solo gli array multipli in stile C e anche li faccio sempre fatica a capire quali sono le righe e quali sono le colonne (quali per prime???). Inoltre quello che non capisco bene nei vector di vector è che ogni riga può avere un numero differente di elementi (non si tratta più di una griglia-tabella)...
Credo che non ci saranno nell'esercizio, ma vorrei riuscire a destreggiarmi per sicurezza (e più in la ci saranno di sicuro!).
=S.

Grazie.

[Kaamos]

Originariamente inviato da RooccoXXI
Ok, grazie.
Ma può i spiegarmi esattamente com'è il concetto dei vector di vector? Io conosco solo gli array multipli in stile C e anche li faccio sempre fatica a capire quali sono le righe e quali sono le colonne (quali per prime???). Inoltre quello che non capisco bene nei vector di vector è che ogni riga può avere un numero differente di elementi (non si tratta più di una griglia-tabella)...
Credo che non ci saranno nell'esercizio, ma vorrei riuscire a destreggiarmi per sicurezza (e più in la ci saranno di sicuro!).
=S.

Grazie.

Che si tratti di vector di vector o di array bidimensionali il concetto è sempre lo stesso: non c'è effettivamente una regola per indicare le colonne, solitamente viene naturale indicare prima le righe e poi le colonne e comportarsi di conseguenza, ma adattando il codice si potrebbe operare anche al contrario.
Una volta deciso di indicare prima le rige poi le colonne, continua a comportarti di conseguenza e non ci saranno indecisioni.
Ma è tutta una cosa ideale, si ci immagina una tabella perché è ciò che la struttura dati in questione rappresenta e perché è ciò che ci viene più comodo immaginare a noi, ma potresti benissimo utilizzare una struttura dati monodimensionale anziché una multidimensionale... per esempio quel che metti in una tabella di n righe ed m colonne potresti metterlo in un array semplice di lunghezza n*m, che idealmente rappresenterebbe tutte le righe in fila, ma sarebbe scomodo e poco rappresentativo della struttura.

Per quanto riguarda righe di diversa lunghezza, beh come dici non si tratta più di una tabella quadrata/rettangolare, ma i concetti rimangono gli stessi, se decidi di indicare righe e poi colonne puoi continuare a farlo, con le dovute precauzioni.

[RooccoXXI]

Originariamente inviato da Kaamos
Che si tratti di vector di vector o di array bidimensionali il concetto è sempre lo stesso: non c'è effettivamente una regola per indicare le colonne, solitamente viene naturale indicare prima le righe e poi le colonne e comportarsi di conseguenza, ma adattando il codice si potrebbe operare anche al contrario.
Una volta deciso di indicare prima le rige poi le colonne, continua a comportarti di conseguenza e non ci saranno indecisioni.
Ma è tutta una cosa ideale, si ci immagina una tabella perché è ciò che la struttura dati in questione rappresenta e perché è ciò che ci viene più comodo immaginare a noi, ma potresti benissimo utilizzare una struttura dati monodimensionale anziché una multidimensionale... per esempio quel che metti in una tabella di n righe ed m colonne potresti metterlo in un array semplice di lunghezza n*m, che idealmente rappresenterebbe tutte le righe in fila, ma sarebbe scomodo e poco rappresentativo della struttura.

Per quanto riguarda righe di diversa lunghezza, beh come dici non si tratta più di una tabella quadrata/rettangolare, ma i concetti rimangono gli stessi, se decidi di indicare righe e poi colonne puoi continuare a farlo, con le dovute precauzioni.

Ok, allora mi comporterò come con gli array tradizionali, utilizzando l'operator []! Grazie per i chiarimenti.

[Kaamos]

Originariamente inviato da RooccoXXI
Ok, allora mi comporterò come con gli array tradizionali, utilizzando l'operator []! Grazie per i chiarimenti.

Quando puoi con le strutture dati usa i metodi come at() invece che l'operatore [], il primo controlla che tu non vada dove non devi, se vai fuori dal tuo array ma non dalla memoria assegnata al programma, vai a modificare altri dati e spuntano fuori problemi apparentemente incomprensibili magari in tutt'altro punto del programma, a volte son difficili da risolvere.