problème de classes

Version imprimable

09/01/2015, 10h57
karistouf

problème de classes
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:

1 2 3 4 5 6 7 8 9 Surfaces Surf(1,4); while (!glfwWindowShouldClose(window)) { RenderMain(); Surf.draw(); }
09/01/2015, 11h23
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 ?

Bonjour !

Citation:

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

Oui !(?)
Code:

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

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:

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:

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:

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

09/01/2015, 11h51
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:
  
  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:

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:

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

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:

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:

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:

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:

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 !

11/01/2015, 00h22
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.