Discussion :

[NoIdea]

Bonjour à tous. J'ai un problème : Ce code m'affiche Base puis Derived au lieu de Derived et Derived. Comment éviter ce problème ?

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
#include <iostream>
#include <typeinfo>
using namespace std;
 
class Base
{
    public :
        Base(){std::cout<<"\nType="<<typeid(*this).name();}
};
 
class Derived : public Base
{
    public :
        Derived() : Base()
        {
            std::cout<<"\nType="<<typeid(*this).name();
        }
};
 
int main()
{
    Derived a;
    return 0;
}

Merci de votre aide.

[athomas]

D'après moi ton code répond normalement.
Ta classe Derived hérite bien de Base;

-----------------------
| BASE |
-----------------------
| Base() {}; |
-----------------------
|
\ /
-----------------------
| DERIVED |
-----------------------
| Derived() {}; |
-----------------------

L'ordre d'appel des construteurs se fait toujours de la classe la plus générale à la plus spécialisée. De manière symétrique, les destructeurs sont appelées de la classe la plus spécialisée vers la plus générique.


F.A.Q. :Dans quel ordre sont construits les différents composants d'une classe ?

[NoIdea]

Je ne dis pas que c'est anormal, je me demande juste comment on peut l'évité :
Dans Base, j'ai une fonction virtuelle. Le constructeur de Base passe en paramètre this à un autre objet.

Le problème :

Quand l'autre objet appelle la fonction virtuelle, c'est base qui est exécutée et non Derived. Comment éviter ce problème ?

[Flob90]

Dans le constructeur on évite tout ce qui est RAII/polymorphisme car il est faussé.

Donc dans ton premier constructeur le type de ton objet est Base et non dérivé même si au final tu construit un dérivé.

De même si tu fais quelque chose comme :

Code :

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

1
2
3
 
struct A { A() { foo(); } virtual void foo() { std::cout <<  0; } };
struct B : A { virtual void foo() { std::cout << 1; } };

Et que tu fais un B, la sortie sera 0 et pas 2 comme tu pourrais t'y attendre.

[NoIdea]

Excusez-moi, mais je vais devoir débiter beaucoup de code car :
L'exemple que j'ai pris avec Base et Derived marche impeccablement mais l'exemple réel non.

Voici l'exemple réel (j'ai essayé de fournir que les parties utiles) :

Le main (rien de compliqué) :

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
int main()
{
    try
    {
    sf::RenderWindow w(VideoMode(800,600), "test");
    sf::GUI::Application app(w, (WindowHandle)NULL);
    Image img;
    img.LoadFromFile("ferme.jpg");
    sf::Sprite s(img);
    Button(app, Implementation::Rectangle<float>(100.f,100.f,200.f,200.f),0u,s);
    app.Wait();
    }
    catch(...)
    {
        std::cout<<"UnknownException";
    }
 
    return 0;
}

Le constructeur de button (button hérite de GraphicObject).

Code :

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

1
2
3
4
5
6
Button(sf::GUI::Application& App, Implementation::Rectangle<float> Pos, unsigned int Plane, sf::Sprite& Img) : GraphicObject(App, Pos, Plane), Image(Img)
{
    std::cout<<"\nObjectType="<<typeid(*this).name();
    Image.SetPosition(Position.Left, Position.Top);
    Image.Resize(Pos.Right-Pos.Left,Pos.Bottom-Pos.Top);
}

Le constructeur de GraphicObject :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
GraphicObject::GraphicObject(sf::GUI::Application& App, Implementation::Rectangle<float>& Pos, unsigned int Plane):
    Parent(NULL), Application(App), Visible(true)
{
    std::cout<<"\nObjectType="<<typeid(*this).name();
    //assert((App.GlPosition()).Contains(Pos));
    Position=Pos;
    ClippingEquations[0]=ClipEquation(1,0,0,Pos.Left,0);
    ClippingEquations[1]=ClipEquation(-1,0,0,Pos.Right,1);
    ClippingEquations[2]=ClipEquation(0,1,0,Pos.Top,2);
    ClippingEquations[3]=ClipEquation(0,-1,0,Pos.Bottom,3);
    App.RegisterWidget(this, Plane);
}

Et maintenant RegisterWidget qui est du type Sorted<GraphicObject*,unsigned int>

