begin process at 2012 05 29 08:33:30
  Trouver un code source :
 
dans
 
[ Dernières recherches ]
Accueil > Forum > 

C++ & C++ .NET

 > 

Divers

 > 

Divers

 > 

erreur de segmentation (segfault) sur un return int


Derniers messages déposésPoser une question dans le forum ou lancer une discussion

erreur de segmentation (segfault) sur un return int

mercredi 20 avril 2011 à 20:31:04 | erreur de segmentation (segfault) sur un return int

tiouil

Bonjour, decidemment j'aime bien ce forum ^^ et par la meme occasion les erreurs de segmentation car en ce moment c'est mon fort (Patato ou cptPingu .... êtes vous la !!!)

Alors je vous explique j'ai un projet de jeu avec la SFML, et une obligation d'utilisation d'une archi model/vue (sans controleur).

Le jeu s'appelle jeu de la vie : une matrice de cellules, on ajoute ou supprime des cellules, on appuie sur "play", et suivant le nombre de voisins (configuré par l'utilisateur), une cellule meurt ou non au temps t+1 et ainsi de suite. Les virus sont prevus mais pas encore de classe.

Voici donc la presque integralité de mon code (presque parce que j'ai des intros avant le jeu que je ne met pas car inutile ca fonctionne parfaitement).

SI jamais vous voyez que j'ai fait un ecart par rapport a l'architecture modele/vue merci de m'indiquer ou et des conseils si possible....

Je sais que le code est long mais comme cela vous pouvez compiler directement

ArchiVue.h

Code C/C++ :
#include "Position.h"
#include "Cellule.h"

using namespace sf;

class ArchiModel;
class Cellule;

class ArchiVue {
 private:
  int _w, _h;
   
  Position _p_pause, _p_play, _p_arret, _p_curseur_vitesse, _p_scroll_1, _p_scroll_2, _p_scroll_vitesse;
  Position _p_plus_ligne, _p_moins_ligne, _p_plus_colonne, _p_moins_colonne;
  Position _p_curseur_min_cell, _p_curseur_max_cell;
  Position _p_curseur_temps_incub, _p_curseur_nb_enfants;
  Position _click, _new_cell; // pour la matrice
  
  String _t_texte_min_cell, _t_texte_max_cell;
  String _t_texte_temps_incub, _t_texte_nb_enfants;
  String _t_texte_vitesse, _t_texte_cell, _t_texte_bact;  
  String _t_texte_ligne, _t_texte_colonne;
  
  Font _police;
  
  RenderWindow * _window;
  ArchiModel * _model;
  Cellule * _cellule;

  Image _background_image;
  Sprite _background_sprite;
  
  //jeu
  
  Sprite _new_cell_sprite;
  float _size_case_x, _size_case_y;
  float _size_new_cell_X, _size_new_cell_Y;
  
  //menu
  Image _menu_recap_plus_image;
  Image _menu_recap_moins_image;
  
  Sprite _menu_recap_plus_ligne_sprite;
  Sprite _menu_recap_moins_ligne_sprite;
  Sprite _menu_recap_plus_colonne_sprite;
  Sprite _menu_recap_moins_colonne_sprite;
  float _size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y;

  Image _menu_recap_image;
  Sprite _menu_recap_sprite;
  float _size_menu_recap_X, _size_menu_recap_Y;
  
  Image _menu_global_bact_image;
  Sprite _menu_global_bact_sprite;

  Image _menu_global_cell_image;
  Sprite _menu_global_cell_sprite;
  float _size_menu_global_onglet_Y, _size_menu_global_X; //identique pour les deux menu globaux (bact selectionné ou cell)

  Image _menu_pause_image;
  Sprite _menu_pause_sprite;
  float _size_menu_pause_X, _size_menu_pause_Y;
  
  Image _menu_play_image;
  Sprite _menu_play_sprite;
  float _size_menu_play_X, _size_menu_play_Y;	
	
  Image _menu_arret_image;
  Sprite _menu_arret_sprite;	
  float	_size_menu_arret_X, _size_menu_arret_Y;
  
  Image _menu_scroll_image; 
  Sprite _menu_scroll_1_sprite; // cell-> min voisines / bact -> tmps incubation
  float	_size_menu_scroll_X, _size_menu_scroll_Y;
  
  Sprite _menu_scroll_2_sprite;	//cell -> max voisines / bact -> nb enfants
  Sprite _menu_scroll_vitesse_sprite;	

  Image _menu_curseur_image;
  Sprite _menu_curseur_vitesse_sprite;	
  float	_size_menu_curseur_X, _size_menu_curseur_Y;
  
  //elements du menu cellule
  Sprite _menu_curseur_min_cell_sprite;	
  Sprite _menu_curseur_max_cell_sprite;	

  //elements du menu virus
  Sprite _menu_curseur_incub_virus_sprite;	
  Sprite _menu_curseur_enfant_virus_sprite;	
  
  //Cellules
  Image _cell_image;
  Sprite _cell_sprite;

  Image _cell_strong_image;
  Sprite _cell_strong_sprite;

  Image _cell_ill_image;
  Sprite _cell_ill_sprite;
  float _size_cell_Y, _size_cell_X; //toutes les cellules ont la meme taille
  
  //Virus
  Image _bact_image;
  Sprite _bact_sprite;
  float _size_bact_Y, _size_bact_X; 
  
 public:
 
  ArchiVue(int w, int h);
  ~ArchiVue();
  
  void setModel(ArchiModel * model);
  void setWH(RenderWindow* _window);
  float getSIZECASEX();
  float getSIZECASEY();
  
  void draw(bool &passerIntro, bool &affiche_onglet_cell);
  
  void dessineMatrice();
  
  //adaptation taille et position avec taille fenetre
  void majTaille();
  void majPos();
  
  bool treatEvents(bool &passerIntro, bool &affiche_onglet_cell);
};
#endif


ArchiVue.cc

Code C/C++ :
#include <iostream>
#include <cstdlib>
#include <SFML/Audio.hpp>
#include <vector>
#include "Position.h"
#include "ArchiVue.h"
#include "ArchiModel.h"
#include "Cellule.h"

using namespace std;
using namespace sf;

/****************************************
 			Constructeur
****************************************/	
	
ArchiVue::ArchiVue(int w, int h): _w(w), _h(h)
{
    _window = new RenderWindow(sf::VideoMode(w, h, 64), "Game of life", sf::Style::Resize);
    majTaille();
    majPos();
	
    _police.LoadFromFile("Ressources/Dauphin_ttf.ttf");
	
    _t_texte_min_cell.SetText("Nb voisines min");
    _t_texte_max_cell.SetText("Nb voisines max");
    _t_texte_temps_incub.SetText("Temps d'incubation");
    _t_texte_nb_enfants.SetText("Enfants par virus");
    _t_texte_vitesse.SetText("Vitesse defilement");
    _t_texte_cell.SetText("Cellules : 100");
    _t_texte_bact.SetText("Virus : 9999");
    _t_texte_colonne.SetText("colonnes");
    _t_texte_ligne.SetText("lignes");

    _t_texte_min_cell.SetFont(_police);
    _t_texte_min_cell.SetSize(18);
    _t_texte_min_cell.SetColor(sf::Color(162, 64, 162));
    _t_texte_min_cell.SetPosition(5, _p_curseur_min_cell.getPosY() - 18 - 5);
	
    _t_texte_max_cell.SetFont(_police);
    _t_texte_max_cell.SetSize(18);
    _t_texte_max_cell.SetColor(sf::Color(162, 64, 162));
    _t_texte_max_cell.SetPosition(5, _p_curseur_max_cell.getPosY() - 18 - 5);
	
    _t_texte_temps_incub.SetFont(_police);
    _t_texte_temps_incub.SetSize(18);
    _t_texte_temps_incub.SetColor(sf::Color(162, 64, 162));
    _t_texte_temps_incub.SetPosition(5, _p_curseur_temps_incub.getPosY() - 18 - 5);
	
    _t_texte_nb_enfants.SetFont(_police);
    _t_texte_nb_enfants.SetSize(18);
    _t_texte_nb_enfants.SetColor(sf::Color(162, 64, 162));
    _t_texte_nb_enfants.SetFont(_police);
    _t_texte_nb_enfants.SetPosition(5, _p_curseur_nb_enfants.getPosY() - 18 - 5);
		
    _t_texte_vitesse.SetFont(_police);
    _t_texte_vitesse.SetSize(18);
    _t_texte_vitesse.SetColor(sf::Color(162, 64, 162));
    _t_texte_vitesse.SetPosition(5, _p_curseur_vitesse.getPosY() - 18 - 5);
	
    _t_texte_cell.SetFont(_police);
    _t_texte_cell.SetSize(18);
    _t_texte_cell.SetColor(sf::Color(162, 64, 162));
    _t_texte_cell.SetPosition(_size_menu_global_X + 5, 6.5);
	
    _t_texte_bact.SetFont(_police);
    _t_texte_bact.SetSize(18);
    _t_texte_bact.SetColor(sf::Color(162, 64, 162));
    _t_texte_bact.SetPosition(_size_menu_global_X * 1.66, 6.5);

    _t_texte_ligne.SetFont(_police);
    _t_texte_ligne.SetSize(18);
    _t_texte_ligne.SetColor(sf::Color(162, 64, 162));
    _t_texte_ligne.SetPosition(_w - (8.32 * _size_menu_recap_PlusMoins_X), 6.5);
	
    _t_texte_colonne.SetFont(_police);
    _t_texte_colonne.SetSize(18);
    _t_texte_colonne.SetColor(sf::Color(162, 64, 162));
    _t_texte_colonne.SetPosition(_w - (3.4 * _size_menu_recap_PlusMoins_X), 6.5);
	
if (!_background_image.LoadFromFile("Ressources/LinuxWorld.jpg")
|| !_menu_global_bact_image.LoadFromFile("Ressources/Select_bact.png")
|| !_menu_global_cell_image.LoadFromFile("Ressources/Select_cell.png")
|| !_bact_image.LoadFromFile("Ressources/Virus.png")
|| !_cell_image.LoadFromFile("Ressources/Cellule.png")
|| !_cell_ill_image.LoadFromFile("Ressources/Cellule_malade.png")
|| !_cell_strong_image.LoadFromFile("Ressources/Cellule_resistante.png")
|| !_menu_scroll_image.LoadFromFile("Ressources/Scroll.png")
|| !_menu_curseur_image.LoadFromFile("Ressources/Curseur.png")
|| !_menu_recap_image.LoadFromFile("Ressources/Recap.png")
|| !_menu_recap_plus_image.LoadFromFile("Ressources/Plus.png")
|| !_menu_recap_moins_image.LoadFromFile("Ressources/Moins.png")
|| !_menu_pause_image.LoadFromFile("Ressources/Pause.png")
|| !_menu_play_image.LoadFromFile("Ressources/Play.png")
|| !_menu_arret_image.LoadFromFile("Ressources/Arret.png")
{
    //jeu
    _background_sprite = Sprite ();
    _cell_ill_sprite = Sprite ();
    _cell_strong_sprite = Sprite ();
    _cell_sprite = Sprite ();
    _bact_sprite = Sprite ();
    //menus
    _menu_global_bact_sprite = Sprite ();
    _menu_global_cell_sprite = Sprite ();
    _menu_pause_sprite = Sprite ();
    _menu_play_sprite = Sprite ();
    _menu_arret_sprite = Sprite ();
    _menu_scroll_1_sprite = Sprite ();
    _menu_scroll_2_sprite = Sprite ();
    _menu_scroll_vitesse_sprite = Sprite ();
    _menu_curseur_vitesse_sprite = Sprite ();
    _menu_recap_sprite = Sprite ();
    _menu_recap_plus_ligne_sprite = Sprite ();
    _menu_recap_moins_ligne_sprite = Sprite ();
    _menu_recap_plus_colonne_sprite = Sprite ();
    _menu_recap_moins_colonne_sprite = Sprite ();
    //onglet cell
    _menu_curseur_min_cell_sprite = Sprite ();
    _menu_curseur_max_cell_sprite = Sprite ();
   //onglet virus		
    _menu_curseur_incub_virus_sprite = Sprite ();
    _menu_curseur_enfant_virus_sprite = Sprite ();
}	
else 
{
//jeu
_background_sprite = Sprite (_background_image);
_background_sprite.Resize(_w, _h);
_background_sprite.SetPosition(0,0);
_new_cell_sprite = Sprite (_cell_image);
_new_cell_sprite.Resize(_size_new_cell_X, _size_new_cell_Y);
_new_cell_sprite.SetPosition(_new_cell.getPosX(), _new_cell.getPosY());
		
//menu		
_cell_ill_sprite = Sprite (_cell_ill_image);
_cell_ill_sprite.Resize(_size_cell_X, _size_cell_Y);
_cell_ill_sprite.SetPosition(_size_menu_global_X/2.75, _h/1.125);
_cell_strong_sprite = Sprite (_cell_strong_image);
_cell_strong_sprite.Resize(_size_cell_X, _size_cell_Y);
_cell_strong_sprite.SetPosition(_size_menu_global_X/2.75, _h/1.125);

_cell_sprite = Sprite (_cell_image);
_cell_sprite.Resize(_size_cell_X, _size_cell_Y);
_cell_sprite.SetPosition(_size_menu_global_X/2.75, _h/12.70);

_bact_sprite = Sprite (_bact_image);
_bact_sprite.Resize(_size_bact_X, _size_bact_Y);
_bact_sprite.SetPosition(_size_menu_global_X/3.5, _h/12.70);

_menu_global_bact_sprite = Sprite (_menu_global_bact_image);
_menu_global_bact_sprite.Resize(_size_menu_global_X, _h);
_menu_global_bact_sprite.SetPosition(0,0);		

_menu_global_cell_sprite = Sprite (_menu_global_cell_image);
_menu_global_cell_sprite.Resize(_size_menu_global_X, _h);
_menu_global_cell_sprite.SetPosition(0,0);	
		
_menu_pause_sprite = Sprite (_menu_pause_image);
_menu_pause_sprite.Resize(_size_menu_pause_X, _size_menu_pause_Y);
_menu_pause_sprite.SetPosition(_p_pause.getPosX(), _p_pause.getPosY());

_menu_play_sprite = Sprite (_menu_play_image);
_menu_play_sprite.Resize(_size_menu_play_X, _size_menu_play_Y);
_menu_play_sprite.SetPosition(_p_play.getPosX(), _p_play.getPosY());

_menu_arret_sprite = Sprite (_menu_arret_image);
_menu_arret_sprite.Resize(_size_menu_arret_X, _size_menu_arret_Y);
_menu_arret_sprite.SetPosition(_p_arret.getPosX(), _p_arret.getPosY());

_menu_scroll_1_sprite = Sprite (_menu_scroll_image);
_menu_scroll_1_sprite.Resize(_size_menu_scroll_X, _size_menu_scroll_Y);
_menu_scroll_1_sprite.SetPosition(_p_scroll_1.getPosX(), _p_scroll_1.getPosY());

_menu_recap_sprite = Sprite (_menu_recap_image);
_menu_recap_sprite.Resize(_size_menu_recap_X, _size_menu_recap_Y);
_menu_recap_sprite.SetPosition(_size_menu_global_X, 0);
		
_menu_recap_plus_ligne_sprite = Sprite (_menu_recap_plus_image);
_menu_recap_plus_ligne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);
_menu_recap_plus_ligne_sprite.SetPosition(_p_plus_ligne.getPosX(), _p_plus_ligne.getPosY());			
		
_menu_recap_moins_ligne_sprite = Sprite (_menu_recap_moins_image);
_menu_recap_moins_ligne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);	_menu_recap_moins_ligne_sprite.SetPosition(_p_moins_ligne.getPosX(), _p_moins_ligne.getPosY());

_menu_recap_plus_colonne_sprite = Sprite (_menu_recap_plus_image);
_menu_recap_plus_colonne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);
_menu_recap_plus_colonne_sprite.SetPosition(_p_plus_colonne.getPosX(), _p_plus_colonne.getPosY());			
		
_menu_recap_moins_colonne_sprite = Sprite (_menu_recap_moins_image);
_menu_recap_moins_colonne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);
_menu_recap_moins_colonne_sprite.SetPosition(_p_moins_colonne.getPosX(), _p_moins_colonne.getPosY());

