Voila je me disais qui si chaqun postait des petit truc pour la programation ca pourais etre cool de partager no connaissance...

Data
www.ploksoftware.org

Je vais vous parlez d un truc tres pratique pour debuger que il sagit des traceable call stack .

Les traceable call stack sont 2 macros que l on place en debut et en fin de fonction. grace a ces deux macro si votre programme plante vous saurez automatiquement dans quelle fichier a quelle ligne et quelle fonction a planter . Mieux vous saurez meme quelle fichier a appeller cette fonction.

voici le source
------------------------------------------------
#define Guard(function) static char * __FUNCTION_NAME__ = #function;\
try {
#define UnGuard } catch (...) {\
time_t tt;struct tm *ttb;tt = time(NULL);ttb = localtime(&);\
std::cout<<"*********************CALL STACK*********************"<<std::endl;\
std::cout<<"* Date : "<<asctime(ttb);\
std::cout<<"* Module : "<<__FUNCTION_NAME__<<std::endl;\
std::cout<<"* Line : "<<__LINE__<<std::endl;\
std::cout<<"* File : "<<__FILE__<<std::endl;\
std::cout<<"* Make date : "<<__DATE__<<" "<<__TIME__<<std::endl;\
std::cout<<"*************************************************

• • "<<std::endl;\

throw; }
-------------------------------------------------

comme certain l auront remaqué il sagit d exception cachée a l interieur de macro
voici un exempl de comment l utiliser

void Mafonction(int arg)
{
Guard(void Mafonction(int arg))

... ici le code de la fonction

UnGuard
}

voila il n y a donc que 2 lignes a rajouter par fonction .

Ceci est un version simplifier des call stack il y a moyen de rediriger el totu vers un flux fichier ou meme d annuler le tracage si on est pas en mode debug . ..

pour ceux qui veullent le fichier complet
http://users.skynet.be/Data/ExCTrace.h

Data
www.ploksoftware.org

Sympa ton idée : )

Bon alors pour commencer ca sera un petit truc pour placer des breakpoints dans un programme (sans utiliser ceux de visual c++ ; o)

1. define MyBreakPoint __asm {int 3}

Je vous laisser deviner comment on s´en sert

pourkoi tant se compliké la vie alors ke la fenetre call stack de visual C++ 6 fonctionne si bien ?
pourkoi tant se compliker la vie alors ke la touche F9 de visual C++ 6 fonctionne si bien ?

Tu as déjà essayé de débugger du DirectX plein écran ? : ) ta call stack tu vas avoir du mal à la contrôler . ...

Pour le breakpoint teste le truc : ) regardes bien la différence entre un breakpoint en Debug avec Visual et le breakpoint que j´ai donné . ... Essaie d´exécuter ton programme avec Ctrl+F5 : ) les breakpoints de Visual ne fonctionnent pas (puisque on debug pas) mais le "int 3" oui : ) ca a son utilité dans certains cas (dans le même principe que les assertions....)

je comprend tres bien ce ke tu veu dire.
ok

Les call stack marche meme si ton prog est deja compiler et est lancé en dehors de l environement de visual. Comme ca si le prog plante chez un beta teteur il lui suffit de t envoyer la copie d´ecran de la consol et tu as toute les infos.

Je te rappelle aussi que tout le monde a pas visual mais si je trouv que c est le meillieur.

Data

www.ploksoftware.org

Alors quelques optimisations en vrac :

1) Ne pas hésiter à utiliser la pré-incrémentation (écrire ++i au lieu de i++) (le programme incrémente alors i AVANT d´éxécuter la fct dans laquel ++i est)

Par ex :

v = 0;

if(v++ == 1)
{
...
}

le if retourne false, vous perdez un cycle bêtement, alors que if(++v == 1) lui, retourne true;

2) Ne pas oublier d´utiliser les mots "const" dans les définitions de fcts lorsque la variable n´est pas censé être modifiée, ça permet au compilo d´optimiser un peu plus.

unsigned long Square(const long i) au lieu de unsigned long Square(long i);

3) Eviter les :

if(a == b)
c = true;
else
c = false;

c´est aussi rapide d´écrire c = a==b;

4) Eviter les imbrications de boucles, surtout quand elles ont peu d´itérations, développer les.

for(int i=0; i<3; i++)
{
mon_tableau[i] = ma_fonction();
}

devient :

mon_tableau[i=0] = ma_fonction();
mon_tableau[++i] = ma_fonction();
mon_tableau[++i] = ma_fonction();

5) Dans le domaine de la 3d, évitez l´utilisation abusive des matrices !

Par exemple, un objet à sa propre matrice qui définit sa transformation. Je veux faire un Scale sur l´objet, alors je fais (en D3D) :

void Mesh::Scale(const float x, const float y, const float z)
{
D3DXMATRIX Scale;
D3DXMatrixScaling(&, x, y, z);
this->Matrix *= Scale;
}

Bon, ça a l´avantage d´être court et simple, mais est-ce vraiment efficace ? N´hésitez pas à développer vous même les calculs, pour éviter un maximum les opérations inutiles.

Bon, ça va sembler évident à certains ce que j´ai dit, mais en tout cas c´était des erreurs et des étourderiesq que je faisais, donc c´est pas impossible que d´autres les fasse aussi

c´est peut etre de l´optimisation si tu connais ton compialteur, mais c´est risqué car ca peu causer des side-effects.

voila a mon tour ce ke je conseille:

kan vous commencez un programme faites une classe MyApp et mettez les variables ke vous auriez déclarées globales dedans et les fonctions du module dedans aussi.
declarez la classe en global au dessus de winmain
et dans winmain appelez la methode MyApp::Create(hInstance); (par exemple)
et puis mettez return 0; tout de suite en dessous et voila une fonction main de 2 lignes.
et faites tout votre app en objet c´est bien plus pratique.
evitez d´allouer vous meme des tablos avec new (pensez meme pas a malloc c un vieu truc du c) parce ke on peu oublier de désalouer utilisez des classes de tableau sécurisés car au moins la désallocation est gérée dans les destructeurs on est sur de pas l´oublier.

Utilisez la stl c est plein de truc super pratique et coder par de professionelle

Tableau,vecteur,hash map,algo,...

Data
www.ploksoftware.org

PS je viens de finir une lib de chargemetn d image pcx,ppm,tga et bmp pour ceux que ca interesse.

Lightness1024 :
"c´est peut etre de l´optimisation si tu connais ton compialteur, mais c´est risqué car ca peu causer des side-effects."

C´est-à-dire ?

oublies, j´ai survolé trop vite ton post.