Valeur reste inchangée

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour, il se trouve que j'ai un problème assez génant. Bien que le programme soit loin d'être fini je vous donne le code afin que vous puissiez me dire d'ou provient l'erreur (du moins j'espere). Le code est très long à lire donc je vous conseille de lire que les parties "importantes". Merci de votre aide.

Voici mon main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "Menu.h"

int main()
{
        initialisations();
	Rectangle tmp(0,0,SCREEN_W/2,SCREEN_H/2, makecol(100,100,100));
	Rectangle fond_rect(0,0,SCREEN_W-1,SCREEN_H-1,makecol(255,255,0));
	Menu_Object img(2,0,tmp,true);
	Menu_Object fond(2,1,fond_rect);
	std::vector<Menu_Object> vect;
	vect.push_back(fond);
	vect.push_back(img);
	Menu menu(vect);
	menu.get_menu_object(1).set_visible(false);
        if(menu.get_menu_object(1).get_visible())
               allegro_message("error");
        show_mouse(screen);
        boucle(menu,NULL);
        return 0;
}

Voici ma classe rectangle (je vous la donne mais je ne pense pas que se soit le problème.

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
#ifndef DEF_RECTANGLE
#define DEF_RECTANGLE
 
#include <allegro.h>
#include <string>
#include "Structures_menu.h"
 
class Rectangle
{
	private :
		struct Emplacement position;
		BITMAP*fond;
		int col_fond;
		bool redim;
		int col_bordure;
	public :
		Rectangle(double,double,double,double,int, BITMAP*, int=-1);
		Rectangle(double,double,double,double, BITMAP*, int=-1);
		Rectangle(double,double,double,double,int, char*, int=-1);
		Rectangle(double,double,double,double, char*, int=-1);
		Rectangle(double,double,double,double,int, std::string, int=-1);
		Rectangle(double,double,double,double, std::string, int=-1);
		Rectangle(double,double,double,double, int=makecol(0,0,0), int=-1);
		Rectangle();
 
		bool is_in_rectangle(double,double);
		bool is_in_rectangle(int,int);
		BITMAP*get_bitmap_de_fond();
		bool set_bitmap_de_fond(BITMAP*,bool);
		bool set_bitmap_de_fond(char*,bool);
		bool set_bitmap_de_fond(std::string, bool);
		int get_col_fond();
		bool set_col_fond(int);
		bool get_redim();
		bool set_bordure_col(int);
		int get_bordure_col();
		bool move_rectangle(int nb, std::string );
		bool move_rectangle(int nb, char* );
		bool set_rectangle(struct Emplacement);
		Emplacement get_pos();
};
#endif

Voici ma classe Menu_Object

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
 
#ifndef DEF_MENU_OBJECT
#define DEF_MENU_OBJECT
 
#include <vector>
using std::vector;
 
#include <allegro.h>
#include "Rectangle.h"
 
 
class Menu_Object
{
	protected :
		int type;
		bool selection;
		int ordre;
		bool visible;
		Rectangle zone;
	public :
		Menu_Object(int,int,Rectangle&,bool=true);
 
		int get_ordre();
		int get_type();
		void set_ordre(int);
		bool get_selection();
		void set_selection(bool);
		bool get_visible();
		void set_visible(bool);
		Rectangle get_rectangle();
		virtual void dessiner();
};
 
#endif

Je vous donne aussi son .cpp

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
#include "Menu_Object.h"
#include "Rectangle.h"
#include <algorithm>
 
Menu_Object::Menu_Object(int type, int ordre, Rectangle& rect, bool visib)
{
	this->type=type;
	this->ordre=ordre;
	zone=rect;
	visible=visib;
}
 
int Menu_Object::get_ordre()
{
	return ordre;
}
int Menu_Object::get_type()
{
	return type;
}
void Menu_Object::set_ordre(int ordre)
{
	this->ordre=ordre;
}
bool Menu_Object::get_selection()
{
	return selection;
}
void Menu_Object::set_selection(bool setting)
{
	selection=setting;
}
bool Menu_Object::get_visible()
{
	return visible;
}
 
void Menu_Object::set_visible(bool visible)
{
	this->visible=visible;
}
 
Rectangle Menu_Object::get_rectangle()
{
	return zone;
}
 
 
void Menu_Object::dessiner()
{
	if(visible==false)
		return ;
	if(zone.get_bitmap_de_fond()==NULL)
		rectfill(screen,zone.get_pos().x1,zone.get_pos().y1,
						zone.get_pos().x2,zone.get_pos().y2,zone.get_col_fond());
	else
	{
		if((zone.get_redim()==false)||(zone.get_col_fond()<0))
		{
			masked_stretch_blit(zone.get_bitmap_de_fond(),screen,0,0,
								zone.get_bitmap_de_fond()->w,zone.get_bitmap_de_fond()->h,
								zone.get_pos().x1,zone.get_pos().y1,
								zone.get_pos().x2-zone.get_pos().x1,
								zone.get_pos().y2-zone.get_pos().y1);
		}
	}
}

Et pour finir je vous donne la classe Menu

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
#ifndef DEF_MENU
#define DEF_MENU
 
#include <allegro.h>
#include "Menu_Object.h"
 
class Menu
{
	private :
		vector<Menu_Object> MyMenu;
		bool(*fc_to_exit)(Menu&, void*);
		void(*exit_function)(Menu,void*);
	public :
		Menu(vector<Menu_Object>, void(*exit_function)(Menu,void*)=NULL);
		Menu(Menu_Object, void(*exit_function)(Menu,void*)=NULL);
		void set_fc_to_exit(bool(*)(Menu&,void*));
		bool do_fc_to_exit(void*);
		void add_object(Menu_Object);
		int get_num_objects();
		Menu_Object& get_menu_object(int);
		void exit_fc(void*param);
		bool is_on_object(int,double, double);
		void dessiner();
};
#endif

Je rajoute get_menu_object :

Code:

1
2
3
4
5
6
7
8
9
10
Menu_Object& Menu::get_menu_object(int object)
{
	if((object>=MyMenu.size())||(object<0))
	{
		allegro_message("error get_menu_object");
		return MyMenu[0];
	}
	Menu_Object reference=MyMenu[object];
	return reference; 
}

Et voila.

Et le problème s'est qu'il m'affiche le message error (voir ligne rouge dans le main).

Merci pour votre aide.

08/04/2010, 19h31
nikko34

C'est quoi l'erreur exacte?
08/04/2010, 19h34
NoIdea

Il rentre dans le If ce qui signifie que le set_visible à échoué
08/04/2010, 19h59
bruno_pages
Bonsoir,

je ne connais pas du tout la couche graphique que vous utilisez, mais est-ce que les index 1 ne devraient pas plutôt être 0, comme cela :
Code:

1 2 menu.get_menu_object(0).set_visible(false); if(menu.get_menu_object(0).get_visible()) ...
?

[edit]j'ai supposé que le fond et l'image sont un couple obligatoire et non deux objets séparés[/quote]
08/04/2010, 20h02
NoIdea

0 se serait pour changer l'objet fond alors que la je souhaite rendre l'objet img invisible. Ce sont 2 objets séparés qui servent pour un test d'une autre partie du programme
08/04/2010, 20h07
bruno_pages

ok, désolé, la supposition que j'avais placé dans l'[edit] est donc fausse

est-ce que set_visible() retourne une valeur indiquant si la chose c'est bien passée (et donc n'est pas void set_visible(...))?
08/04/2010, 20h10
NoIdea

Comme tu peux le voir dans le .cpp, set_visible retourne void (en principe il ne peut pas y avoir d'erreur : il s'agit juste d'une attribution). Quant à la couche graphique que j'utilise (elle ne concerne pas le problème) il s'agit d'allegro.
08/04/2010, 20h24
bruno_pages

:oops: je n'avais pas cherché ailleurs que la ligne en rouge, je pensais que cela attaquait une lib graphique :lol:

j'ai donc un peu mieux regardé et la réponse est simple, get_menu_object(int) retourne une valeur (temporaire), la modifier ne sert donc à rien, il aurait fallu retourner une référence
08/04/2010, 20h28
NoIdea

Bien que je ne comprenne pas pourquoi cette valeur serait temporaire (si ta un lien qui explique) je vais essayer de passer une référence.
08/04/2010, 20h31
bruno_pages

le retour d'une opération/fonction est placé en pile, difficile de ne pas être temporaire dans ces conditions, et si elle n'était pas temporaire cela voudrait dire qu'il y aurait une perte de mémoire définitive :aie:
08/04/2010, 20h37
NoIdea

J'obtiens toujours la même après passage en référence mais j'ai un warning :
"Reference to local variable "reference" returned"
Je vais éditer le code du haut. Finis d'éditer
08/04/2010, 20h45
bruno_pages
:cry: ok, donc vous n'avez pas compris le problème

ce que vous voulez c'est que menu.get_menu_object(1).set_visible(false) modifie l'élément de rang 1 du menu, il faut donc rendre non pas une copie (retour par valeur) de cet élément mais l'élément lui même, et en C++ cela ce fait via une référence

donc quelque chose comme
Code:

1 2 3 4 Menu_Object & Menu::get_menu_object(int r) { return MyMenu.at(r); }
08/04/2010, 20h48
bruno_pages

:massacre::furieux::fessee::rouleau::pan::zekill::alerte: on ne modifie pas un message qu'on a poster il y a longtemps, sinon comment voulez-vous que les lecteurs comprenne quelque chose ?
08/04/2010, 21h11
NoIdea

Je pense avoir compris ce que tu voulais dire mais il me semble que s'est ce que j'ai fait non ? (je renvoie bien un Menu_Object& dans la nouvelle version ?)
Pour l'erreur d'avoir éditer mon message je remet comme s'était ? et je rajoute la modification dans mon dernier message?
08/04/2010, 21h17
NoIdea

Quoi qu'il en soit, ta solution marche bien.
Merci beaucoup.

Citation:

Envoyé par NoIdea

Je pense avoir compris ce que tu voulais dire mais il me semble que s'est ce que j'ai fait non ? (je renvoie bien un Menu_Object& dans la nouvelle version ?)

ce qui compte ce n'est pas de retourner n'importe qu'elle référence, ce qui compte c'est de retourner la référence sur l'élément que l'on veut modifier.
MyMenu.at(r) (ou MyMenu[r]) retourne non pas une recopie de l'élement d'index r mais une référence vers celui-ci, et donc au final return MyMenu[r] retourne la référence vers cet élément, et grâce à cela menu.get_menu_object(1).set_visible(false) applique set_visible sur l'élément dont l'attibut visible sera modifié

Une référence de quelque chose c'est un pointeur vers cette chose, son adresse. il n'y a pas de différence fondamentale entre une référence et une adresse, simplement dans le cas d'une référence les déréférenciations permettant de 'traverser' l'adresse sont automatiquement faites par le compilateur :
Code:

1 2 3 4 5 6 7 8 9 int v = 123; int * ptr = &v; // pointe sur v int & ref = v; // pointe aussi sur v cout << *ptr << ' ' << ref; // affiche 123 123 *ptr = 456; // v vaut maintenant 456; ref = 789; // v vaut maintenant 789
par contre quand vous faites :
Code:

1 2 Menu_Object reference=MyMenu[object]; return reference;
vous recopiez MyMenu[object] et vous rendez non pas une référence sur l'élement devant être modifié mais sur la variable reference, et comme c'est une variable locale (temporaire) le compilateur vous indique l'erreur car une fois sorti de l'opération la référence rendue pointe sur quelque chose qui n'existe plus

Citation:

Pour l'erreur d'avoir éditer mon message je remet comme s'était ? et je rajoute la modification dans mon dernier message?

c'est comme vous voulez, simplement la prochaine fois donner ce qui est modifié dans une nouvelle réponse au lieu de modifier une ancienne

Ok merci. J'ai un autre problème (encore sur les références et sur ce projet), avec la fonction get_rectangle(). Encore une fois, je renvoie une copie et non une référence ce qui m'empêche de modifier la valeur. Je me suis dis qu'il serait peut être plus intéressant de changer le .h de Menu_Object avec une référence vers un Rectangle au lieu d'un Rectangle. Malheureusement mon compilateur m'indique que la référence n'est pas initialisée. Il me semble que si mais si quelqu'un pouvait m'indiquer l'erreur...

Je vous donne 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 class Menu_Object { protected : int type; bool selection; int ordre; bool visible; Rectangle& zone; public : Menu_Object(int,int,Rectangle&,bool=true); int get_ordre(); int get_type(); void set_ordre(int); bool get_selection(); void set_selection(bool); bool get_visible(); void set_visible(bool); Rectangle& get_rectangle(); virtual void dessiner(); };
et le .cpp
Code:

1 2 3 4 5 6 7 Menu_Object::Menu_Object(int type, int ordre, Rectangle& rect, bool visib) { //ERREUR INDIQUEE ICI ! zone=rect; this->type=type; this->ordre=ordre; visible=visib; }
La ligne d'erreur du compilateur est celle de l'accolade. De plus, aurais-je une référence vers une référence qui pointe sur rectangle ou une référence sur rectangle?

09/04/2010, 19h53
bruno_pages
Citation:

Envoyé par NoIdea

Je me suis dis qu'il serait peut être plus intéressant de changer le .h de Menu_Object avec une référence vers un Rectangle au lieu d'un Rectangle.

que voilà une très très mauvaise idée :aie:

de façon générale ne jamais utiliser de membre qui soient des références, utilisez un pointeur si vous devez mémoriser l'adresse de la chose et non directement la chose

Citation:

Malheureusement mon compilateur m'indique que la référence n'est pas initialisée.

et il a bien-sûr tout à fait raison

il fallait écrire
Code:

1 2 3 4 5 6 Menu_Object::Menu_Object(int type, int ordre, Rectangle& rect, bool visib) : zone(rect) { this->type=type; this->ordre=ordre; visible=visib; }
une variable/membre qui est une référence doit obligatoirement être initialisée
dans votre cas vous rentriez dans le corps du constructeur avec zone non initialisé
09/04/2010, 21h13
Davidbrcz

Citation:

de façon générale ne jamais utiliser de membre qui soient des références, utilisez un pointeur si vous devez mémoriser l'adresse de la chose et non directement la chose

Euh y'a une argumentation quelconque pour défendre ceci ?
Car je ne suis pas vraiment d'accord.

En faisant attention aux histoires de porté de l'objet sur lequel on fait une référence, il n'y aucun risque alors qu'avec un pointeur dans tous les cas, c'est la mouise: Est ce que je deviens responsable de l'objet ? Est ce que c'est un tableau ? est il non nul ? .....

de même que pour un pointeur 'simple' (une référence est de toute façon aussi un pointeur) on peut très bien pointé vers quelque chose qui n'existe plus

par contre affecter d'une telle instance sera bien 'dangereux', par exemple ci dessous l'opérateur= ne copie par l'instance (pas d'autre attribut que la référence) mais l'entier référencé :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class C { private: int & r; public: C(int & i) : r(i) {} C operator=(const C & a) { r = a.r; // ! } }; int main(int, char **) { int i1 = 1; int i2 = 2; C c1(i1); C c2(i2); c2 = c1; // i2 vaut maintenant 1 !

Voir 40 message(s) de cette discussion en une page