Ubuntu-fr

G.I.Bdeking

map et objets

Bonjours à tous! aujourd'hui j'ais eue un problème de tableau map avec deux de mes classes (du moins je crois) avec ces erreurs:

-------------- Build: Debug in TGui ---------------

Compiling: TFenetre.cpp
In file included from /usr/include/c++/4.6/map:61:0,
                 from /usr/local/include/SFML/Graphics/Font.hpp:37,
                 from /usr/local/include/SFML/Graphics.hpp:34,
                 from /TGui/generalVar.hpp:7,
                 from /TGui/TFenetre.hpp:4,
                 from /TGui/TFenetre.cpp:1:
/usr/include/c++/4.6/bits/stl_map.h: In member function ‘std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = std::basic_string<char>, _Tp = TButton, _Compare = std::less<std::basic_string<char> >, _Alloc = std::allocator<std::pair<const std::basic_string<char>, TButton> >, std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type = TButton, std::map<_Key, _Tp, _Compare, _Alloc>::key_type = std::basic_string<char>]’:
/TGui/TFenetre.cpp:30:18:   instantiated from here
/usr/include/c++/4.6/bits/stl_map.h:453:11: erreur: no matching function for call to ‘TButton::TButton()’
/usr/include/c++/4.6/bits/stl_map.h:453:11: note: candidates are:
/TGui/TBouton.hpp:26:5: note: TButton::TButton(sf::Image&, int, int, float, float)
/TGui/TBouton.hpp:26:5: note:   candidate expects 5 arguments, 0 provided
/TGui/TBouton.hpp:25:5: note: TButton::TButton(sf::Image&, int, int)
/TGui/TBouton.hpp:25:5: note:   candidate expects 3 arguments, 0 provided
/TGui/TBouton.hpp:7:7: note: TButton::TButton(const TButton&)
/TGui/TBouton.hpp:7:7: note:   candidate expects 1 argument, 0 provided
Process terminated with status 1 (0 minutes, 1 seconds)
8 errors, 0 warnings
 

Je ne comprend tout simplement pas cette erreur!

Tbouton.hpp

#ifndef TBOUTON_HPP_INCLUDED
#define TBOUTON_HPP_INCLUDED

#include "generalVar.hpp"


class TButton
{
    protected://Tout ce qui suit n'est accessible que par la classe et ses eventuelles classes filles

    ///attributs:
    int m_positionX;//variable qui stocke la position X actuelle du bouton
    int m_positionY;//stocke la position Y actuelle du bouton
    int m_tailleX;//Cette variable, associée à tailleY, permet à la methode show de déduire le rectangle qu'occupe le bouton sur l'ecran
    int m_tailleY;//Cette variable, associée à tailleX, permet à la methode show de déduire le rectangle qu'occupe le bouton sur l'ecran
    std::string m_cheminImage1;//Le chemin relatif/absolu de l'image qui matérialisera le bouton
    sf::Image m_image;
    sf::Image m_image2;
    sf::Sprite m_sprite;
    sf::Sprite m_sprite2;

    public://Tout ce qui suit est accessible de n'importe où

    ///constructeur(s) et destructeur:
    TButton(sf::Image&, int, int);//Premier constructeur surchargé, il permet de créer un bouton avec une seule image et le bouton s'adapte à la taille de l'image
    TButton(sf::Image&, int, int, float, float);//Deuxième constructeur, il prend deux autres paramètres: la taille du bouton (redimentionnera l'image en conséquence)


    ///methodes principales:
    sf::Sprite getSprite();
    bool estTouche(int, int);

    ///accesseurs:

    void setTailleX(int);
    void setTailleY(int);
    void setTailleXY(int, int);
    int getPositionX();
    int getpositionY();
    void setPositionX(int);
    void setPositionY(int);
    void setPositionXY(int, int);
    float getTailleX();
    float getTailleY();
};


#endif // TSHOWBUTTON_HPP_INCLUDED

TBouton.cpp

#include </home/alexis/programmes/C++/SFML/en développement actif/TGui/TBouton.hpp>

using namespace std;

