Class et "mère" et "fille"

Version imprimable

16/03/2016, 15h14
Disixlis

Class et "mère" et "fille"
Bonjour, j'ai une petite question avec ce code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Class A { public: A(){} void functionA(){} } Class B : public A { public: B():A(){} void functionB(){} }
Logiquement si je fait un vector de A et que je fait un push_back de B dans le vector de type A, tout fonctionne.
Mais mon vector n'aura pas accès à la fonction membre de B ? Donc comment fait t'on pour rendre cela possible tout en gardant un vector de type A ?

Merci ^^
16/03/2016, 15h27
Bousk

Citation:

Envoyé par Disixlis

Logiquement si je fait un vector de A et que je fait un push_back de B dans le vector de type A, tout fonctionne.

Non tu slice ton B en A. Vaut mieux éviter.

Citation:

Envoyé par Disixlis

Mais mon vector n'aura pas accès à la fonction membre de B ? Donc comment fait t'on pour rendre cela possible tout en gardant un vector de type A ?

Ce que tu veux faire s'appelle du polymorphisme. Il faut utiliser le typage dynamique et donc avoir un vector de A* ou A&. Et les fonctions doivent être virtuelles.
Mais je suis surpris que tu te poses la question que maintenant, tu n'en as jamais eu besoin dans tes nombreuses années de C++ ? 8O
16/03/2016, 16h15
bacelar

Citation:

Il faut utiliser le typage dynamique et donc avoir un vector de A* ou A&.

Heu, plutôt vector de unique_ptr<A> et pas de A*.
16/03/2016, 16h44
Disixlis
Citation:

Envoyé par Bousk

Non tu slice ton B en A. Vaut mieux éviter.

Ce que tu veux faire s'appelle du polymorphisme. Il faut utiliser le typage dynamique et donc avoir un vector de A* ou A&. Et les fonctions doivent être virtuelles.
Mais je suis surpris que tu te poses la question que maintenant, tu n'en as jamais eu besoin dans tes nombreuses années de C++ ? 8O

Enfaite j'ai appris mon cour sur OC et donc la je réapprend tout le cour de gbdivers qui est d’ailleur ultra super cool !
Et non je n'en ai jamais eu besoin, jusqu'à ce jour où je voulais un code plus propre et surtout simple x) donc pour faire ce que je veux il suffit juste de remplacer ça :
Code:

1 2 std::vector<A> v_a;
par ça :
Code:

1 2 std::vector<A*> v_a;
pour que les fonctions membres de B fonctionne ? :D
16/03/2016, 16h45
Disixlis

Citation:

Envoyé par bacelar

Heu, plutôt vector de unique_ptr<A> et pas de A*.

C'est parce-que c'est plus moderne ? ou plus sécurisé ?

J'ai fait un petit test sur un jeu que je voulais corrigé mais bizarrement ça fonctionne pas trop x)

Voici le code :

.hpp

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
 
 
class Entity : public sf::Drawable, public sf::Transformable ///*** Mon A ***///
{
public:
 
    Entity( sf::Vector2f const &size, sf::Vector2f const &position )
    {
        _shape.setFillColor(sf::Color::Red);
        _shape.setPosition(position);
        _shape.setSize(size);
    }
 
    void setPosition( sf::Vector2f const &position )
    {
        _shape.setPosition( position );
    }
 
    sf::Vector2f position() const
    {
        return _shape.getPosition();
    }
 
protected:
 
    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
    {
        states.transform *= getTransform();
        states.texture = NULL;
        target.draw(_shape);
    }
 
    sf::RectangleShape _shape;
 
};
 
class Bullet : public Entity ///*** Mon B ***///
{
public:
 
    Bullet( sf::Vector2f size, sf::Vector2f position ) : Entity( size, position )
    {
 
    }
 
    void create( float velocity, unsigned int direction ) //à changer
    {
        _velocity = velocity;
        _direction = direction > 360 ? 360 : direction;
    }
 