_menu_scroll_2_sprite = Sprite (_menu_scroll_image);
_menu_scroll_2_sprite.Resize(_size_menu_scroll_X, _size_menu_scroll_Y);
_menu_scroll_2_sprite.SetPosition(_p_scroll_2.getPosX(), _p_scroll_2.getPosY());

_menu_scroll_vitesse_sprite = Sprite (_menu_scroll_image);
_menu_scroll_vitesse_sprite.Resize(_size_menu_scroll_X, _size_menu_scroll_Y);
_menu_scroll_vitesse_sprite.SetPosition(_p_scroll_vitesse.getPosX(), _p_scroll_vitesse.getPosY());

_menu_curseur_vitesse_sprite = Sprite (_menu_curseur_image); //scroll 3
_menu_curseur_vitesse_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_vitesse_sprite.SetPosition(_p_curseur_vitesse.getPosX(), _p_curseur_vitesse.getPosY());

//onglet Cellule
_menu_curseur_min_cell_sprite = Sprite (_menu_curseur_image);
_menu_curseur_min_cell_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_min_cell_sprite.SetPosition(_p_curseur_min_cell.getPosX(), _p_curseur_min_cell.getPosY());

_menu_curseur_max_cell_sprite = Sprite (_menu_curseur_image);
_menu_curseur_max_cell_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_max_cell_sprite.SetPosition(_p_curseur_max_cell.getPosX(), _p_curseur_max_cell.getPosY());
		