///constructeurs:
TButton::TButton(sf::Image& image, int positionX, int positionY)
{
    m_positionX=positionX;
    m_positionY=positionY;
    m_sprite.SetImage(image);
    m_tailleX = m_sprite.GetSize().x;
    m_tailleY = m_sprite.GetSize().y;
}

TButton::TButton(sf::Image& image, int positionX, int positionY, float dimentionX, float dimentionY)
{
    m_positionX=positionX;
    m_positionY=positionY;
    m_tailleX=dimentionX;
    m_tailleY=dimentionY;
    m_sprite.SetImage(image);
    m_sprite.Resize(dimentionX, dimentionY);
}

///Methodes:
sf::Sprite TButton::getSprite()
{
    m_sprite.SetX(m_positionX);
    m_sprite.SetY(m_positionY);
    m_sprite.Resize(m_tailleX, m_tailleY);

    return m_sprite;
}

bool TButton::estTouche(int posSourisX, int posSourisY)
{
    int calculX=m_positionX+m_tailleX;
    int calculY=m_positionY+m_tailleY;

    if(posSourisX>=m_positionY && posSourisY>=m_positionX && posSourisX<=calculY && posSourisY<=calculX)
        return true;
    else
        return false;
}

///accesseurs:
void TButton::setTailleXY(int tailleX, int tailleY){
    m_tailleX=tailleX;
    m_tailleY=tailleY;
}

float TButton::getTailleX(){
    return m_tailleX;
}

float TButton::getTailleY(){
    return m_tailleY;
}

void TButton::setTailleY(int tailleY){
    m_tailleY=tailleY;
}

void TButton::setTailleX(int tailleX){
    m_tailleX=tailleX;
}

int TButton::getPositionX(){
    return m_positionX;
}

void TButton::setPositionX(int position){
    m_positionX=position;
}

void TButton::setPositionY(int position){
    m_positionY=position;
}

TFenetre.hpp

#ifndef TFENETRE_HPP_INCLUDED
#define TFENETRE_HPP_INCLUDED

#include "generalVar.hpp"
#include "TBouton.hpp"

class TFenetre
{
    protected:
    std::map<std::string, TButton> m_boutons;
    std::map<std::string, sf::Image> m_images;
    sf::RenderWindow fenetre;

    public:
    TFenetre(std::string*, int, std::string, int, int);
    TFenetre(std::string, int, int, bool);
    void newButton(int, int, float, float, std::string, std::string);
    void screenshot(std::string);
    void show();
    ~TFenetre();
};

#endif // TFENETRE_HPP_INCLUDED

TFenetre.cpp

#include "TFenetre.hpp"

using namespace std;

TFenetre::TFenetre(string chemins[], int tailleTableauChemins, string nom, int largeur, int hauteur)
{
    for(int c=0; c!=tailleTableauChemins; c++){
        sf::Image image;
        image.LoadFromFile(chemins[c]);
        m_images[chemins[c]]=image;
    }

    fenetre.Create(sf::VideoMode(largeur, hauteur, 32), nom);
    fenetre.SetFramerateLimit(60);
}

TFenetre::TFenetre(string nom, int largeur, int hauteur, bool fullscreen)
{
    if(fullscreen)
        fenetre.Create(sf::VideoMode(largeur, hauteur, 32), nom, sf::Style::Fullscreen);
    else
        fenetre.Create(sf::VideoMode(largeur, hauteur, 32), nom, sf::Style::None);

    fenetre.SetFramerateLimit(60);
}

void TFenetre::newButton(int posX, int posY, float largeur, float hauteur, string nomImage, string nom)
{
    TButton bouton(m_images[nomImage], posX, posY, largeur, hauteur);
    m_boutons[nom]=bouton;
}

void TFenetre::screenshot(string nom)
{
    sf::Image Screen = fenetre.Capture();
    Screen.SaveToFile(nom);
}

void TFenetre::show()
{
    fenetre.Clear();
    fenetre.Display();
}

TFenetre::~TFenetre()
{}

Je ne montrerait pas generalVar.hpp car il n'y a dedans qu'inclus tous les headers  indispensables au prog.

