Bonjour,

Je pensais avoir bien compris l’héritage mais en fait pas du tout voici mon problème comment interdire l’accès a une fonction dans une classe qui hérite d'une classe fille de la classe mère. 

Ex:

class A
{
public:
    A();
    fonctionAutoriserAvantLaClasseC ()
   
}

classe B : public A //J’hérite de la fonction 
{
   B();
   //blabla
}

classe C: public B //J’hérite de la fonction de la class A mais j'aimerai éviter comment faire ?
{
  c();
}

J'ai pense a faire sa 

class A
{
public:
    A();
protected:
    fonctionAutoriserAvantLaClasseC ()
   
}

classe B : public A //Je devrais herite  la fonction
{
   B();
   //blabla
}

classe C: public B //La je devrais pas herite de la fonction A mais herite des fonction de la classe B
{
  C();
}

Mais la grosse erreur quand j'essaye d'appeler la fonction  de la class A a partir de la classe fille...

include\initialisationFenetre.h|13|error: 'void initialisationFenetre::initialisationDonneeFenetre(int, int, std::__cxx11::string)' is protected|

error: within this context|

une solution ?  

Merci  :) 

-
Edité par lois22 3 novembre 2018 à 2:11:41

D'où as-tu appelé ta fonction déclarée dans A ?

Si tu appelles ta fonction test depuis l'extérieur de ta classe A, c'est normal, car elle est protégée. L'accès protected ne se fait que depuis la dite classe et ses classes dérivées

Lu'!

Mets nous le vrai code qui pose problème, il y a peut être un détail important qui t'a échappé mais si on n'a pas le vrai code, on ne peut pas le dire.

D'accord alors voila comment j'ai penser le petit heritage j'utilise la SFML 

  initialisationFenetre.h

#ifndef INITIALISATIONFENETRE_H
#define INITIALISATIONFENETRE_H
#include <string>


class initialisationFenetre
{
    public:
        initialisationFenetre();
        virtual ~initialisationFenetre();

    protected:
        void initialisationDonneeFenetre(int largeur, int hauteur, std::string nom);
        int largeurFenetre;
        int hauteurFenetre;
        std::string nomFenetre;
};

#endif // INITIALISATIONFENETRE_H

.cpp

#include "initialisationFenetre.h"

initialisationFenetre::initialisationFenetre()
{
    //ctor
}

initialisationFenetre::~initialisationFenetre()
{
    //dtor
}

void initialisationFenetre::initialisationDonneeFenetre(int largeur, int hauteur, std::string nom)
{
    largeurFenetre = largeur;
    hauteurFenetre = hauteur;
    nomFenetre = nom;
}

fenetre .h

#ifndef FENETRE_H
#define FENETRE_H
#include <SFML/Graphics.hpp>
#include <initialisationFenetre.h>


class Fenetre : public initialisationFenetre
{
    public:
        Fenetre();
        virtual ~Fenetre();
        int getHauteurFenetre();
        int getLargeurFenetre();

    protected:

    private:


};

bouton.h

#ifndef BOUTON_H
#define BOUTON_H
#include "Fenetre.h"


class Bouton : public Fenetre
{
    public:
        Bouton();
        virtual ~Bouton();
        void initialisationBoutonFenetre();

    protected:

    private:
};

#endif // BOUTON_H

main.cpp

#include <SFML/Graphics.hpp>
#include <fenetre.h>
#include <Bouton.h>

auto HAUTEUR_FENETRE = 800;
auto LARGEUR_FENETRE = 700;
auto NOM_FENETRE = "Snack";

Fenetre fenetre;


int main()
{
    sf::RenderWindow window(sf::VideoMode(HAUTEUR_FENETRE, LARGEUR_FENETRE), NOM_FENETRE);
    fenetre.initialisationDonneeFenetre(HAUTEUR_FENETRE, LARGEUR_FENETRE, NOM_FENETRE);

///blabla
}

Lu',

je crois que tu abuses un peu de l'OO.

Une classe "initilisationFenetre"....perso je pense que tu peux t'en passer. En gros tu devrais avoir un code du genre:

class Fenetre
{
public:
	Fenetre(const unsigned longueur, const unsigned hauteur, const std::string & nom = {"Fenetre"});
        //...et le reste
};

A partir du moment où tu penses à une fonction pour initialiser une classe, dit toi que cette fonction existe deja: il s'agit du constructeur. Donc jamais on ne doit avoir une classe du genre:

class Foo
{
public:
	Foo();
        void initiliser();
};

A la limite on peut avoir ce type de classe:

class Foo
{
public:
	Foo();
private:
        void initiliser();
};

//dans le .cpp
Foo::Foo()
{
	initialiser();
}

Tu abuses aussi un peu de l'héritage. Si B herite de A alors on peut dire que B est une forme /type de A. Exemple classique: une classe "T-shirt" herite d'une classe "Vetement" on peut donc dire qu'un T-shirt est une forme / type de vetement.

Dans ton cas: A quel moment un bouton est une forme/type de fenetre? Un bouton peut appertenir à une fenetre mais n'est pas une forme/type de fenetre. 

En bref: essaie de faire comme si ta classe "initilisationFenetre" n'existait pas et utilise le constructeur et non une fonction "initialiser" pour initialiser une classe.