Code :

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

1
2
3
4
5
inline void sf::GUI::Application::RegisterWidget(GraphicObject*ChildWidget, unsigned int plan)
{
    std::cout<<"\nObjectType="<<typeid(*ChildWidget).name();
    ChildWidgets.AddElement(ChildWidget, plan);
}

Voici le .hpp de Sorted :

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
 
template<typename Object, typename Sort,template<typename, typename>class Storing>
class Sorted<Object*, Sort, Storing>
{
    private :
        Storing<std::pair<Object*, Sort>, std::allocator<std::pair<Object*, Sort>>> List;
    public :
        Sorted()=default;
        Sorted(const Sorted&)=delete;
        Sorted& operator=(Sorted&)=delete;
        ~Sorted()=default;
        void AddElement(Object* Element, Sort Position);
        inline void EraseElement(Object* Element);
        template<typename Fc>
        inline void ForEach(Fc Function);
};

Et Sorted.inl :

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
 
 
template<typename Object, typename Sort, template<typename,typename>class Storing>
inline void sf::GUI::Implementation::Sorted<Object*, Sort, Storing>::AddElement(Object* Element, Sort Position)
{
    std::cout<<"\nObjectType="<<typeid(*Element).name();
    auto it=List.begin();
    for(;it!=List.end();it++)
        if(it->second<=Position)
            break;
    List.insert(it,std::make_pair(Element,Position));
}
 
template<typename Object, typename Sort, template<typename,typename>class Storing>
void sf::GUI::Implementation::Sorted<Object*, Sort, Storing>::EraseElement(Object* Element)
{
    for(auto it=List.begin();it!=List.end();it++)
    {
        if(it->first==Element)
        {
            List.erase(it);
            return ;
        }
    }
}
 
 
template<typename Object, typename Sort, template<typename,typename>class Storing>
template<typename Fc>
inline void sf::GUI::Implementation::Sorted<Object*, Sort, Storing>::ForEach(Fc Function)
{
    for(auto it=List.begin();it!=List.end();it++)
    {
        std::cout<<"\nObjectType="<<typeid(*(it->first)).name();
        sf::GUI::Implementation::CallFunction<Fc, Object, void>::Call(Function, *(it->first));
    }
}

Voici le code qui appelle ForEach :

ChildWidgets.ForEach(&GraphicObject::Actualise);

