[c++] Aiuto programmino matrici

[-Slash]

mmm, ho visto un po' il programma del corso e vector non si fa, mentre invece l'allocazione dinamica è in programma... potreste farmi un esempio semplice di allocazione di memoria di una variabile,messa poi in un array? tipo abbiamo una variabile k che viene immessa da tastiera con cin e successivamente la variabile k è usata come indice di un array: array[k]

ho googlato un po' e la cosa che piu si avvicina a quello che devo fare che ho trovato è questa http://www.disp.uniroma2.it/users/bu.../CPP3/CPP3.HTM

ma utilizza stdio.h

grazie ancora di tutto, dopo di questa mi tolgo dalle scatole

[cionci]

int righe = 6;
int colonne = 3;


double *matrice = new double[righe * colonne];


Per accedere all'elemento (r,c): matrice[r * colonne + c]

[marko.fatto]

Originariamente inviato da cionci

int righe = 6;
int colonne = 3;


double *matrice = new double[righe * colonne];


Per accedere all'elemento (r,c): matrice[r * colonne + c]

Scusa la nubbiaggine ma così non è un vettore!?

[wizard1993]

no, è un array ad allocazione tramite puntatore

[marko.fatto]

Originariamente inviato da wizard1993

no, è un array ad allocazione tramite puntatore

ma comunque un array monodimensionale... è possibile allocare dinamicamente un array multidimensionale senza ricorrere a quel "trucchetto"?

edit: sempre usando un puntatore...

[cionci]

Sì, ma c'è da lavorare un pochetto

Lo facevo per farglielo più semplice...

double **m = new double * [righe];

for(int i = 0; i < righe; ++i)
m[i] = new double[colonne];

[marko.fatto]

Originariamente inviato da cionci

Sì, ma c'è da lavorare un pochetto

Lo facevo per farglielo più semplice...

double **m = new double * [righe];

for(int i = 0; i < righe; ++i)
m[i] = new double[colonne];

E per accederci?

[cionci]

m[i][j]

[-Slash]

grande! sono riuscito a fare il programma finalmente

#include <iostream>
#include <vector>
using namespace std;

int main() {
	int righe,
		colonne,
		diagsize;
	
	cout << "Inserire il numero di vettori della matrice quadrata" << endl;
	cin >> righe;
	
	colonne = righe;
		
	diagsize = ( ( 2 * righe ) - 1 );
	
	double **matrice = new double * [righe];
	
	vector< double > diagonale( diagsize );
	
	for(int i = 0; i < righe; ++i)
	   matrice[i] = new double[colonne];
		 
	
	for(int i = 0; i < righe; i++)
		for(int j = 0; j < colonne; j++) {
			cout << "Inserisci Elemento" << (i+1) <<" " << (j+1) << endl;
			cin >> matrice[i][j];	
		}
	
	
	
	for(int i = 0; i < righe; i++)
			for(int j = 0; j < colonne; j++)
				diagonale[righe-i+j] += matrice[i][j];
	
	for(int i = 1; i <= diagsize; i++)
		cout << "La somma della " << (i+1) << " diagonale e': " << diagonale[i] << endl;
	
	system("PAUSE");
	return 0;
		
}

funziona

solo l'array monodimensionale per le somme delle diagonali non lo riuscivo a fare con l'allocazione, quindi ho fatto un vector...

potresti spiegarmi questo codice

double **m = new double * [righe];

for(int i = 0; i < righe; ++i)
m[i] = new double[colonne];

funziona benissimo, ma non ho capito bene il ragionamento che c'è sotto

[Maverick18]

Originariamente inviato da -Slash

double **m = new double * [righe];

for(int i = 0; i < righe; ++i)
m[i] = new double[colonne];
[/code]
funziona benissimo, ma non ho capito bene il ragionamento che c'è sotto

Se non sbaglio alloca un vettore di puntatori double e lo fa puntare da m.
Poi alloca un vettore double per ogni puntatore double puntato da m.

[cionci]

Non sbagli.

[banryu79]

Anche se cionci e Maverick18 ti hanno già risposto ho pensato che poteva esserti di ulteriore aiuto uno schema visivo:

double **m = new double * [righe];

for(int i = 0; i < righe; ++i)
m[i] = new double[colonne];

a) double **m = new double * [righe];

l'dentificatore "m" viene definito come una variabile di tipo "Puntatore a puntatore a double", quindi viene inizializzato con l'allocazione dinamica di un array contenente un numero pari a "righe" di "Puntatori a double".

