Discussion :

[Nadd]

Bonjour,

Voici le code sur lequel je travaille :

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
 
template<typename T>
class vector_t
{
public:
	virtual T const & operator[](size_t y) const = 0;
	virtual T & operator[](size_t y) = 0;
	virtual size_t size() const = 0;
};
 
template<typename T>
class Vector : public vector_t<T>
{
public:
	Vector(size_t n) : n_(n), data_(n) { }
	Vector(size_t n, T val) : n_(n), data_(n, val) { }
	virtual T const & operator[](size_t y) const { return data_[y]; }
	virtual T & operator[](size_t y) { return data_[y]; }
	virtual size_t size() const { return data_.n_; }
	vector<T> & data() { return data_; }
private:
	size_t n_;
	vector<T> data_;
};
 
template<typename T>
class Field
{
public:
	class Field2 : public vector_t<T>
	{
	public:
		Field2(Field & parent, size_t x) : parent_(parent), x_(x) { }
		virtual T const & operator[](size_t y) const { return parent_.data_[x_ * parent_.n_ + y]; }
		virtual T & operator[](size_t y) { return parent_.data_[x_ * parent_.n_ + y]; }
		virtual size_t size() const { return parent_.n_; }
	private:
		Field & parent_;
		size_t x_;
	};
	Field(size_t m, size_t n) : m_(m), n_(n), data_(m * n) { };
	Field(size_t m, size_t n, T val) : m_(m), n_(n), data_(m * n, val) { };
	Field2 const operator[](size_t x) const { return Field2(*this, x); };
	Field2 operator[](size_t x) { return Field2(*this, x); };
	size_t m() const { return m_; }
	size_t n() const { return n_; }
	vector<T> & data() { return data_; }
private:
	friend class Field2;
	size_t m_, n_;
	vector<T> data_;
};

L'objectif de la classe Field est de permettre d'appliquer deux fois l'opérateur [] à un vecteur représentant une matrice.

Je souhaite exécuter la fonction :

Code :

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

1
2
3
4
5
6
7
8
9
 
void printField(const ScalarField & p)
{
	for(size_t i = 0; i < p.m(); ++i) {
		for(size_t j = 0; j < p.n() - 1; ++j)
			cout << p[i][j] << '\t';
		cout << p[i][p.n()-1];
		if(i < p.m() - 1) cout << endl; }
}

Dans le cas où il n'y a pas de const devant l'argument, la fonction fonctionne correctement. Lorsque le const est là, j'obtiens l'erreur suivante :

math.hpp:63:66: error: no matching function for call to ‘Field<double>::Field2::Field2(const Field<double>&, size_t&)’
math.hpp:63:66: note: candidates are:
math.hpp:53:3: note: Field<T>::Field2::Field2(Field<T>&, size_t) [with T = double; Field<T> = Field<double>; size_t = long unsigned int]
math.hpp:53:3: note: no known conversion for argument 1 from ‘const Field<double>’ to ‘Field<double>&’
math.hpp:50:8: note: Field<double>::Field2::Field2(const Field<double>::Field2&)
math.hpp:50:8: note: candidate expects 1 argument, 2 provided

Je comprends que lorsqu'un objet est passé en const à une fonction, rien dans le corps de cette fonction ne doit altérer l'objet. Pour s'en assurer, toutes les fonctions appelées à partir de l'objet doivent être déclarées const.

Malheureusement, je ne vois pas comment régler ce problème...

En vous remerciant d'avance,

Nicolas.

[ternel]

Bonjour Nicolas,

Ta classe Field est une erreur de conception, lis donc dans la faq cette entrée et celle-ci.

L'explication y est assez claire pour que je ne la répète pas ici.

Pour ton problème proprement dit, j'ai l'impression qu'il manque de la constance de fonction dans ta classe (size(), par exemple)

[Nadd]

Merci pour votre réponse.

Je comprends parfaitement ! Je ne sais d'ailleurs plus pourquoi je me suis embarqué là-dedans, d'autant plus que j'avais déjà une implémentation maison d'une matrice basée sur l'opérateur (). L'explication donnée est très claire et très intéressante.

Merci encore,

Nicolas.