Je suis pas persuadé de cela. Néanmoins, j'ai jamais réellement vu un code procédurale très bon.Dobro a écrit :je pense qu'en procedurale, il y aura moins de lignes ..
C'est fauxje pense qu'en procedurale, il y aura moins de lignes ..
, je code aussi régulièrement en c++ , et y a pas photo , la poo facilite pas mal les choses , rend un code beaucoup plus "humain"Voici une classe fille :class Dessin
{
public:
/*constructeur , on initialise ce que tu veut dedans*/
Dessin()
{
nom = "il sera redefini dans les classes filles";
}
float position_x;
float position_y;
virtual void rendu() = 0;
protected:
std::string nom;
};
Triangle hérite de toute sa classe mère , on à redéfini la fonction de rendu car la classe mère avait une méthode virtuelleclass Triangle: public Dessin
{
public:
Triangle()
{
nom = "je suis un triangle";
}
void rendu()
{
std::cout << nom << std::endl;
}
};
class Rond: public Dessin
{
public:
Rond()
{
nom = "je suis un rond";
}
void rendu()
{
std::cout << nom << std::endl;
}
};
class Dobro: public Dessin
{
public:
Dobro()
{
nom = "je suis dobro !";
}
void rendu()
{
std::cout << nom << std::endl;
}
};
on construit nos objets en appelant les constructeurs :std::vector<Dessin*> maListe;
une des forces de la poo , c'est que nos objets sont différents , mais il tiendrons tous dans le vector :Rond * monRond = new Rond();
Triangle * monTriangle = new Triangle();
Dobro * monDobro = new Dobro();
et on parcour la liste pour le rendu :maListe.push_back(monRond);
maListe.push_back(monTriangle);
maListe.push_back(monDobro);
évidement c'est bateau comme exemple , met toi au c++ , et regarde comment est fait par exemple la sfml 2.0 , reagarde pour un sprite sfml 2.0 :std::vector<Dessin*>::iterator it;
for(it = maListe.begin(); it < maListe.end(); ++it)
{
Dessin * element = *it;
element->rendu();
}
Code : Tout sélectionner
#include <iostream> // pour cout
#include <vector> // pour la LL
class Dessin
{
public:
/*constructeur , on initialise ce que tu veut dedans*/
Dessin()
{
nom = "il sera redefini dans les classes filles";
}
float position_x;
float position_y;
virtual void rendu() = 0;
protected:
std::string nom;
};
class Triangle: public Dessin
{
public:
Triangle()
{
nom = "je suis un triangle";
}
void rendu()
{
std::cout << nom << std::endl;
}
};
class Rond: public Dessin
{
public:
Rond()
{
nom = "je suis un rond";
}
void rendu()
{
std::cout << nom << std::endl;
}
};
class Dobro: public Dessin
{
public:
Dobro()
{
nom = "je suis dobro !";
}
void rendu()
{
std::cout << nom << std::endl;
}
};
int main()
{
std::vector<Dessin*> maListe;
Rond * monRond = new Rond();
Triangle * monTriangle = new Triangle();
Dobro * monDobro = new Dobro();
maListe.push_back(monRond);
maListe.push_back(monTriangle);
maListe.push_back(monDobro);
std::vector<Dessin*>::iterator it;
for(it = maListe.begin(); it < maListe.end(); ++it)
{
Dessin * element = *it;
element->rendu();
}
}
g++ main.cpp -o main.exe
Code : Tout sélectionner
structure personnage
taille.l ; taille du personnage
vie.b ; vie du perso
x.l ; position x du perso
y.l ; position y du perso
nom.s
; etc...
endstructureCode : Tout sélectionner
structure personnage
taille.l ; taille du personnage
vie.b ; vie du perso
x.l ; position x du perso
y.l ; position y du perso
nom.s
; etc...
endstructure
dim perso.personnage(1)
dim triangle.personnage(1) ; utilise la meme structure que perso
perso(1)\taille=120 ; attribution pour test
perso(1)\nom.s="je suis un perso"
triangle(1)\x=100
triangle(1)\y=250
triangle(1)\nom.s="je suis un triangle"
debug perso(1)\taille ; on a 2 "objets " qui utilisent la meme structure ! (dans ce cas, je dirai que la structure est un objet en quelques sortes)
debug perso(1)\nom
debug triangle(1)\x
debug triangle(1)\y
debug triangle(1)\nom
) ... a mon ageje n'ai pas dit que c'était mieux, connaissant bien les deux , je te confirme que le poo est plus "pratique"franchement, ça ne me montre pas en quoi la POO est mieux que le procedurale
en pb cela donnerais :std::vector<Dessin*> maListe;
ensuite j'ai passer un Rond* un Triangle* & un Dobro* à cette liste :newlist *maListe.Dessin()
c'est trois type différent , mais il vont dans la même liste ! impossible en pb sans jouer d'astuces, les types ne se "mélange pas"maListe.push_back(monRond);
maListe.push_back(monTriangle);
maListe.push_back(monDobro);
Brouillon quoitu met chaque "objet" dans une proceduredll , que tu stock en librairie
bien sur que non , un code poo avant d'être compilé est aplati au même titre que la procédural , llvm transforme la poo en procedural avant de compiléenfin je ne pense pas que ce soit inaccessible au procedurale
Alors laisse tombé la pooj'ai déja eu du mal a me mettre au structure
)Oui, tout pareil...Dobro a écrit : mais comme je le répète, je n'entends rien en POO (et suis hermétique !
j'ai déja eu du mal a me mettre au structure, faut pas pousser non plus
).Dobro a écrit :je n'entends rien en POO (et suis hermétique !
)Moi je vais te le direlepiaf31 a écrit :En ce qui concerne PureBasic, pour programmer avec le "style" objet, on est quand même obligé de passer par des pointeurs, donc je ne vois pas l’intérêt
Non je ne crois pas que PB soit plus intéressant que JAVA ou C++ ^^Robrock55 a écrit : Purebasic est un langage qui présente un nombre de qualités assez incroyable, le rendant plus intéressant que le JAVA et le C++.
en c++ aussi...Pour ma part, je ne fais pas de C++ car je trouve plus que barbant de devoir faire des includes de bibliothèques alors qu'en PB, tu as déjà tout !
hop , ta la sfml de dispo dans ton programme !#include <SFML/Graphics.hpp>
hop , tu fait de l'opengl#include <GL/gl.h>
ouf , ta enfin accès a opengl , place à la chasse à la segfault maintenantImport "-lgl"
Prototype GlBegin(const.i)
...
...
...
EndImport
global GlBegin.GlBegin = getFunction(...
...
...
Code : Tout sélectionner
#include <iostream>
#include <string>
#include <vector>tu inclus se dont tu as besoin , le c++ ne sais rien faire à la base , juste de la compilation basique avec des opérations basique et des mots clé basique aussi, il ne sais même pas écrire dans un fichier ! PB est un langage clé en main , c'est avant tout un basic... , et si trois lignes c'est barbant , faut changé de hoobies#include <iostream>
#include <string>
#include <vector>