Discussion :

[Disixlis]

Bonjour, j'ai une petite question avec ce 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
 
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 ^^

[Bousk]

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.

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

[bacelar]

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

[Disixlis]

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

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 :

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

1
2
 
std::vector<A> v_a;

par ça :

Code :

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

1
2
 
std::vector<A*> v_a;

pour que les fonctions membres de B fonctionne ?

[Disixlis]

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

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

[Disixlis]

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 :

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

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

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

[Médinoc]

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 C++14 :

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

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 C++11 :

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

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) );

[bacelar]

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.

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

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

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

1
2
3
 
v_e[0].update();
window.draw(v_e[0]);

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

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

1
2
v_e[0]->update();
window.draw(*v_e[0]);

[Disixlis]

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