supprimer vector 2D immense

Version imprimable

11/12/2016, 19h48
js_naka

supprimer vector 2D immense

Bonjour à tous,

je suis sur une petite appli dans laquelle je recueille des données pouvant être très nombreuses. Par exemple, je charge des matrices (vector 2D) de l'ordre de 400 000 lignes à 4 ou 6 colonnes, ça met environ 4 sec à partir du fichier de données.

Je fais mon traitement tout va bien mais quand je quitte l'application, ça met 30 sec pour vider la matrice (swap). Ce qui est un peu gênant...

Je me doute bien que c'est intrinsèque à la fonction swap mais y a-t-il une meilleure approche pour gérer de telles matrices ? Notamment pour les supprimer en quittant le programme ?

Merci d'avance pour votre aide
11/12/2016, 21h54
Pyramidev

Bonjour,

Peux-tu montrer ton code ?
Comme ça, on te dira s'il y a un moyen facile d'optimiser.

Lecture du fichier et chargement du tableau 2D :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
void ChargerFichier::chargergrille(const int &dim, const int &nblig, const CString &chemin_fichier, std::vector<std::vector<double> > &grille)
{
	std::ifstream fichier(chemin_fichier, std::ios::in);
	if (fichier)
	{
		for (int i = 0; i < nblig; i++)
		{
                        for (int j = 0; j < (2 * dim + 4); j++)
                        {
                                   fichier >> grille[i][j];
                        }
 
		}
		fichier.close();
	}
	else
	{
		// peu importe
	}
}

Suppression du tableau en cliquant sur un bouton pour quitter l'appli :

Code:

1
2
3
4
5
6
 
void CIdMv2x64Dlg::OnBnClickedCancel()
{
	std::vector<std::vector<double>().swap(grille);
	CDialogEx::OnCancel();
}

Un std::vector de std::vector, ce n'est pas performant, car tu auras au moins autant d'allocations dans la mémoire dynamique que de std::vector. Idem pour les désallocations.

Il vaut mieux un seul std::vector<double> qui contient toute la matrice.
Par exemple, si on y stocke les données colonne par colonne, alors l'élément d'indices (row, col) dans la matrice sera l'élément d'indice col*nbLignes + row dans le std::vector<double>.
Pour le manipuler en tant que matrice, le plus simple est de l'encapsuler dans une classe Matrix<double>.

Voici le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <iostream>
#include <sstream>
#include <typeinfo>
#include <vector>
 
template<class T>
class Matrix
{
public:
	Matrix(size_t rowCount, size_t colCount);
	Matrix(Matrix<T>&&)               = default;
	Matrix(const Matrix<T>&)          = default;
	~Matrix()                         = default;
	Matrix<T>& operator=(Matrix<T>&&) = default;
	Matrix<T>& operator=(Matrix<T> other) {*this = std::move(other); return *this;}
	size_t   rowCount() const {return m_rowCount;}
	size_t   colCount() const {return m_colCount;}
	T&       operator()(size_t row, size_t col);       //!< \warning pas de contrôle des indices
	const T& operator()(size_t row, size_t col) const; //!< \warning pas de contrôle des indices
	T&       at        (size_t row, size_t col);       //!< \exception std::out_of_range indices incorrects
	const T& at        (size_t row, size_t col) const; //!< \exception std::out_of_range indices incorrects
private:
	size_t         m_rowCount;
	size_t         m_colCount;
	std::vector<T> m_data;
};
 
template<class T>
Matrix<T>::Matrix(size_t rowCount, size_t colCount) :
	m_rowCount(rowCount),
	m_colCount(colCount),
	m_data(rowCount*colCount)
{
}
 
template<class T>
const T& Matrix<T>::operator()(size_t row, size_t col) const
{
	return m_data[col*m_rowCount + row]; // stockage colonne par colonne
//	return m_data[row*m_colCount + col]; // stockage ligne par ligne
}
 
template<class T>
T& Matrix<T>::operator()(size_t row, size_t col)
{
	return const_cast<T&>(static_cast<const Matrix<T>&>(*this)(row, col));
}
 
template<class T>
const T& Matrix<T>::at(size_t row, size_t col) const
{
	if(row >= m_rowCount || col >= m_colCount) {
		std::ostringstream oss;
		oss << "Error: Matrix<T>::at [T = " << typeid(T).name() << "]:";
		if(row >= m_rowCount)
			oss << " Row index (" << row << ") out of range (number of rows: " << m_rowCount << ").";
		if(col >= m_colCount)
			oss << " Column index (" << col << ") out of range (number of columns: " << m_colCount << ").";
		throw std::out_of_range(oss.str());
	}
	return (*this)(row, col);
}
 
template<class T>
T& Matrix<T>::at(size_t row, size_t col)
{
	return const_cast<T&>(static_cast<const Matrix<T>&>(*this).at(row, col));
}
 
// Utilisation :
int main(int argc, char **argv)
{
	// Construire une matrice :
	Matrix<double> mat(3, 5);
	for(size_t i = 0; i < mat.rowCount(); ++i)
		for(size_t j = 0; j < mat.colCount(); ++j)
			mat(i, j) = i+j;
 
	// Afficher la matrice (code bourrin) :
	for(size_t i = 0; i < mat.rowCount(); ++i) {
		for(size_t j = 0; j < mat.colCount(); ++j)
			std::cout << mat(i, j) << " ; ";
		std::cout << '\n';
	}
}

12/12/2016, 09h26
Bousk

Quelle est l'utilité de ce swap ?

Citation:

Notamment pour les supprimer en quittant le programme ?

Tu n'as rien à faire pour supprimer un vector en sortie du programme. :weird:
12/12/2016, 13h52
js_naka

Merci Pyramidev. Effectivement, c'est bien plus performant avec un seul vector. Merci beaucoup aussi pour le code, je vais d'abord essayer de toit comprendre et je l'utiliserai plus tard.
Pour te répondre Bousk, effectivement le swap ne sert à rien ici, mais comme on m'a demandé de montrer du code, je l'ai rajouté pour que ce soit explicite.
12/12/2016, 23h37
zobal

Bonjour
Je ne sais pas quels sont tes objectifs, utilisations et contraintes mais pour manipuler des matrices, il existe des bibliothèques d'algèbre linéaire comme armadillo, eigen ou blitz qui sont bien pratiques.