J´ai fais un petit programme qui permet d´écrire 3 variables ( int , signed short int, signed short int) dont le contenu est capturé de stdin. Ça fonctionne merveilleusement bien ! Mais une nouvelle question vient de me frapper suite à ce succès. Qu´est-ce que l´entête d´un fichier exactement ? Je crois qu´il s´agit d´une zone qui contient des informatiosn relatives au fichier en question ( du genre, le format utilisé pour un vidéo, la durée, truc du genre) ? Est-ce que l´entête d´un fichier n´est rien de plus que des données inscrites et lisibles comme le reste du corps du document ?

Un entete de fichier n´existe que théoriquement. En fait, c´est le programmeur qui a choisi d´ecrire ces informations qui lui permettent de manipuler le reste du fichier.

Elle est ecrite de la meme façon que le reste du fichier, elle n´est pas obligatoir.

Merci beaucoup, c´est en plein la réponse que j´espérais .

Hmmm j´ai peut-être un peu trop de questions ( ignorez moi si c´est le cas ) mais est-ce que quelqu´un pourrait définir un template pour moi ? Je viens de lire l´explication dans le guide de Christian Casteyde ( http://casteyde.christian.free.fr/ ) et, franchement, je n´arrive pas à comprendre ni le fonctionnement ni le résultat donné par un de ces trucs. Peut être un exemple avec un petit programme ?

ou va ton pour créé un jeu

moi j´ai une kestion: pk je pige pas gd chose? arg... jm´en fous, je vous bat tous en bataille de pouce!

Codejunqui > >
http://perso.wanadoo.fr/ck/Langages.htm

grosbill7b > >
Probablement parce que tu connais pas/peu la prog en C/C++

TechSlash > comme te disait ruffi, l´entete d´un fichier, c´est toi qui la fait ou non.
--> tu envoies des données a la suite dans ton fichier.
dans l´exemple que je t´ai donné sur les joueurs, on " pourrait" par exemple définir l´entete comme étant uniquement la variable X, et le corps comme étant les joueurs avec leur vie, tout ça !

Un autre exemple : un fichier BMP, c´est une entete qui contient entre autre le X,Y, la profondeur de couleurs, toutes sortes de données inutiles, la palette éventuelle utilisée, etc etc
puis derriere l´entete, tu as les données brut de l´image.

Le template, c´est de la généricité.
petit exemple : imagine que tu aies une fonction " minimum" qui prend 2 nombres, et retourne le plus petit :
sans template, tu écris :

int minimum(int a,int b)
{
if ( a<b) return a;
else return b;
}

mais maintenant, disons que tu veux tester 2 " double" :

double minimum(double a,double b)
{
if ( a<b) return a;
else return b;
}

et la tu te dis " j´ai déja tapé ça, mais avec un autre type..."

alors au lieu de l´écrire 2 fois, tu écris :

template < class T> / / type générique appelé T
T minimum(T a,T b)
{
if ( a<b) return a;
else return b;
}

et le compilateur construira tout seul la fonction minimum avec un int ou un double selon les besoins qu´il a.

Et non seulement tu peux mettre des int et des double, mais aussi des types que tu définis toi meme : voir carrément une instance de classe !
la seule contrainte pour cet exemple, c´est que tu saches comment définir si a<b ou non : ce qui implique qu´il faut surcharger l´opérateur < dans la classe.
En gros, pour cet exemple, tu mets le type que tu veux, a condition que le " <" soit défini.

C´est quand meme du C++ bien avancé tout ça
Dans les STL du C++ ( structures de listes chainées etc, . ..) tout marche en template !
ainsi tu peux faire des listes de int, de double ou de pois-chiches pour peu que tu les aie définis...

Mais dans un 1er temps, si tu n´es pas trop familier avec les template, ne les utilise pas. Retiens juste que ça existe, et que ça sert si et seulement tu fais la MEME fonction, mais avec des types différents, pour éviter de réécrire plusieurs fois la meme chose...

Logique......

Merci bcp, ça clarifie les choses! À se demander pourquoi c´est pas écrit comme ça dans le cours .

C´est en effet peut-être avancé pour quelqu´un comme moi ( j´apprends de façon la plus autodidacte possible en utilisant les ressouces que je trouve ici et là sur le web). Mais je passe point par point le cours de M. Casteyde et j´en suis pas mal là. Pas que je maîtrise parfaitement tout ce qui vient avant ( encore des concepts un peu flou ici et là qu´il faudrait que je mette en application pour bien comprendre...) mais j´y travaille tranquillement.

Je commence à me demander si j´ai vraiment besoin d´aller aussi loin par contre. Certains trucs commencent être des prises de tête ennuyantes... comme les templates ( qui sont plus clairs maintenant), les classes abstraites, les membres statiques dans les classes et même la surcharge que je n´ai pas encore pratiqué ( bien que, pour la surchage, je sais que c´est très utile et souvent nécessaire en POO).

M´enfin, je m´écarte du sujet du post, merci encore !

j´ai lu le cours de Christian Casteyde, et il est vrai qu´il rentre souvent dans les détails, et parle de trucs dont 0.005 % des programmeurs se servent ( exemple, les variables " volatile", qui ne servent qu´en multithreading)

A mon avis, en ce qui concerne l´objet, voit surtout les classes : constructeurs, destructeurs, héritage, surcharges.
Le reste : généricité, polymorphisme, statique ou non, foncteurs, etc etc, tu peux t´en passer, et tu pourras y revenir le jour ou tu seras déja tres tres a l´aise avec la base

Excellent plan .

J´ai déjà mon petit projet de jeu d´ailleurs, commence vraiment à être temps de sortir ça de la glace et d´utiliser enfin tout le bourrage théorique . Reste qu´à voir la surcharge et je suppose que je peux prendre un crayon, un cahier et planifier le moteur.

utilise une lib graphique existante !
- SDL pour la 2D
- OpenGL pour la 3D

par exemple
tu as déja manipulé une lib graphique ?

Oui, légèrement...

En OpenGL + GLUT j´avais fais une caisse ( un cube texture-mappé) qui tourne avec les flèches du clavier

En SDL + SDLimage j´avais programmé une fenêtre pour faire apparaitre du texte à l´écran. J´ai dessiné un sprite contenant toutes les lettres de l´alphabet, minuscule et majuscule. À chaque fois qu´une touche était enfoncé, le programme créait une surface, lui appliquait le sprite et resizait la surface pour n´afficher que la lettre choisie. Pas très optimisé mais ça marchait. Ce qui me fait penser qu´il faut que j´apprenne comment utiliser un fichier de police.

Direct X j´avais fait un cylindre avec une lumière dynamique qui se déplaçait avec les mouvements de la souris.

Sauf que dans tous les cas c´était des expérimentations qui reposaient beaucoup sur des tutoriels écrient par d´autres personnes. J´ai effacé tout ça et j´ai recommencé avec la base du C++ après avoir réalisé que tout ça allait nul part.

ben moi je pense qu´au contraire ça aide de réaliser des petits exemples comme ça

En tout cas tu es sur la bonne voie pour réaliser de belles choses

en ce qui concerne la lecture du font, SDL a plein d´add on, et entre autre SDL_TTF je crois ( regarde sur le site officiel) qui permet de lire un fichier font.

Bien c´est encore moi avec un problème !

Cette fois c´est la surcharge.

J´ai réussi à surcharger les opérateurs internes ( les opérateurs surchargés à l´intérieur d´une classe dans lesquels le premier opérande est celui sur lequel la fonction est appliqué ( =+ , =- par exemple)

J´essais de surcharger les opérateurs externes ( surcharge d´un opérateur de l´espace de nommage global).

Encore une fois, le cours me semble nébuleux.

Ma méthode d´overload est la suivante:
MyClass operator+(MyClass *s1, MyClass *s2)
{
MyClass reCl;
reCl.writa((*s1).printa() + ( *s2).printa());
return reCl;
}

je reçois l´erreur:
error C2803: ´operator +´ must have at least one formal parameter of class type

et franchement j´ignore pourquoi...

C´est parce que tu passes des pointeurs. Et dans une surcharge, il ne faut pas passer de pointeurs :

MyClass operator+(MyClass s1, MyClass s2)
{
MyClass reCl;
reCl.writa(s1.printa() + s2.printa());
return reCl;
}

devrait mieux marcher !
de plus, si dans un opérateur tu accedes des données internes, il faut déclarer ta fonction en tant que " friend"
Ainsi, tu pourras faire :
s1.a + s2.a

meme si a est private.

autre chose : ta syntaxe :
s1.printa() + s2.printa() me parait louche !
tu veux additionner 2 print ?

encore une astuce, le jour ou tu utilises des pointeurs :

la syntaxe ( *s).truc existe, elle marche, mais il existe une maniere plus simple de l´écrire, plus lisible qui revient au meme :
s->truc

Merci, wow, c´est beaucoup à la fois

> tu veux additionner 2 print ?

printa une une fonction public qui retourne la valeur de int a; en gros, c´était une façon d´éviter d´avoir à faire un friend puisqu´il est dit dans le guide de M. Casteyde que les friends représentent souvent des défauts de conception et de planification dans un objet. Maintenant que j´y repense, ma méthode est probablement un défaut de conception encore plus grand ( puisque beaucoup plus compliquée) mais bon, on va faire avec ce qu´on a.

> s->truc

chic, je vais devoir tester ça, je pensais que l´opérateur -> c´était pour quand le pointeur est sur la donnée/méthode qui est manipulée et non sur l´objet ( autrement dit quand le * est à la droite du point).

Merci bien encore une fois ! J´aimerais savoir cependant, est-ce que tu dors des fois ? Un message à 02:29:05 et un à 07:46:41. Je calcul rapidement mais ça fait 5:17 de sommeil ça non ?

Sans les pointeurs, ça fonctionne, en effet ! C´est incroyable les objets et la surcharge, on en vient à se demander comment un langage de prog. peut vivre sans avoir ça .

ah les surcharges, C du bon ça
un truc utile : une classe " vecteur" par exemple, que j´utilise pour OpenGL qui prend en surcharge [] pour accéder aux coordonnées, +, -, += -= pour les opérations

• pour le produit sclaire, ou pour multiplier un vecteur par une composante, / pour le produit vectoriel ( par exemple), etc !

tres pratique

Sinon, en effet, cette nuit, j´ai pas bcp dormi, lol ! Hier soirée, soirée Tarot avec des potes jusqu´a tres tard, ce matin boulot. Je dormirai ce WE ( d´ailleurs, je m´absenterai des ce soir jusqu´a dimanche soir ( GMT) ( tu es du canada je vois))
Bon allez, je dois aller au boulot ! De toute façon, je passe sur le forum au boulot aussi, pendant des petites pauses !
a++ !