PS: Je ne pense pas que le problème vienne de /usr/include/c++/4.6/bits/stl_map.h
PPS: ce doit être seulement la ligne 11 de TFenetre.hpp et la ligne 30 de TFenetre.cpp qui sont très importantes... à vérifier!
PPPS: code::block, C++.

à bientot!

Dernière modification par G.I.Bdeking (Le 15/07/2013, à 16:39)

---

"Le désir sincère d'aider est l'essence du logiciel libre. Trouvez y un poste où vous serez utiles, même si ce n'est que de répondre aux libristes sur des forum, et vous trouverez votre place dans ce nouveau monde."

telliam

Re : map et objets

Salut,
je suis pas un pro des mmaps, mais dans ton code tu n'as pas d'operateur de recopie alors que tu l'utilises.
de plus, ton code n'a pas de constructeurs sans parametre, alors que l'operator[] semble l'utiliser.

---

"- Un intellectuel assis va moins loin qu'un con qui marche."
Maurice Biraud - Un Taxi pour Tobrouk
Michel Audiard

grim7reaper

Re : map et objets

telliam a déjà tout dit.

Tu as besoin d’un opérateur d’affectation (operator=), mais tu ne le définis pas. Je te conseille de vérifier que celui généré par défaut est suffisant.
De plus operator[] fait bien un appel au constructeur par défaut (sans paramètre), comme le confirme le standard du C++2003 :

23.6.1.2 map element access
T& operator[](const key_type& x);
1    Effects: If there is no key equivalent to x in the map, inserts value_type(x, T()) into the map.
2    Requires: key_type shall be CopyConstructible and mapped_type shall be DefaultConstructible.
3    Returns: A reference to the mapped_type corresponding to x in *this.
4    Complexity: logarithmic.

En fait, operator[] vérifie si l’élément map[x] existe, si non il va en créer un via le constructeur par défaut puis renvoyer une référence dessus (ensuite, via operator= tu vas modifier cette objet pour mettre le tien à la place).

Si un constructeur par défaut n’a pas de sens pour ta classe TButton, tu peux passer par insert pour ajouter ton élément à ta std::map (pas d’appel au constructeur par défaut, par contre il me semble qu’un copy constructor (donc encore une fois, vérifie si celui généré par défaut est suffisant, sinon écrit le tien) est requis).

---

Blog

G.I.Bdeking

Re : map et objets

Techniquement, je ne pense pas avoir besoin de constructeur de copie car je n'ais aucuns pointeurs dans mes attributs mais c'est sur que le constructeur par défaut ne suffira pas... est-ce que Map.insert(std::make_pair(string, TBouton)); est correct?

Dernière modification par G.I.Bdeking (Le 17/07/2013, à 15:40)

---

"Le désir sincère d'aider est l'essence du logiciel libre. Trouvez y un poste où vous serez utiles, même si ce n'est que de répondre aux libristes sur des forum, et vous trouverez votre place dans ce nouveau monde."

grim7reaper

Re : map et objets

À priori, oui.

m_boutons.insert(std::make_pair(nom, bouton));

devrait fonctionner.

---

Blog

G.I.Bdeking

Re : map et objets

Et oui ça marche! merci de m'avoir ouvert les yeux! dommage que mon livre du site du zero que j'utilise soit incomplet en certains points parfois importants... Sauriez-vous me conseiller un autre ouvrage plus complet?

Merci!

---

"Le désir sincère d'aider est l'essence du logiciel libre. Trouvez y un poste où vous serez utiles, même si ce n'est que de répondre aux libristes sur des forum, et vous trouverez votre place dans ce nouveau monde."

grim7reaper

Re : map et objets

Il y a :
Le langage C++ de Bjarne STROUSTRUP, aux éditions Pearson Education.
Qui est une référence en ce domaine (espérons qu’une nouvelle édition verra le jour pour tenir compte des apport du C++11).
Cela dit, si le livre est très complet, il manque parfois un peu de pédagogie.

Du coup, pour débuter je te conseillerai plutôt :
Programmation, Principes et pratique avec C++ de Bjarne STROUSTRUP aux éditions Pearson Education.

---

Blog