Discussion :

[js_naka]

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

[Pyramidev]

Bonjour,

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

[js_naka]

Lecture du fichier et chargement du tableau 2D :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Pyramidev]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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';
	}
}

[Bousk]

Quelle est l'utilité de ce swap ?

Notamment pour les supprimer en quittant le programme ?

Tu n'as rien à faire pour supprimer un vector en sortie du programme.

[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.

[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.