Discussion :

[CedricMocquillon]

Bonjour à tous,

Je me demandais s'il était possible d'appeler un setter à la lecture d'un flux plutôt que de passer par une variable temporaire. Ca donnerai un truc du genre:

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
 
class Foo
{
private:
  int valeur;
public:
  void setValeur(const int newVal)
  {
    assert(newVal != 100); //par exemple ou une levée d'exception
    valeur = newVal;
  }
};
 
int main (void)
{
  Foo f;
  ifstream file ("data.txt");
  file >> f.setValeur();
  file.close();
  return 0;
}

[Médinoc]

Non.
Par contre, tu peux faire une fonction qui retourne une référence. Mais elle ne pourra effectuer aucun contrôle sur la valeur.

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
class Foo
{
private:
  int valeur;
public:
  int & getRefValeur()
  {
      return valeur;
  }
};
 
int main (void)
{
  Foo f;
  ifstream file ("data.txt");
  file >> f.getRefValeur();
  file.close();
  return 0;
}

[Luc Hermitte]

Si on peut. En jouant avec des proxys.

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
struct Proxy {
    typedef int value_type; // templatisable, tout ça
    Proxy(value_type &i, value_type max ) : m_i(i), m_max(max) {}
    void set(value_type i)  { if (i<m_max) m_i=i; else throw .../return false }
private
    value_type & m_i;
    value_type const m_max; // ou un "boost::function m_predicate;"
};
 
std::istream & operator>>(std::istream&is, Proxy & p) {
    Proxy::value_type i;
    if (is >> i) { p.set(i); // exception ou code de retour ?}
    return is;
}
 
struct A {
    Proxy setI() { return Proxy(m_i, 42); }
    Proxy setJ() { return Proxy(m_j, 100); }
};

A raffiner, ... tout ça.

[Médinoc]

Tu peux aussi faire une classe pour vérifier:

Code C++ :

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
class IntSetter
{
public:
	typedef bool (*check_function)(int toCheck, intptr_t userData);
 
	explicit IntSetter(int *pInt, check_function func=0, intptr_t userData=0)
	 : m_pInt(pInt), m_func(func), m_userData(userData)
	{ }
 
	bool Set(int val) const
	{
		bool ok = true;
		if(m_func != 0)
			ok = m_func(val, m_userData);
		if(ok)
			*m_pInt = val;
		return ok;
	}
 
private:
	int * m_pInt;
	check_function m_func;
	intptr_t m_userData;
};
 
std::istream & operator>> (std::istream & is, IntSetter const &setter)
{
	int val;
	is >> val;
	setter.Set(val);
	return is;
}

Et l'utiliser ainsi:

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
class Foo
{
private:
	int valeur;
	static bool checkValeur(int newVal, intptr_t /*unused*/)
	{
		assert(newVal != 100); //par exemple ou une levée d'exception
		if(newVal != 100)
			return true;
		return false;
	}
public:
	IntSetter getSetValeur()
	{
		return IntSetter(&valeur, checkValeur);
	}
};
 
int main (void)
{
	Foo f;
	std::ifstream file ("data.txt");
	file >> f.getSetValeur();
	file.close();
	return 0;
}

Edit: Mince, post croisé avant que j'aie le temps de tester mon code...
Le code ci-dessus n'est pas testé...
Edit2: Testé et corrigé...

[Médinoc]

Et en voici une version Template:

Code C++ :

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
#include <iostream>
#include <fstream>
#include <cassert>
 
template< class T >
struct SetterUtil
{
	typedef bool (*check_function)(T toCheck);
	typedef bool (*ref_check_function)(T const & toCheck);
};
 
template< class T, class Verif=typename SetterUtil<T>::ref_check_function >
class Setter
{
public:
	typedef T value_type;
	typedef Verif check_type;
 
	explicit Setter(value_type *pValue, check_type checker=0)
	 : m_pValue(pValue), m_checker(checker)
	{ }
 
	bool Set(value_type const & val) const
	{
		bool ok = true;
		if(m_checker != 0)
			ok = m_checker(val);
		if(ok)
			*m_pValue = val;
		return ok;
	}
 
private:
	int * m_pValue;
	check_type m_checker;
};
 
template< class T, class Verif >
std::istream & operator>> (std::istream & is, Setter< T, Verif > const &setter)
{
	T val;
	is >> val;
	setter.Set(val);
	return is;
}
 
 
class Foo
{
private:
	int valeur;
	static bool checkValeur(int newVal)
	{
		assert(newVal != 100); //par exemple ou une levée d'exception
		if(newVal != 100)
			return true;
		return false;
	}
public:
	typedef Setter<int, SetterUtil<int>::check_function> setter_type;
	setter_type getSetValeur()
	{
		return setter_type(&valeur, checkValeur);
	}
};
 
void TestProxy(void)
{
	Foo f;
	std::ifstream file ("data.txt");
	file >> f.getSetValeur();
	file.close();
}

[Luc Hermitte]

Le code ci-dessus n'est pas testé...

T'inquiètes, le mien ne compile pas. ^^

[CedricMocquillon]

Merci beaucoup pour vos réponses très completes. Cependant, je crois que je vais rester avec mes variables temporaires (je ne pensai pas que les solutions pouvaient être aussi "compliquées"). Encore merci à tout les deux

[Médinoc]

Eh bien, la base est compliquée, mais la suite du code est assez réutilisable...