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.