-----------------------------------------------------------------
Puntatore a puntatore a double.....Puntatore a double..........Double
-----------------------------------------------------------------
double **m ..............................double *(unnamed)..........double
-----------------------------------------------------------------
m ------------------------------> righe1 -------------> (double)
|
| -------------------------------> righe2 -------------> (double)
|
| -------------------------------> righeN -------------> (double)


b) m[i] = new double[colonne];

Sappiamo che "m" (Puntatore di puntatore a double) adesso punta ad un array di elementi Puntatore a double
Viene quindi utilizzato un ciclo per assegnare ad ognuno di quei Puntatori a double un array di double.

m----->righe1..........righe2........righeN
...........|................|..............|.
...........|................|..............|.
...........V................V.............V.
..............................................
...........double[]......double[]......double[]


Spero ti sia utile,
Ciao

[-Slash]

Grazie per la spiegazione esaustiva

ho trovato anche il modo per farlo con vector di vector

vector<int> m( matsize );
vector<vector<int> >  matrice( matsize,m );

per accederci basta il solito matrice[i][j]

potrebbe essere utile a qualcuno

[cionci]

Originariamente inviato da -Slash

Grazie per la spiegazione esaustiva

ho trovato anche il modo per farlo con vector di vector

vector<int> m( matsize );
vector<vector<int> >  matrice( matsize,m );

per accederci basta il solito matrice[i][j]

potrebbe essere utile a qualcuno

Non ci sono quei costruttori In ogni caso dopo vanno ridimensionati i singoli vector.

[-Slash]

Originariamente inviato da cionci

Non ci sono quei costruttori In ogni caso dopo vanno ridimensionati i singoli vector.

cioè?

comunque ho fatto vedere oggi il programma al professore, mi ha quasi insultato dicendo che devo risolvere i problemi con gli strumenti che abbiamo

bah, ma che modi

mi ha detto che lo stesso programma si poteva fare senza allocazione o vector, dichiarando i valori delle diagonali come const int. tralasciando la sua ignoranza(e soprattutto quella del suo assistente, un ingegnere che non sa come imporre l'esistenza di un triangolo e non conosce getchar) sul fatto che non posso dichiarare(almeno con i nostri strumenti) un const int senza inizializzarlo e peggio ancora poi inserirlo da cin tutto sommato poi dichiarando la dimensione della matrice come int funziona senza allocazione dinamica...

#include <iostream>
#include <cstdlib>

using namespace std;

int main() {
    int matsize, // Dimensione della Matrice quadrata
	    diagsize; // Numero di diagonali della matrice

	cout << "Inserire il numero di vettori della matrice quadrata" << endl;
	cin >> matsize;

	diagsize = ( 2 * matsize )-1;

	double matrice[matsize] [matsize];
	double diagonale[diagsize];

	// Inserisce gli elementi
	for(int i = 0; i < matsize; i++)
		for(int j = 0; j < matsize; j++) {
			cout << "Inserisci Elemento " << (i+1) <<" " << (j+1) << endl;
			cin >> matrice[i][j];
		}


	// Calcola le Somme della matrice
	for(int i = 0; i < matsize; i++)
			for(int j = 0; j < matsize; j++)
				diagonale[matsize-i+j] += matrice[i][j];

	// Stampa il risultato
	for(int i = 1; i <= diagsize; i++)
		cout << "La somma della " << (i+1) << " diagonale e': " << diagonale[i] << endl;

	system("PAUSE");
    return 0;

}

mi ha detto anche che non posso calcolare il numero di diagonali algebricamente perchè non funziona poi, ma funziona lo stesso

[cionci]

Originariamente inviato da -Slash

cioè?

Cioè il codice che hai scritto non funziona perché non esistono costruttori di vector che prendono in ingresso quei parametri.
Puoi fare però così per creare una matrice R x C:

vector< vector<int> > m;

m.resize(R);
for(int i = 0; i < R; ++i)
   m[i].resize(C, 0);

[-Slash]

Originariamente inviato da cionci

Cioè il codice che hai scritto non funziona perché non esistono costruttori di vector che prendono in ingresso quei parametri.
Puoi fare però così per creare una matrice R x C:

vector< vector<int> > m;

m.resize(R);
for(int i = 0; i < R; ++i)
   m[i].resize(C, 0);

nono, con i vector come l'avevo fatto io funziona bene

ho letto la guida qui su come creare vector di vector

http://www.dcs.bbk.ac.uk/~roger/cpp/week7.htm

[cionci]

Azzz...avevo letto male...non avevo visto che m era il vettore sopra.
in effetti così va bene.