    void update()
    {
        _shape.move( sf::Vector2f( std::cos( _direction ) * _velocity, std::sin( _direction ) * _velocity ) );
    }
 
private:
 
    float _velocity;
    unsigned int _direction;
};

.cpp

Code:

1
2
3
4
5
6
7
8
 
 
    std::vector<std::unique_ptr<Entity>> v_e;
 
    Bullet b( sf::Vector2f(10,10), sf::Vector2f(75,75) ) ;
    b.create( 1, 90 );
 
    v_e.push_back( b );

Erreur au niveau du push_back() -> No matching function for call to 'std::vector<std::unique_ptr<Entity> >::push_back(Bullet&)'|

Ps: oui je vais bientôt apprendre le polymorphisme mais je n'y suis pas encore, ceci explique cela :p
:)

~~If you have a C++14 compiler, you can declare your bullet thusly:~~
Pourquoi est-ce que j'écris en anglais, moi? Je me crois sur StackOverflow, ou quoi?

Si tu as accès à un compilateur C++14, tu peux instancier ton objet Bullet de cette façon:
Code:

1 2 3 4 5 6 std::vector<std::unique_ptr<Entity>> v_e; auto b = std::make_unique<Bullet>( sf::Vector2f(10,10), sf::Vector2f(75,75) ) ; b->create( 1, 90 ); v_e.push_back( std::move(b) );
~~If you only have C++11, this will have to do:~~
Si tu n'as que C++11, tu vas devoir te contenter de ceci:
Code:

1 2 3 4 5 6 std::vector<std::unique_ptr<Entity>> v_e; std::unique_ptr<Bullet> b(new Bullet( sf::Vector2f(10,10), sf::Vector2f(75,75) )) ; b->create( 1, 90 ); v_e.push_back( std::move(b) );

16/03/2016, 17h38
bacelar

Citation:

C'est parce-que c'est plus moderne ? ou plus sécurisé ?

Plus pour fainéant, car on ne gère pas la mémoire.

Citation:

Erreur au niveau du push_back() -> No matching function for call to 'std::vector<std::unique_ptr<Entity> >::push_back(Bullet&)'|

C'est pour te dire que tu n'importenawak.
"b" est une variable locale
Qu'est-ce qui ce passe si tu sort de ta fonction et que ton vecteur a une durée de vu supérieur à celle de la fonction déclarant cette variable locale ?

En utilisant un unique_ptr, tu indiques qu'il ne peut avoir qu'un seul responsable (au sens de responsable d'appeler le destructeur), à la fois.

Si tu mets un objet dans un "std::vector<unique_ptr<A>>", c'est que l'objet n'est la propriété que de ce vector.
Si tu veux donc mettre un A ou un B dans ce vector, passe par make_unique et emplase_back.

http://en.cppreference.com/w/cpp/mem...tr/make_unique
http://en.cppreference.com/w/cpp/con...r/emplace_back
17/03/2016, 08h43
Disixlis
Je code avec c++14 donc pas de problèmes pour la première fonction ça marche impec ^^ donc si je comprend bien, ma variables locale devient la variable local de std::vector et seulement lui peux appeler sont destructeur, c'est bien ça ? Et du coup peut-on faire l'effet inverse en baissant justement en localité ( je dirais oui à 80% mais bon x) je ne m'y connais pas encore avec ce genre de chose )? Je sais pas si on m'as compris x)

Edit : Donc maintenant mon vecteur est parfait, mais comment je fait pour appeler une function membre ? car ceci ne fonctionne pas :
Code:

1 2 3 v_e[0].update(); window.draw(v_e[0]);
17/03/2016, 09h28
Daïmanu
Bonjour.

unique_ptr a la même interface qu'un pointeur, il suffit donc de déréférencer la variable à chaque appel.
Code:

1 2 v_e[0]->update(); window.draw(*v_e[0]);
17/03/2016, 09h38
Disixlis

D'accord merci bien ^^ et merci à vous tous :)