//onglet virus

_menu_curseur_incub_virus_sprite = Sprite (_menu_curseur_image);
_menu_curseur_incub_virus_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_incub_virus_sprite.SetPosition(_p_curseur_temps_incub.getPosX(), _p_curseur_temps_incub.getPosY());

_menu_curseur_enfant_virus_sprite = Sprite (_menu_curseur_image);
_menu_curseur_enfant_virus_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_enfant_virus_sprite.SetPosition(_p_curseur_nb_enfants.getPosX(), _p_curseur_nb_enfants.getPosY());
}

/***************************************
			Destructeur
***************************************/

ArchiVue::~ArchiVue()
{
  if(_window != 0)
    delete _window;
  if(_model != 0)
    delete _model;
  if(_cellule != 0)
    delete _cellule;
}

/***************************************
		Accesseur en ecriture
***************************************/

void ArchiVue::setModel(ArchiModel * model)
{
  _model = model;
}

void ArchiVue::setWH(RenderWindow* _window)
{
	_w = (_window->GetWidth());
	_h = (_window->GetHeight());
}



/****************************************
		Accesseur en lecture
****************************************/

float ArchiVue::getSIZECASEX()
{
	//size_x = _size_case_x;
	return _size_case_x;
} 

float ArchiVue::getSIZECASEY()
{
	//size_y = _size_case_y;
	return _size_case_y;
}

/****************************************
  Mise à jour des tailles et positions
****************************************/

void ArchiVue::majTaille()
{	
	//menus du jeu
	_size_menu_global_X = _w/4;
	_size_menu_global_onglet_Y = _h/15;
	_size_menu_pause_X = _w/17.019;
	_size_menu_pause_Y = _h/10.525;
	_size_menu_play_X = _w/17.019; 
	_size_menu_play_Y = _h/10.525;	
	_size_menu_arret_X = _w/15.6862;
	_size_menu_arret_Y = _h/11.764;
	_size_menu_scroll_X = _size_menu_global_X - 10;
	_size_menu_scroll_Y = _h/22 ;
    _size_menu_curseur_X = _w/150 ;
    _size_menu_curseur_Y = _h/14 ;
    _size_menu_recap_X = _w - _size_menu_global_X ;
	_size_menu_recap_Y = _size_menu_global_onglet_Y ;
	_size_menu_recap_PlusMoins_X = _w/23 ;
	_size_menu_recap_PlusMoins_Y = _size_menu_recap_Y - 10 ;
		
	//matrice
	_size_case_x = (_size_menu_global_X - (_w/(_model->getNBCOLONNES())));
	_size_case_y = (_size_menu_recap_Y - (_h/(_model->getNBLIGNES())));
			
	//Cellules
	_size_cell_X = _w/15 ;
	_size_cell_Y = _size_cell_X ; 
	
	//Virus
	_size_bact_X = _w/9 ;
	_size_bact_Y = _h/13 ; 
}

