Discussion :

[NoIdea]

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 :

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
#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 :

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
#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 :

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
 
#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 :

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
#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 :

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
#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 :

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

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.

[nikko34]

C'est quoi l'erreur exacte?

[NoIdea]

Il rentre dans le If ce qui signifie que le set_visible à échoué

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

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

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]

[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

[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(...))?

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

[bruno_pages]

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

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

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

[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

[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

[bruno_pages]

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 :

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

1
2
3
4
 
Menu_Object & Menu::get_menu_object(int r) {
  return MyMenu.at(r);
}

[bruno_pages]

on ne modifie pas un message qu'on a poster il y a longtemps, sinon comment voulez-vous que les lecteurs comprenne quelque chose ?

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

[NoIdea]

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

[bruno_pages]

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 :

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

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 :

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

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

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

[NoIdea]

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 :

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
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 :

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

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?

[bruno_pages]

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

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

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 :

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

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é

[Davidbrcz]

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

[bruno_pages]

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 :

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
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 !