(Les variables globales non constantes c'est pas tip-top non plus)

Merci  pour toute tes information elle mon était précieuse surtout pour l'initialisation du constructeur...

J'ai donc tout repenser mes class

J'aurai encore 3 questions

Pourquoi je n'est jamais pu avoir accès a la fonction dans protected ?  

Et il possible d'interdire l'instance d'une classe quand on la déjà instancier ?  

ex:

Background background {LARGEUR_FENETRE,HAUTEUR_FENETRE,BACKGROUND_FENETRE,POSITION_LARGEUR_MILLIEU,POSITION_HAUTEUR_MILLIEU}; 

Background deuxiemeBackground {LARGEUR_FENETRE,HAUTEUR_FENETRE,BACKGROUND_FENETRE,POSITION_LARGEUR_MILLIEU,POSITION_HAUTEUR_MILLIEU}; // devrais être interdit 

Dans mon cas il est complètement illogique de crée un deuxième Background et il possible de l'interdire ?

Dernière question suite a l'avancement du petit projet je me retrouve avec "beaucoup" de constant est ce correcte ?  de plus et il possible de crée un fichier avec que des constante afin d’éviter de polluer le main ?  

voici le main 

#include <SFML/Graphics.hpp>
#include <Background.h>
#include <BoutonJouer.h>
#include <Fenetre.h>
#include <BoutonOption.h>
#include <iostream>


const auto HAUTEUR_FENETRE = 600;
const auto LARGEUR_FENETRE = 800;
const auto NOM_FENETRE = "Snack";
const auto BACKGROUND_FENETRE = "ressource/background.png";
const auto BACKGROUND_BOUTON_JOUER  = "ressource/boutonJouer.png";
const auto BACKGROUND_BOUTON_OPTION = "ressource/BoutonOption.png";


const auto HAUTEUR_BOUTON = HAUTEUR_FENETRE * 0.10;
const auto LARGEUR_BOUTON = LARGEUR_FENETRE * 0.25;

const auto POSITION_LARGEUR_MILLIEU = 0.5; //entre 0 et 1
const auto POSITION_HAUTEUR_MILLIEU = 0.5; //entre 0 et 1
const auto POSITION_HAUTEUR_BOUTON_JOUER = 0.45;
const auto POSITION_HAUTEUR_BOUTON_OPTION = 0.6;
const auto POSITION_LARGEUR_BOUTON_JOUER = 0.5; // 0.5 est le milieu  de la fenetre
const auto POSITION_LARGEUR_BOUTON_OPTION = 0.5; // 0.5 est le milieu de la fenetre


const auto MILLIEU_LARGEUR_BOUTON = LARGEUR_FENETRE*POSITION_LARGEUR_BOUTON_OPTION;
const auto MILLIEU_HAUTEUR_BOUTON = HAUTEUR_FENETRE*POSITION_HAUTEUR_BOUTON_OPTION;

int main()
{
    sf::RenderWindow window(sf::VideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE), NOM_FENETRE);
    ElementFenetre::initialiserVariableTailleFenetre(LARGEUR_FENETRE,HAUTEUR_FENETRE); // initialise la taille de la fenetre
    Background background {LARGEUR_FENETRE,HAUTEUR_FENETRE,BACKGROUND_FENETRE,POSITION_LARGEUR_MILLIEU,POSITION_HAUTEUR_MILLIEU}; //Initialisation background
    BoutonJouer boutonJouer{LARGEUR_BOUTON,HAUTEUR_BOUTON,BACKGROUND_BOUTON_JOUER,POSITION_LARGEUR_BOUTON_JOUER,POSITION_HAUTEUR_BOUTON_JOUER}; //Initialise le boutonJouer
    BoutonOption boutonOption{LARGEUR_BOUTON,HAUTEUR_BOUTON,BACKGROUND_BOUTON_OPTION,POSITION_LARGEUR_BOUTON_OPTION,POSITION_HAUTEUR_BOUTON_OPTION};

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
            if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
                if(event.mouseButton.x > MILLIEU_LARGEUR_BOUTON-LARGEUR_BOUTON/2 &&
                   event.mouseButton.x < MILLIEU_LARGEUR_BOUTON+LARGEUR_BOUTON/2 &&
                   event.mouseButton.y > MILLIEU_HAUTEUR_BOUTON-HAUTEUR_BOUTON/2 &&
                   event.mouseButton.y < MILLIEU_HAUTEUR_BOUTON+HAUTEUR_BOUTON/2 )
                    window.close();

        }

        window.clear();
        background.afficherElement(window);
        boutonJouer.afficherElement(window);
        boutonOption.afficherElement(window);

        window.display();
    }

    return 0;
}

Merci encore  pour votre aide

-
Edité par lois22 4 novembre 2018 à 4:21:51

Bonjour, j'aimerais savoir pourquoi il y'a une erreur et comment y remédier.

Merci

class Character {
    var lifePoint: Int
    var attackPoint: Int
    
    init() {
        self.lifePoint = 0
        self.attackPoint = 0
    }
    func introduceYourself() {
        print("Hello, I have \(lifePoint) life and \(attackPoint) attack points")
    }
    
  func compareTo(_character: Character ) -> Character {
        if _character.attackPoint > self.attackPoint {
            return _character
        } else if self.lifePoint < self.lifePoint {
            return _character
        } else {
            _character.attackPoint == _character.lifePoint
            return _character
        }
}

class Warrior: Character {
    override func introduceYourself() {
        print("I'm a warrior I have \(lifePoint) life and \(attackPoint) attack points")
    }
    override init() {
        super.init()
        self.lifePoint = 90
        self.attackPoint = 120
    }
    }
}

class Mage: Character {
    override func introduceYourself() {
        print("I'm a mage I have \(lifePoint) life and \(attackPoint) attack points")
    }
    override init() {
        super.init()
        self.lifePoint = 98
        self.attackPoint = 2
    }
}

let awarrior = Warrior()
awarrior.introduceYourself()
let amage = Mage()
amage.introduceYourself()
let character1 = Character()
let character2 = Character()
let better = Character()
better.compareTo(_character: character1)

Quel est le rapport avec C++ et avec le sujet ?