void ArchiVue::majPos()
{
	//Menu
    _p_pause.setPosX(_w/6.3) ;
    _p_pause.setPosY(_h/1.35) ;
    _p_play.setPosX(_w/27) ;
    _p_play.setPosY(_h/1.35) ;
    _p_arret.setPosX(_w/10.6) ;
    _p_arret.setPosY(_h/1.65) ; 
    _p_curseur_vitesse.setPosX(_w/162) ;
    _p_curseur_vitesse.setPosY(_h/2.027) ;
    _p_scroll_1.setPosX(_w/160) ;
    _p_scroll_1.setPosY(_h/4.25) ;
    _p_scroll_2.setPosX(_w/160) ;
    _p_scroll_2.setPosY(_h/2.70) ;
    _p_scroll_vitesse.setPosX(_w/160) ;
    _p_scroll_vitesse.setPosY(_h/1.98) ;
    
    //menu recap
    _p_plus_ligne.setPosX(_w/1.40);
    _p_plus_ligne.setPosY(4.5); 
    _p_moins_ligne.setPosX(_w/1.8);
    _p_moins_ligne.setPosY(4.5);
    _p_plus_colonne.setPosX(_w - _size_menu_recap_PlusMoins_X - 5);
    _p_plus_colonne.setPosY(4.5); 
    _p_moins_colonne.setPosX(_w/1.30);
    _p_moins_colonne.setPosY(4.5);
	
	//Onglet cellule
	_p_curseur_min_cell.setPosX(_w/162) ;
	_p_curseur_min_cell.setPosY(_h/4.47) ;
	_p_curseur_max_cell.setPosX(_w/162) ;
	_p_curseur_max_cell.setPosY(_h/2.8) ;
	
	//Onglet virus
	/*_p_curseur_temps_incub = _p_curseur_min_cell ;
	_p_curseur_nb_enfants = _p_curseur_max_cell ;*/
	_p_curseur_temps_incub.setPosX(_p_curseur_min_cell.getPosX());
	_p_curseur_temps_incub.setPosY(_p_curseur_min_cell.getPosY());
	_p_curseur_nb_enfants.setPosX(_p_curseur_max_cell.getPosX());
	_p_curseur_nb_enfants.setPosY(_p_curseur_max_cell.getPosY());

	//Matrice
	_new_cell.setPosX(0);
	_new_cell.setPosY(0);
}

/****************************************
		Affichage des images
****************************************/

void ArchiVue::draw(bool &affiche_onglet_cell)
{   
    setWH(_window); //ajustement fenetre : recuperation taille réel fenetre _w et _h  
    _window->Draw(_background_sprite); //Image de fond du jeu
    
    if(affiche_onglet_cell)
    {
		_window->Draw(_menu_global_cell_sprite);
		_window->Draw(_cell_sprite);		
		_window->Draw(_cell_strong_sprite);
	}
	else if(!affiche_onglet_cell)
    {
		_window->Draw(_menu_global_bact_sprite);			
		_window->Draw(_bact_sprite);
		_window->Draw(_cell_ill_sprite);
	}
	
	//controle de la simulation
	_window->Draw(_menu_pause_sprite);
	_window->Draw(_menu_play_sprite);
	_window->Draw(_menu_arret_sprite);
	_window->Draw(_menu_scroll_1_sprite);
	_window->Draw(_menu_scroll_2_sprite);
	_window->Draw(_menu_scroll_vitesse_sprite); // vitesse de defilement simulation
	_window->Draw(_menu_curseur_vitesse_sprite);
	_window->Draw(_menu_recap_sprite);
	_window->Draw(_menu_recap_plus_ligne_sprite);
    _window->Draw(_menu_recap_moins_ligne_sprite);
	_window->Draw(_menu_recap_plus_colonne_sprite);
	_window->Draw(_menu_recap_moins_colonne_sprite);
	_window->Draw(_t_texte_vitesse);
    _window->Draw(_t_texte_cell);
    _window->Draw(_t_texte_bact);	
    _window->Draw(_t_texte_colonne);
    _window->Draw(_t_texte_ligne);
    
    dessineMatrice();
	
	if(affiche_onglet_cell) //meme test que dessus car il faut afficher le fond puis l'onglet puis scroll puis curseur...
	{
		_window->Draw(_t_texte_min_cell);
		_window->Draw(_t_texte_max_cell);
		
		_window->Draw(_menu_curseur_min_cell_sprite);
		_window->Draw(_menu_curseur_max_cell_sprite);	
	}
	else if(!affiche_onglet_cell)
    {			
		_window->Draw(_menu_curseur_incub_virus_sprite);
		_window->Draw(_menu_curseur_enfant_virus_sprite);

		_window->Draw(_t_texte_temps_incub);
		_window->Draw(_t_texte_nb_enfants);
	}	
    _window->Display();
    usleep(500);
  }
}

/******************************************************
			   Dessin de la matrice
******************************************************/

void ArchiVue::dessineMatrice()
{	
	vector<vector<bool> > _matrice_cellules_T;	
	_matrice_cellules_T.resize(_model->getNBLIGNES(), vector<bool>(_model->getNBCOLONNES(), false));
	_matrice_cellules_T = (_cellule->getMATRICECELLT());
	for(int i=0; i < _model->getNBCOLONNES(); i++)
	{
		for(int j=0; j < _model->getNBLIGNES(); j++)
		{
				if(_matrice_cellules_T[i][j]) // on affiche la matrice actuelle 
				{
					// taille d'une cellule adaptée au nombre de L et Col
					_new_cell_sprite.Resize(((_size_case_x) -2), ((_size_case_y) -2));
					_new_cell.setPosX((i * (_size_case_x)) + _size_menu_global_X + 1);
					_new_cell.setPosY((j * (_size_case_y)) + _size_menu_recap_Y + 1);
					_new_cell_sprite.SetPosition(_new_cell.getPosX(), _new_cell.getPosY());
					_window->Draw(_new_cell_sprite);
				}
		}
		
	}
}

	usleep(5000);
}

/******************************************************
			   Traitement des evenements
	Retourne false si un evenement de fin est reçu
******************************************************/