(Ce code est appelé au début de Wait()

Actualise appelle Draw qui est une fonction virtuelle.
Le problème : le Draw appelé et celui de graphicObject et non de button.

Vous risquez d'avoir besoin de cette portion de code :

Code :

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

1
2
3
4
5
6
7
8
9
template<typename Obj, typename R, typename ...Args>
struct CallFunction<R(Obj::*)(Args...),Obj,R,Args...>
{
    inline static R Call(R(Obj::*Function)(Args...), Obj& Object, Args...Arguments)
    {
        std::cout<<"\nCalling "<<typeid(Object).name();
        return (Object.*Function)(Arguments...);
    }
};

Merci à tous ceux qui auront déjà lut (même en diagonal) ce post.

[Flob90]

Désolé d'être un peu flemmard, mais tu pourrais pas essayer de tout réduire à un seul fichier compilable avecun copier-coller ? Ca serait bien plus simple ...

(Je regarde quand même).

[Flob90]

Après avoir tester, l'utilisation de ton ForEach avec des élément d'une hiérarchie polymorphique et une fonction virtuelle (hors des constructeurs, dans les constructeur le polymorphisme est proscrit en général) marche comme prévue chez moi, l'erreur vient d'ailleur.

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
 
struct A { virtual void foo() { std::cout << 0; } virtual ~A() {} };
struct B : A { void foo() { std::cout << 1; } };
 
template<typename, typename, typename, typename...>
struct CallFunction;
 
template<typename Obj, typename R, typename ...Args>
struct CallFunction<R(Obj::*)(Args...),Obj,R,Args...>
{
  static R Call(R(Obj::*Function)(Args...), Obj& Object, Args...Arguments)
  { return (Object.*Function)(Arguments...); }
};
 
template<typename, typename, template<typename, typename> class>
struct Sorted;
 
template<typename Object, typename Sort,template<typename, typename>class Storing>
class Sorted<Object*, Sort, Storing>
{
  private :
    Storing<std::pair<Object*, Sort>, std::allocator<std::pair<Object*, Sort>>> List;
  public :
    void AddElement(Object* Element, Sort Position)
    {
      auto it=List.begin();
        for(; it != List.end(); ++it) if(it->second <= Position) break;
      List.insert(it,std::make_pair(Element,Position));
    }
    template<typename Fc> void ForEach(Fc Function)
    {
      for(auto it = List.begin(); it != List.end(); ++it)
        CallFunction<Fc, Object, void>::Call(Function, *(it->first));
    }
};
 
int main()
{
  Sorted<A*, size_t, std::vector> s;
  s.AddElement(new A(), 0); s.AddElement(new B(), 1);
  s.ForEach(&A::foo);
  system("PAUSE"); return 0; 
}

[NoIdea]

Après avoir tester, l'utilisation de ton ForEach avec des élément d'une hiérarchie polymorphique et une fonction virtuelle (hors des constructeurs, dans les constructeur le polymorphisme est proscrit en général) marche comme prévue chez moi, l'erreur vient d'ailleur

Oui, c'est bien ce qui m'avais semblé (j'ai fais plein de tests et chaque partie individuellement marche). C'est pour sa que je ne sait plus ou regarder !

Je vais essayer de te fournir un code qui reproduit le bug mais qui est compilable (je peux toujours te mettre tout le projet, mais sa risque d'être un peu gros...)

D'après les typeid que j'ai mis pour debugger, le pointeur this reste un GraphiqueObject toute sa vie...

Je vais essayer de créer un code "minimal".

[NoIdea]

Magnifique échec pour le code minimal : Ce code représente toutes les interactions que j'ai pu trouvé entre les objets et il marche impeccablement.
Voici le code que j'ai testé :

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
62
63
64
 
//Les include sont là pour la classe Sorted
#include "Utilities.hpp"
#define __ALLOW_INL_INCLUSION_OK__
#include "Binding.inl"
#include "Utilities.inl"
#undef __ALLOW_INL_INCLUSION_OK__
 
using namespace sf;
using namespace sf::GUI;
using namespace sf::GUI::Implementation;
 
class B;
 
class A
{
    private :
        Sorted<B*,unsigned int> V;
    public :
        void RegisterChild(B*obj, unsigned int plan);
        void DoForEach();
};
 
class B
{
    public :
        virtual void Draw(){std::cout<<"\nBase Draw Called";}
        void Actualise()
        {
            Draw();
        }
        B(A& a, unsigned int plan)
        {
            std::cout<<"TypeConstructor : "<<typeid(*this).name();
            a.RegisterChild(this, plan);
        }
};
 
class C : public B
{
    public :
        virtual void Draw(){std::cout<<"\nDerived Draw Called";}
        C(A& a, unsigned plan) : B(a,plan)
        {}
};
 
void A::RegisterChild(B*obj, unsigned plan)
{
    std::cout<<"\nRegister: "<<typeid(*obj).name();
    V.AddElement(obj,plan);
}
 
void A::DoForEach()
{
    V.ForEach(&B::Actualise);
}
 
int main()
{
    A a;
    C c(a,1u);
    a.DoForEach();
    return 0;
}

Résultat en sortie (console) :

TypeConstructor : 1B
Register : 1B
ObjectTypeAddElement : 1B
ObjectTypeForEach : 1C
Calling 1C
Derived Draw Called

Ce qui est le résultat attendu.

Je vous fourni Binding.inl, Utilities.hpp et Utilities.inl (Il y a plus de chose que nécessaire mais vous permet d'avoir un code compilable).

Cependant, avec le projet complet je n'obtient pas le même résultat :

TypeConstructor : N2sf3GUI13GraphicObjectE
Register : N2sf3GUI13GraphicObjectE
ObjectTypeAddElement : N2sf3GUI13GraphicObjectE
ObjectTypeForEach : N2sf3GUI13GraphicObjectE
Calling N2sf3GUI13GraphicObjectE
Base Draw Called

Je vais vous passer le projet complet (si je ne vous passe pas le complet vous risquez de ne pas avoir l'erreur).
C'est un projet Code::Blocks et je l'ai compilé avec g++4.5 -std=c++0x -Wall -pedantic -pedantic-errors

Je n'ai aucun warning au erreurs à la compilation (au part pour auto importing mais ce warning la est toujours présent quelque soit le projet).

J'ai juste viré la dépendance sur sfml que vous n'ayez pas a linker à des choses inutiles et le même problème se produit toujours.

Merci de votre aide.

[Flob90]

Tu aurais pas un fichier de commande pour compiler ? (ou un makefile)

J'ai tenté ca :
g++ -std=c++0x -Werror -Wall -Wextra -c main.cpp
g++ -std=c++0x -Werror -Wall -Wextra -c Application.cpp
g++ -std=c++0x -Werror -Wall -Wextra -c GraphicObject.cpp
g++ -std=c++0x -Werror -pedantics-errors -Wall -Wextra -o final.exe main.o Application.o GraphicObject.o

Mais il ne trouve pas les définitions de clip et unclip (ce qui est normal puisqu'elles ne sont pas dans un .cpp)

[NoIdea]

J'ai pas mal galérer à trouver le log de code::blocks. Voici tout ce que j'ai pu avoir :

Build started on: 26-10-2010 at 20:26.10
Build ended on: 26-10-2010 at 20:27.00
-------------- Build: Debug in SFMLGUIREFAIT ---------------
mingw32-g++.exe -Wall -fexceptions -g -Wmain -pedantic-errors -pedantic -W -Wall -g -std=c++0x -c "J:\Zone Programmation\Projets\SFMLGUIv2\ProjetComplet\GraphicObject.cpp" -o obj\Debug\GraphicObject.o
mingw32-g++.exe -Wall -fexceptions -g -Wmain -pedantic-errors -pedantic -W -Wall -g -std=c++0x -c "J:\Zone Programmation\Projets\SFMLGUIv2\ProjetComplet\main.cpp" -o obj\Debug\main.o
mingw32-g++.exe -Wall -fexceptions -g -Wmain -pedantic-errors -pedantic -W -Wall -g -std=c++0x -c "J:\Zone Programmation\Projets\SFMLGUIv2\ProjetComplet\Application.cpp" -o obj\Debug\Application.o
mingw32-g++.exe -o bin\Debug\SFMLGUIREFAIT.exe obj\Debug\GraphicObject.o obj\Debug\main.o obj\Debug\Application.o -lmingw32 -lsfml-system -lsfml-window -lsfml-graphics -lopengl32 -lglu32 C:\Gcc-G++\lib\libopengl32.a C:\Gcc-G++\lib\libglaux.a C:\Gcc-G++\lib\libglu32.a
c:/gcc-g++/bin/../lib/gcc/mingw32/4.5.0/../../../../mingw32/bin/ld.exe: warning: auto-importing has been activated without --enable-auto-import specified on the command line.
Info: resolving std::__detail::__prime_list by linking to __imp___ZNSt8__detail12__prime_listE (auto-import)
This should work unless it involves constant data structures referencing symbols from auto-imported DLLs.
Info: resolving std::cout by linking to __imp___ZSt4cout (auto-import)
Info: resolving vtable for __cxxabiv1::__vmi_class_type_info by linking to __imp___ZTVN10__cxxabiv121__vmi_class_type_infoE (auto-import)
Info: resolving vtable for __cxxabiv1::__class_type_info by linking to __imp___ZTVN10__cxxabiv117__class_type_infoE (auto-import)
Info: resolving vtable for __cxxabiv1::__si_class_type_info by linking to __imp___ZTVN10__cxxabiv120__si_class_type_infoE (auto-import)
Output size is 837.97 KB
Process terminated with status 0 (0 minutes, 49 seconds)
0 errors, 1 warnings

En espérant que cela t'aide.

[EDIT]Je t'ai donné le projet codeblocks dans le .zip, donc, tu peux toujours l'utiliser si tu as codeblocks.

[NoIdea]

Je suis vraiment désolé de vous avoir dérangés pour rien en fait :
Dans mon main, j'avais fait Button(...) au lieu de faire Button truc(...).
Ce qui faisait que mon Button était détruit sans créer une segfault.
Donc, lors du ForEach, il ne restait plus "réellement" de Button. Normal que le code minimal marche parfaitement...

Il n'y aurait pas un warning pour ce genre de chose ?
Dire que j'ai passé 2 jours la dessus...

Bon je crois que l'on peut clore le sujet...