Discussion :

[karistouf]

Bonjour !

je passe le pas au C++. j'ai DEUX grosses questions de newbie

j'ai écris une classe dans un HPP et un CPP. et j'en suis à faire des essais...
peux ton faire appel dans le cosntructeur à des fonctions membres ?

je crées l'objet dans mon main, avant la boucle principale, mais à l'appel de cet objet depuis des fonctions dans le code, l'objet apparrait comme non déclaré.
lcelà veut dire que les objets doivent être créés uniquement dans le main ? et appelés du main ?
comment çà se passe pour pointer vers les objets créés à l'ouverture du programme et pendant l'exécution du programme ?

merci !

Code :

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

1
2
3
4
5
6
7
8
9
 
 
    Surfaces Surf(1,4);
 
    while (!glfwWindowShouldClose(window))
    {
        RenderMain();
       Surf.draw();
   }

[Flob90]

Bonjour,

Je ne comprends pas ta question, tu peux faire voir un de tes "appel de cet objet depuis des fonctions dans le code" ? Et donner l'erreur que tu obtiens aussi ?

[PilloBuenaGente]

Bonjour !

peux ton faire appel dans le cosntructeur à des fonctions membres ?

Oui !(?)

Code :

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

1
2
3
4
5
6
7
class Classe
{
public:
    Classe() { fonctionMembre(); }
private:
    void fonctionMembre() {}
};

je crées l'objet dans mon main, avant la boucle principale, mais à l'appel de cet objet depuis des fonctions dans le code, l'objet apparrait comme non déclaré.
lcelà veut dire que les objets doivent être créés uniquement dans le main ? et appelés du main ?
comment çà se passe pour pointer vers les objets créés à l'ouverture du programme et pendant l'exécution du programme ?