bool ArchiVue::treatEvents(bool &affiche_onglet_cell)
{
	bool result = false;
	if(_window->IsOpened())
	{
		result = true;
		Event event;
		// const Input &input = _window->GetInput(); pour curseurs suivents souris ---- fonctionne pas
		while (_window->GetEvent(event))
		{
			int MouseX = _window->GetInput().GetMouseX(); //recupere position souris x
			int MouseY = _window->GetInput().GetMouseY(); // idem en y
			
			//valable tout le temps
			if ((event.Type == sf::Event::Closed) || (((event.Type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Escape))))
			{
				_window->Close();
				result = false;
			}
			
//mise a jour = adapte nouvelle taille fenetre grace a GetWidth et GetHeight dans draw
			_w = _window->GetWidth();
			_h = _window->GetHeight();
			majTaille();
			majPos();				
			
                        if((event.Type == sf::Event::MouseButtonPressed) && (event.MouseButton.Button == sf::Mouse::Left)) 
			{
				/** clics dans le menu **/
				//selection de l'onglet cellule
				if((MouseX >= 0) && (MouseX <= (_size_menu_global_X/2)) && (MouseY >= 0 ) && (MouseY <= _size_menu_global_onglet_Y))
				{
					affiche_onglet_cell = true;
				}
				//selection de l'onglet virus
				else if((MouseX >= (_size_menu_global_X/2)) && (MouseX <= _size_menu_global_X) && (MouseY >= 0 ) && (MouseY <= _size_menu_global_onglet_Y))
				{
					affiche_onglet_cell = false;
				}
						
				/** clics sur boutons du menu **/
				
				/** Dans l'onglet cellule **/
				if(affiche_onglet_cell)
				{
					//curseur min cellules voisines -> clic sur scroll
					if((MouseX >= _p_scroll_1.getPosX()) && (MouseX <= (_p_scroll_1.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_1.getPosY()) && (MouseY <= (_p_scroll_1.getPosY() + _size_menu_scroll_Y)))
					{
						_p_curseur_min_cell.setPosX(MouseX);
								_menu_curseur_min_cell_sprite.SetPosition(_p_curseur_min_cell.getPosX(), _p_curseur_min_cell.getPosY());		
					}
					//curseur max cellule -> clic sur scroll						else if((MouseX >= _p_scroll_2.getPosX()) && (MouseX <= (_p_scroll_2.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_2.getPosY()) && (MouseY <= (_p_scroll_2.getPosY() + _size_menu_scroll_Y)))
					{
								_p_curseur_max_cell.setPosX(MouseX);
								_menu_curseur_max_cell_sprite.SetPosition(_p_curseur_max_cell.getPosX(), _p_curseur_max_cell.getPosY());
					}
					/*else if(event.Type == sf::Event::MouseMoved) // les curseurs suivent la souris marche pas
					{
							if((MouseX >= _p_curseur_min_cell.getPosX()) && (MouseX <= (_p_curseur_min_cell.getPosX() + _size_menu_curseur_X)) && (MouseY >= _p_curseur_min_cell.getPosY()) && (MouseY <= (_p_curseur_min_cell.getPosY() + _size_menu_curseur_Y))) //deplacement curseur min cell
							{
								_p_curseur_min_cell.setPosX(event.MouseMove.X);
						    	_menu_curseur_min_cell_sprite.SetPosition(_p_curseur_min_cell.getPosX(), _p_curseur_min_cell.getPosY());
								cout<<"suivi min cell"<<endl;
							}
							else if((MouseX >= _p_curseur_max_cell.getPosX()) && (MouseX <= (_p_curseur_max_cell.getPosX() + _size_menu_curseur_X)) && (MouseY >= _p_curseur_max_cell.getPosY()) && (MouseY <= (_p_curseur_max_cell.getPosY() + _size_menu_curseur_Y))) // idem max cell
							{
								_p_curseur_max_cell.setPosX(event.MouseMove.X);
						    	_menu_curseur_max_cell_sprite.SetPosition(_p_curseur_max_cell.getPosX(), _p_curseur_max_cell.getPosY());
								cout<<"suivi max cell"<<endl;
							}
					}	*/
						}
				/** Dans l'onglet virus **/
				else if(!affiche_onglet_cell)
				{
					//curseur temps d'incubation
					if((MouseX >= _p_scroll_1.getPosX()) && (MouseX <= (_p_scroll_1.getPosX() + _size_menu_scroll_X + 1- _size_menu_curseur_X)) && (MouseY >= _p_scroll_1.getPosY()) && (MouseY <= (_p_scroll_1.getPosY() + _size_menu_scroll_Y)))
					{
						_p_curseur_temps_incub.setPosX(MouseX);
						_menu_curseur_incub_virus_sprite.SetPosition(_p_curseur_temps_incub.getPosX(), _p_curseur_temps_incub.getPosY());						}
					//curseur nb enfants par virus
					else if((MouseX >= _p_scroll_2.getPosX()) && (MouseX <= (_p_scroll_2.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_2.getPosY()) && (MouseY <= (_p_scroll_2.getPosY() + _size_menu_scroll_Y)))
					{
						_p_curseur_nb_enfants.setPosX(MouseX);
						_menu_curseur_enfant_virus_sprite.SetPosition(_p_curseur_nb_enfants.getPosX(), _p_curseur_nb_enfants.getPosX());
					}
					
						}
						
				/** Objets communs **/
				
				//play
				if((MouseX >= _p_play.getPosX()) && (MouseX <= (_p_play.getPosX() + _size_menu_play_X)) && (MouseY >= _p_play.getPosY()) && (MouseY <= (_p_play.getPosY() + _size_menu_play_Y)))
				{
					cout<<"clic sur play"<<endl;
				}
				//pause
				else if((MouseX >= _p_pause.getPosX()) && (MouseX <= (_p_pause.getPosX() + _size_menu_pause_X)) && (MouseY >= _p_pause.getPosY()) && (MouseY <= (_p_pause.getPosY() + _size_menu_pause_Y)))
				{
					cout<<"clic sur pause"<<endl;
				}
				//arret
				else if((MouseX >= _p_arret.getPosX()) && (MouseX <= (_p_arret.getPosX() + _size_menu_arret_X)) && (MouseY >= _p_arret.getPosY()) && (MouseY <= (_p_arret.getPosY() + _size_menu_arret_Y)))
				{
					cout<<"clic sur arret"<<endl;
				}
				//curseur vitesse de defilement
				else if((MouseX >= _p_scroll_vitesse.getPosX()) && (MouseX <= (_p_scroll_vitesse.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_vitesse.getPosY()) && (MouseY <= (_p_scroll_vitesse.getPosY() + _size_menu_scroll_Y)))
				{
					_p_curseur_vitesse.setPosX(MouseX);
					_menu_curseur_vitesse_sprite.SetPosition(_p_curseur_vitesse.getPosX(), _p_curseur_vitesse.getPosY());
				}
				// - ligne
				else if((MouseX >= _p_moins_ligne.getPosX()) && (MouseX <= (_p_moins_ligne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_moins_ligne.getPosY()) && (MouseY <= (_p_moins_ligne.getPosY() + _size_menu_recap_PlusMoins_Y)))
				{
					if(_model->getNBLIGNES() > 0)
					{
						cout<<"- 1 ligne"<<endl;
						_model->setNBLIGNES(_model->getNBLIGNES() - 1);
					}
				}
				// + ligne
				else if((MouseX >= _p_plus_ligne.getPosX()) && (MouseX <= (_p_plus_ligne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_plus_ligne.getPosY()) && (MouseY <= (_p_plus_ligne.getPosY() + _size_menu_recap_PlusMoins_Y)))
				{
					if(_model->getNBLIGNES() < 10)
					{
						cout<<"+ 1 ligne"<<endl;
						_model->setNBLIGNES(_model->getNBLIGNES() + 1);
					}
				}
				// - colonne
				else if((MouseX >= _p_moins_colonne.getPosX()) && (MouseX <= (_p_moins_colonne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_moins_colonne.getPosY()) && (MouseY <= (_p_moins_colonne.getPosY() + _size_menu_recap_PlusMoins_Y)))
				{
					if(_model->getNBCOLONNES() > 0)
					{
						_model->setNBCOLONNES(_model->getNBCOLONNES() - 1);
						cout<<"- 1 colonne"<<endl;
					}
				}
				// + colonne
				else if((MouseX >= _p_plus_colonne.getPosX()) && (MouseX <= (_p_plus_colonne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_plus_colonne.getPosY()) && (MouseY <= (_p_plus_colonne.getPosY() + _size_menu_recap_PlusMoins_Y)))
				{
					if(_model->getNBCOLONNES() < 12)
					{
						_model->setNBCOLONNES(_model->getNBCOLONNES() + 1);
						cout<<"+ 1 colonne"<<endl;
					}
				}	
				
				/** Dans la matrice **/		
				// clic gauche pour ajouter une cellule							if(((MouseX > _size_menu_global_X) && (MouseX < _w)) && ((MouseY > _size_menu_recap_Y) && (MouseY < _h)))
				{
					_click.setPosX(MouseX - _size_menu_global_X); // On va donc envoyer la position de la souris 
	
				_click.setPosY(MouseY - _size_menu_recap_Y); // qui sera dans la matrice
					// pause = true;
					bool ajout = true;
					_cellule->ajoutOuSuppCellule(_click, ajout);
				}
			}
			else if((event.Type == sf::Event::MouseButtonPressed) && (event.MouseButton.Button == sf::Mouse::Right))
			{
				// clic droit pour supprimer une cellule
				if(((MouseX > _size_menu_global_X) && (MouseX < _w)) && ((MouseY > _size_menu_recap_Y) && (MouseY < _h)))
						{
                        _click.setPosX(MouseX - _size_menu_global_X); 
			_click.setPosY(MouseY - _size_menu_recap_Y);
			// pause = true;
			bool ajout = false;
			_cellule->ajoutOuSuppCellule(_click, ajout);
		                }
			}
	}				
	}
		} 
  return result;
}


ArchiModel.h

Code C/C++ :
#ifndef _ARCHI_MODEL_
#define _ARCHI_MODEL_

#include <SFML/System.hpp>
#include <vector>
#include "Cellule.h"

using namespace std;

class Cellule;

class ArchiModel {
 private:
  int _w, _h;
  int _nb_lignes, _nb_colonnes;
  
  Cellule * _cellule;

 public:

  ArchiModel();
  ArchiModel(int w, int h);
  ~ArchiModel();
  
  //vector<vector<bool> > getMATRICECELLTM() const;
  
  int getNBCOLONNES();
  void setNBCOLONNES(int nb);
  
  int getNBLIGNES();
  void setNBLIGNES(int nb);
  
  void nextStep();
  
};
#endif
[code=cpp]


ArchiModel.cc

[code=cpp]
#include <vector>
#include <iostream>
#include <cstdlib>
#include "ArchiModel.h"
#include "Cellule.h"

using namespace std;

/****************************************
 			Constructeur
****************************************/
ArchiModel::ArchiModel() : _w(800), _h(600)
{
	_nb_lignes = 4; 
	_nb_colonnes = 4;
}

ArchiModel::ArchiModel(int w, int h) :  _w(w), _h(h)
{

}

/****************************************
 			Destructeur
****************************************/

ArchiModel::~ArchiModel()
{
	if(_cellule != 0)
		delete _cellule;
}

/****************************************
 		Accesseurs en lecture
****************************************/

int ArchiModel::getNBCOLONNES()
{
	return _nb_colonnes;
} 

int ArchiModel::getNBLIGNES()
{
	return _nb_lignes;
}

/****************************************
 		Accesseurs en ecriture
****************************************/

void ArchiModel::setNBLIGNES(int nb)
{
	_nb_lignes = nb;
}

void ArchiModel::setNBCOLONNES(int nb)
{
	_nb_colonnes = nb;
}

/****************************************
 			Prochaine etape
****************************************/
void ArchiModel::nextStep(){
	//on prepare la matrice future T+1
}


Cellule.h

Code C/C++ :
#ifndef _CELLULE_
#define _CELLULE_

#include <vector>
#include "ArchiModel.h"
#include "ArchiVue.h"

class ArchiModel;
class ArchiVue;

using namespace std;

class Cellule 
{
	private :
		vector<vector<bool> > _matrice_cellules_T;
		//vector<vector<bool> > _matrice_cellules_T_1;
		
		int _nb_voisins ;
		int _max_nb_voisins,  _min_nb_voisins;
		
		ArchiModel* _model;
		ArchiVue* _vue;
		
	public:
		Cellule();
		//Cellule(int x , int y , vector<vector<bool> > _m_matrice_cellules, int _nb_voisins , int _max_nb_voisins , int _min_nb_voisins);
		~Cellule();
		
		vector<vector<bool> > getMATRICECELLT() const;
		
		void ajoutOuSuppCellule(Position click, bool ajout);
		void Generation();
		//void Meurt();
		//Resistance();
};
#endif


Cellule.cc

Code C/C++ :
#include <vector>
#include "Cellule.h"
#include "ArchiVue.h"
#include "ArchiModel.h"
#include <iostream>
#include <cstdlib>

using namespace std;

Cellule::Cellule()
{
	_matrice_cellules_T.resize(_model->getNBLIGNES(), vector<bool>(_model->getNBCOLONNES(), false)); // initialisation matrice 2D à faux
	//_matrice_cellules_T_1.resize(_vue->getNBLIGNES(), vector<bool>(_vue->getNBCOLONNES(), false));
	_nb_voisins = 0 ;
	_max_nb_voisins = 0;
	_min_nb_voisins = 8;

}

Cellule::~Cellule()
{
  if(_model != 0)	
	delete _model;
  if(_vue != 0)	
	delete _vue;
}

vector<vector<bool> > Cellule::getMATRICECELLT() const
{
	return _matrice_cellules_T;
}


void Cellule::ajoutOuSuppCellule(Position click, bool ajout)
{
	float size_case_x = (_vue->getSIZECASEX());
	float size_case_y = (_vue->getSIZECASEY());
	
	for(int i=0; i < (_model->getNBCOLONNES()); i++)
	{
		for(int j=0; j < (_model->getNBLIGNES()); j++)
		{
			if(((click.getPosX() > (i * size_case_x)) && (click.getPosX() < ((i * size_case_x) + size_case_x))) // on a trouve la case 
			&& ((click.getPosY() > (j * size_case_y)) && (click.getPosY() < ((j * size_case_y) + size_case_y)))) //où le clique s'est produit	
			{
				if(ajout) // on veut ajouter une cellule
				{
					_matrice_cellules_T[i][j] = true;
				}
				else // on veut supprimer une cellule car on ne veut pas en ajouter une (!ajout)
				{
					_matrice_cellules_T[i][j] = false;	
				}
				i = _model->getNBCOLONNES(); // on a trouve la case et mis a jour la matrice donc on sort
				j = _model->getNBLIGNES();
			}
		}
	}
}


Position.h

Code C/C++ :
#ifndef _POSITION_
#define _POSITION_

#include <SFML/System.hpp>

class Position{

 private:
  float _pos_x, _pos_y;

 public:

  Position();
  ~Position();

  int getPosX();
  int getPosY();  
  void setPosX(float _x);
  void setPosY(float _y);
    
};
#endif


Position.cc

Code C/C++ :
#include "Position.h"

using namespace std;

/****************************************
			Constructeur
****************************************/
Position::Position()
{	
	_pos_x = 0;
	_pos_y = 0;
}

/****************************************
			Destructeur
****************************************/  
Position::~Position()
{
}

/****************************************
	     Accesseurs en ecriture
****************************************/

int Position::getPosX()
{
	return _pos_x;
}

int Position::getPosY()
{
	return _pos_y;
}

/****************************************
	     Accesseurs en ecriture
****************************************/

void Position::setPosX(float _x)
{
	_pos_x = _x;
}

void Position::setPosY(float _y)
{
	_pos_y = _y;
}


main.cc

Code C/C++ :
#include "ArchiVue.h"
#include "ArchiModel.h"
const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 600;

using namespace std;

int main(){
  srand(time(NULL));

  bool affiche_onglet_cell = true;
  
  ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT);
  ArchiVue * view = new ArchiVue(SCREEN_WIDTH, SCREEN_HEIGHT);
  view->setModel(model);
  
  while(view->treatEvents(affiche_onglet_cell))
  {
    model->nextStep();
    view->draw(affiche_onglet_cell);
  }
  delete view;
  delete model;
  
  return EXIT_SUCCESS;
}




Merci à tous pour votre extreme patience, et pour vos reponse qui je le sais seront pertinentes !!!
mercredi 20 avril 2011 à 20:33:25 | Re : erreur de segmentation (segfault) sur un return int

tiouil
J'ai oublié de precisé, je programme sous linux en c++, et l'erreur de segmentation et sur le return _nb_colonnes.

Mais je sais que si je les inverses il y en a aussi un sur return _nb_lignes (toujours dans le model) et il me semble que parfois aussi dans le return _matrice_cellules_T de cellule.cc
mercredi 20 avril 2011 à 23:27:23 | Re : erreur de segmentation (segfault) sur un return int

patatalo

Membre Club Administrateur CodeS-SourceS
Réponse acceptée !
salut,

Le constructeur que tu utilises pour ArchiModel n'initialise pas _nb_colones et _nb_lignes. Si il sont initialisés à 0, tu obtiens une division par 0.

@++
mercredi 20 avril 2011 à 23:45:13 | Re : erreur de segmentation (segfault) sur un return int

tiouil
Encore une fois merci pour ta réponse mais je ne vois pas pourquoi tu dis cela car pourtant je le fait dans ArchiModel.cc :


ArchiModel::ArchiModel() : _w(800), _h(600)
{
_nb_lignes = 4;
_nb_colonnes = 4;
}






Cyril Z.
jeudi 21 avril 2011 à 11:16:56 | Re : erreur de segmentation (segfault) sur un return int

patatalo

Membre Club Administrateur CodeS-SourceS
re,

Désolé mais moi je vois:
ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT);

@++
jeudi 21 avril 2011 à 11:30:23 | Re : erreur de segmentation (segfault) sur un return int

tiouil
HEHE, moi je vois les 2. Peux-tu être plus précis stp.


Cyril Z.
jeudi 21 avril 2011 à 11:34:03 | Re : erreur de segmentation (segfault) sur un return int

CptPingu

Administrateur CodeS-SourceS
Évite les "using namespace", voir: [ Lien ]

Pour la prochaine fois, merci de poster un code qui compile vraiment !
(Et de dégager tous ce qui concerne sfml, vu que je ne l'ai pas, j'ai galéré à faire une fausse classe à partir des messages d'erreurs de compil...)

Code C/C++ :
#ifndef FAKE_HH_
# define FAKE_HH_

namespace sf
{
  struct Font
  {
    void LoadFromFile(const std::string&) {}
  };

  struct Image
  {
    bool LoadFromFile(const std::string&) {}
  };

  struct Sprite
  {
    Sprite() {}
    Sprite(const Image&) {}
    void Resize(float, float) {}
    void SetPosition(float, double) {}
  };

  struct Color
  {
    Color(int, int, int) {}
  };

  struct Style
  {
    static void Resize(float, float) {}
  };

  struct VideoMode
  {
    VideoMode(int, int, int) {}
  };

  struct String
  {
    void SetText(const std::string&) {}
    void SetFont(const Font&) {}
    void SetSize(const int&) {}
    void SetColor(const Color&) {}
    void SetPosition(float, double) {}
  };

  struct Event
  {
    int Type() {}
    int Key() {}
    bool Closed() {}
    int KeyPressed() {}
  };

  struct Input
  {
    int GetMouseX() {}
    int GetMouseY() {}
    int MouseButton() {}
  };

  struct RenderWindow
  {
    RenderWindow(const VideoMode&, const char*, void (&)(float, float)) {}
    void Draw(const String&) {}
    void Draw(const Sprite&) {}
    int GetWidth() const {}
    int GetHeight() const {}
    void Display() const {}
    bool IsOpened() const { return true; }
    bool GetEvent(Event&) {}
    Input GetInput() {}
    void Close() {}
  };
}

#endif /* !FAKE_HH_ */


Avec cette fausse classe, j'ai pu compiler et passer un coup de gdb (il faut apprendre à s'en servir), qui m'a dit:


gdb ./a.out
Reading symbols from /tmp/soso/a.out...done.
gdb$ r

Program received signal SIGSEGV, Segmentation fault.
0x0000000000400ee8 in ArchiModel::getNBCOLONNES (this=0x0) at ArchiModel.cc:39
39 return _nb_colonnes;
gdb$ bt
#0 0x0000000000400ee8 in ArchiModel::getNBCOLONNES (this=0x0) at ArchiModel.cc:39
#1 0x00000000004043fe in ArchiVue::majTaille (this=0x60d030) at ArchiVue.cc:296
#2 0x0000000000401381 in ArchiVue::ArchiVue (this=0x60d030, w=0x320, h=0x258) at ArchiVue.cc:20
#3 0x0000000000409a38 in main () at main.cc:15



Ici, on voit que "ArchiModel::getNBCOLONNES (this=0x0)". Comme this == 0, ça veut dire que tu fais 0->getNBCOLONNES, et donc ça plante.

_model n'est pas initialisé, tout simplement.

________________________________________________________________________
Historique de mes créations, et quelques articles:
http://0217021.free.fr/portfolio
Merci d'utiliser Réponse acceptée si un post répond à votre question
jeudi 21 avril 2011 à 11:38:02 | Re : erreur de segmentation (segfault) sur un return int

CptPingu

Administrateur CodeS-SourceS
Réponse acceptée !
@patatalo: Ce n'est pas le soucis, mais le code n'est pas consistent, ce qui t'a trompé (et moi aussi au début).

@tiouil: Initialise tout de la même manière. Dès que tu peux utiliser la liste d'initialisation, utilise là !

Ex:

Code C/C++ :
ArchiModel::ArchiModel() : _w(800), _h(600)
{
// Du code
_nb_lignes = 4;
_nb_colonnes = 4;
}


Devrait être:
Code C/C++ :
ArchiModel::ArchiModel()
 : _w(800), _h(600), _nb_lignes(4), _nb_colonnes(4)
{
// Du code
}


________________________________________________________________________
Historique de mes créations, et quelques articles:
http://0217021.free.fr/portfolio
Merci d'utiliser Réponse acceptée si un post répond à votre question
jeudi 21 avril 2011 à 11:53:26 | Re : erreur de segmentation (segfault) sur un return int

tiouil
Lu, desolé pour les namespace mais je n'ai pas changé, je ne sais toujours pas quelle fonction fait partie de std donc.....

Sinon si je fait juste ca


ArchiModel::ArchiModel()
: _w(800), _h(600), _nb_lignes(4), _nb_colonnes(4)
{
// Du code
}



ca marche ???

Du code, du code, mais la j'en ai pas besoin vu que je fait des redirections.
Comment l'initialisé comme vous dite, du moins qu'est ce que je n'est pas initialisé ?

Merci a vous deux, toujours present je vois ^^.

ps : j'etais en train d'ameliorer mon code car comme vous avez pu le voir j'ai des _size_w, _size_h, apres je rappelle autre chose pour la position, c'etait le zouk, donc je me suis arrange ma classe position et j'ai fait une classe objet comme ca moins de variables et code plus clair. Je pense finir dans l'aprem car revoir tout mon code c'est long.... je vous tiens au courant pour le debuggage, si vous m'avez un peu plus eclairé

Cyril Z.
jeudi 21 avril 2011 à 12:05:24 | Re : erreur de segmentation (segfault) sur un return int

CptPingu

Administrateur CodeS-SourceS

// Du code


C'est une généralité pour illustrer le problème. J'ai bien vu que tu n'avais pas de code.

Toujours utiliser la liste d'initialisation c'est important. Ce n'est pas tout à fait pareil que d'initialiser une variable dans le constructeur.

Ex.

Soit la classe:
Code C/C++ :
class Toto
{
public:
  Toto(int i);
private:
  const int _i;
};


Code C/C++ :
Toto::Toto(int i)
{
  i_ = i; // Ne compilera pas
}


Code C/C++ :
Toto::Toto(int i)
 : i_(i) // Aucun souci
{
}


Utile pour des attributs const, ou des références.

________________________________________________________________________
Historique de mes créations, et quelques articles:
http://0217021.free.fr/portfolio
Merci d'utiliser Réponse acceptée si un post répond à votre question

1 2 3

Cette discussion est classée dans : menu, curseur, sprite, size, cell

Répondre à ce message

Sujets en rapport avec ce message

comment supprimer curseur ds un menu deroulant? [ par Topper ] tout est ds la question Créer un bouton ms-dos [ par casanoveg ] Salut tout le monde :) Alors que j'ai superbement bien avancé dans la conception de l'éditeur de carte du jeu qui me tient à coeur et qui ne va pas t Curseur en C allegro [ par lakeeee ] Salut, je suis en train de coder en C un memory, j'utilise allegro et j'aimerais changer le curseur de la souris mais malgrès plusieurs recherches je Pb avec D3DXCreateTextureFromFileInMemory [ par DIMUSERS ] Bonjour,Je vous soumet un code qui ne fonctionne pas ! Le but recherché est de créer une texture avec un texte issu d'une fonte du GDI. Le code retour STL: pb mémoire "physique" non libérée avec un vector [ par pipocodesrc ] Bonjour à tous, j'utilise des vecteurs pour stocker des objets 3d, ors la mémoire physique utilisée par le vecteur au fur et à mesure de ses besoins n Modification Size d'un Label [ par lillith212 ] Bonjour à tous,Je suis entrain de réaliser mes premiers pas en C++ et je suis entrain de réaliser une application en C++ builder 6Je travaille sous wi du C au C++ [ par nidhaletec ] si quelqu un m aide à convertir cette fonktion en C++ ; c écrit en C ;void remplacer (char *filename, char *str,  char *occ){    FILE *f = fopen(filen if(sousligne1.compare(sousligne3)) // le test ne fonction pas !! [ par yanlou ] Bonjour, pourquoi mon code ne fonction pas correctement, le test #include #include #include using namespace std; int main() { s Condition avec signaux [ par chimisteq ] <link rel="Fi rechercer avec tinyxml [ par tudiant ] <link rel="Fi


Nos sponsors


Sondage...

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir
 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,827 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales
Outils Convertisseur VB/C# Snippets et scripts Outils en ligne La ToolBox
Communauté Programmation Photographie Technologie Newsgroups Emploi Forum Blogs
Guide d'achat Téléphonie mobile Image et son Informatique Bureautique Jeux vidéo
Logiciels Internet & Réseau Développement Market Android Jeux & Loisirs Graphisme Multimédia Sécurité Pilotes
Loisirs Cartes virtuelles Vidéos droles Jeux en ligne Géoguide AndroLib (Android Market)