Les objets doivent être passés en paramètre dans les classes qui doivent les utiliser : (à titre d'exemple, on veut que la classe RenderMain utilise la classe Surface)

RenderMain.hpp

Code :

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

1
2
3
4
5
6
7
8
class Surfaces;//Déclaration anticipée de Surface
 
class RenderMain//La classe qui doit utiliser Surface
{
public:
    RenderMain(const Surfaces& surface);//On passe par reference (&) Surface. (Peut être fait dans le constructeur ou dans une fonction)
    //Pour un rendu, on peut même l'imaginer constante.
};

RenderMain.cpp

Code :

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

1
2
3
4
5
6
7
8
9
#include "RenderMain.h"
#include "Surface.h"//On inclut l'entête de la classe Surface
 
RenderMain::RenderMain(const Surfaces& surface)
{
    ...
    surface.render();//On l'utilise
    ...
}

main.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "Surface.h"
#include "RenderMain.h"
 
int main()
{
    Surfaces surf(1,4);
 
    while (!glfwWindowShouldClose(window))
    {
        RenderMain renderMain(surf);
    }
}

[ternel]

Pour la première question:

A l'exécution, la création d'un objet se passe en trois phases:

1. attribution de mémoire pour contenir l'objet.
   Pour une variable locale, c'est dans la fameuse pile.
   Pour un new, le programme demande au système un bloc mémoire (un peu comme un malloc du C)
2. remplissage de la mémoire
   C'est la très importante liste d'initialisation ( : a(1) dans le code suivant)
   

   Code :

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

   1
   2
   3
   4
   5
   classe bidule {
       int a, b;
   public:
       bidule() : a(1) {};
   };

3. l'objet est créé, on peut le construire: exécution du corps du constructeur.
   Les fonctions sont disponibles, mais ne sont pas encore virtuelles (vers les descendants).

Ce qui n'est pas initialisé explicitement sera construit par défaut. (ce qui veut dire rien de valable pour les types primitifs)
Certaines choses sont invariantes: les références, les constantes, la construction des classes parentes, etc. Seule la liste d'initialisation peut s'en charger.

Ainsi, le code suivant ne compile pas.

Code :

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

1
2
3
4
5
classe bidule {
    int & reference;
public:
    bidule(int & r) {reference = r};
};

En effet, le corps du constructeur ne contient qu'une affectation à reference, donc à ce que celle-ci réfère
Et ce qui pose surtout problème, et ce sera le message du compilateur, reference n'est pas initialisé.

La bonne syntaxe (et la seule) est :

Code :

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

1
2
3
4
5
classe bidule {
    int & reference;
public:
    bidule(int & r) : reference(r) {}
};

[karistouf]

Bonjour et d'abord merci de vos réponses ! super !

nb: rendermain() est ma fonction OnDisplay() d'affichage dans la fenêtre

J'ai encore deux questions !
1/
je comprends donc pour dessiner un objet créé, il faut que la fonction dessiner soit un membre de cet objet.
ou alors que je déclares dans mon point.h général des objets ?

Code :

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

1
2
3
 
Surfaces::Objet1;
Surfaces::Objet2;

à tout le monde dans le code?

Ce qui me pose aussi question, c'est comment créer n objets par une boucle au démarrage de mon programme?

Code :

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

1
2
3
4
5
 
for(int i=0;i<max_objet;i++)
{
Surfaces::Identité_de_l_objet[i];/// ?
}

2/ pour la création d'un objet, je me posais en effet la question de l'initalisation en effet, mais en passant par des fonctions membres. Je mets ici un bout de 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
 
 
class Surfaces
{
public://fonction membres allias méthodes
 
    Surfaces();//constructeur
 
    Surfaces(int ID, int nb_points);
 
    ~Surfaces();//destructeur
 
    void give_a_name(std::string const &name);//user define
    std::string return_a_name();
 
    void build_shape(int nb_points);//build vertex default
    int return_nb_points();
 
    void init_VBO_VAO();//init VBO and VAO
    void refresh_VBO_vertex_array();//refresh position of points
    void create_shaders();//m_VS et m_FS glCreateShader
    void compile_attach_shaders(const string &shadercode, GLenum shader_type);
    void create_program();
    void draw();
 
    //count number of objects on creation
    void ajoute();
    void retire();
 
 
private://variables membres allias attributs
 
    int m_ID;//ID by calling constructor and destructor
 
    std::string m_name; //name of the shape, user define
 
    int m_nb_vert;//number of vertices for the shape
    vector<Vertex> m_vertex; //vertex x y z, see struct vertex
 
    GLuint m_VAO;//Vertex array object
    GLuint m_VBO;//Vertex buffer object
    GLuint m_program;
    GLuint m_VS;
    GLuint m_FS;
 
    const char* m_vertex_shader_code;
    const char* m_fragment_shader_code;
 
    float m_color[4];//r v b a
    float m_pos[3];//x y z
};

cpp

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
 
#include <Surfaces.hpp>
 
using namespace std;
 
//constructeur
Surfaces::Surfaces()
{
}
//constructeur par liste d'initialisation//////////
Surfaces::Surfaces(int ID, int nb_points)
: m_ID(ID),m_nb_vert(nb_points)
{
    ajoute();
    build_shape(nb_points);
    string nameis = "Forme " + ID;
    give_a_name(nameis);
    init_VBO_VAO();
    refresh_VBO_vertex_array();
    create_shaders();
 
    string default_VS=
    "#version 140\n in vec3 vp; \n void main () { gl_Position = vec4 (vp, 1.0);}\n";
	string default_FS=
	"#version 140\n out vec4 frag_colour; \n void main () {	frag_colour = vec4 (0.7, 0.7, 0.5, .7);}\n";
 
    compile_attach_shaders(default_VS,GL_VERTEX_SHADER);
    compile_attach_shaders(default_FS,GL_FRAGMENT_SHADER);
    create_program();
 
}
 
//destructeur
Surfaces::~Surfaces()
{ 
retire();//pour descendre mon décompte d'objet créés ?
}
 
 
void Surfaces::give_a_name(std::string const &name)
{
m_name=name;
}
 
std::string Surfaces::return_a_name()
{
return m_name;
}
 
//etc etc...
 
void Surfaces::ajoute() {
    nb_Surfaces++;
    m_ID=nb_Surfaces;
}
 
void Surfaces::retire() {
    if (nb_Surfaces > 0) nb_Surfaces--;
}

Faut il que je revoie la façon de faire les fonctions membres ?

Merci !

[bacelar]

Pour faire une synthèse de la réponse de leternel, tu peux appeler des fonctions membres/méthodes de votre objet dans son constructeur si elles ne sont pas virtuelles.
Attention, il ne faut pas s'attendre à une erreur à la compilation mais à un comportement indéterminé et variable en fonction du compilateur et des options de compilation.

1/ pas claire, votre question.
Un truc répétitif est forcement une erreur.

Pour gérer des groupes d'objets, création comprise, regardez du coté des std::array ( http://fr.cppreference.com/w/cpp/container/array ) et des std::vector (http://www.cplusplus.com/reference/vector/vector/ )

2/ A la fin d'un constructeur, l'objet doit être opérationnel (sauf rares exceptions), donc pas de constructeur sans paramètre.
Les méthodes d'initialisations devraient être privées car non appelable par le code client ni "surchargeable" par les classes filles.
Les méthodes "ajouter" et "retirer" sont très suspectes.