Language de programmation ??
- Statut
titloup
Elite
Didju... et t'as fait comment pour avoir ton EXE? t'as fait comment pour installer ce truc? T'as quoi comme interface déjàHacko a dit:
? Comme fonctions? Comme aide? Comme debugger? Comme composants?... ... ... ... ...Cobol c'est le langage des années 80, on ne touche pas aux poussiéres
MoTh
PaW
C'est très bien de mélanger portabilité, compatibilité et standard.
Va pas balancer ce genre de remarque lors d'un entretient d'embauche, car dans mon cas je t'engage vraiment pas .....
Si je me souviens bien la question originale était quelle language utiliser pour faire des EXE, alors bon je vois pas trop ce que linux vient la dedans.
Va pas balancer ce genre de remarque lors d'un entretient d'embauche, car dans mon cas je t'engage vraiment pas .....
Si je me souviens bien la question originale était quelle language utiliser pour faire des EXE, alors bon je vois pas trop ce que linux vient la dedans.
THiBOo
Elite
Bin d'accord avec Wolf
le C est très bien, mais restrictif, et un peu vieu... cependant si tu désires programmer des progs pour Linux, le C est encore fort répandu.
le C++ est tiré du C, et possède toute les fonctionnalité du C plus des fonctionnalité bien à lui dont d'ailleurs la "fameuse" i++ ou ++i, qui permet d'incrémenter i ( qui doit être déclaré comme variable ). ( c'est un exemple parmis tant d'autres ) la véritable nouveauté du C++ c'est qu'il est plus orienté objet que le C ( apparition de l'idée de classe )
le java, très bien, mais assez lent je dirais ... très bien pour des application graphique ...
l'assembleur alalalaa les joies de l'assembleur ou comment rendre compliquer les choses simple , dépassé, archaïque, mais rapide et performant, foutre une petite fonction asm peut bien aléger votre programme, et c'est parfois très utile, voir indispensable ...
le COBOL pas un système de programmation ça, tu parle à ton ordi en lui demande gentiment de faire qqc, et il comprend jamais lol ( ceux qui connaissent comprendront )
le Delphi connait pas ( de nom seulement )
le FORTRAN moouahahahahah dépassé
Visual Basic, sympa pour commencer permet de vite faire des ptit truc sympa, et tout ...
exemple des différent langage :
C :
travaillant la plupart du temps en C++ j'ai fait un ptit prog vite fait
C++ :
créé un labyrinthe avec un système de case clé et téléporteurs et trouve la maniere la plus courte d'en sortir
Assembleur :
ça décryptait un message donné ...
Visual Basic :
un petit bonhomme pendu
vala vala
le C est très bien, mais restrictif, et un peu vieu... cependant si tu désires programmer des progs pour Linux, le C est encore fort répandu.
le C++ est tiré du C, et possède toute les fonctionnalité du C plus des fonctionnalité bien à lui dont d'ailleurs la "fameuse" i++ ou ++i, qui permet d'incrémenter i ( qui doit être déclaré comme variable ). ( c'est un exemple parmis tant d'autres ) la véritable nouveauté du C++ c'est qu'il est plus orienté objet que le C ( apparition de l'idée de classe )
le java, très bien, mais assez lent je dirais ... très bien pour des application graphique ...
l'assembleur
alalalaa les joies de l'assembleur ou comment rendre compliquer les choses simple , dépassé, archaïque, mais rapide et performant, foutre une petite fonction asm peut bien aléger votre programme, et c'est parfois très utile, voir indispensable ...le COBOL pas un système de programmation ça, tu parle à ton ordi en lui demande gentiment de faire qqc, et il comprend jamais lol ( ceux qui connaissent comprendront
)le Delphi connait pas
( de nom seulement )le FORTRAN moouahahahahah dépassé
Visual Basic, sympa pour commencer
permet de vite faire des ptit truc sympa, et tout ...exemple des différent langage :
C :
Code:
# <iostream.h>
void main ( )
{
int i, j;
cout << "Introduisez un nombre entier :";
cin >> i;
cout << "Introduisez un deuxième nombre entier :";
cin >> j;
cout << "La somme est :" << ( i+j ) << endl;
cout << "Tapez sur une touche pour stopper";
cin >> i;
}C++ :
Code:
#include <iostream.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>
int vx[4]={0,1,0,-1}; //vecteurs de directions possibles
int vy[4]={1,0,-1,0};
int sol=INT_MAX; // prend la valeur maximale possible, c'est la solution finale
int sol_part=0; // solution partielle
int cpt_key=0; // compteur de clé possédées
//----------------------------------------------------------------------------------------------
// Classe Elem
//----------------------------------------------------------------------------------------------
class Elem
{
private :
bool debut; // permet juste de savoir si l'on est au début ou pas
bool fin; // idem pour la fin
bool key; // idem pour une clé
bool teleport; // idem pour teleporteur
int ligne;
int colonne; // coordonnées du point
int cpt; // sauve le nbr de clés lors de chaque passage
public :
Elem();
friend class Labyrinthe;
};
//----------------------------------------------------------------------------------------------
// Constructeur d'elem
//----------------------------------------------------------------------------------------------
Elem::Elem()
{ // tous les param sont par défaut
debut=false;
fin=false;
key=false;
teleport=false;
ligne=-1;
colonne=-1;
cpt=-5; // on doit juste initaliser à une valeur inférieure à 0
}
//----------------------------------------------------------------------------------------------
// Class Labyrinthe
//----------------------------------------------------------------------------------------------
class Labyrinthe
{
private:
int n; // ligne
int m; // colonne
int cle; // nb de clefs dans le labyrinthe
int tel; // nb de teleporteurs dans le labyrinthe
public:
int in_x, in_y; // sauvegarde juste les coordonnées de l'entrée
Labyrinthe(int,int, int, int); // constructeur
~Labyrinthe(); // destructeur
Elem** M; // pointeur de pointeur d'elem permet d'accéder à la matrice
void Init_Lab(); // initialise le labyrinthe
void in_out();
void Key();
void Teleporter();
void Print();
void BB(int, int);
};
//----------------------------------------------------------------------------------------------
// Constructeur
//----------------------------------------------------------------------------------------------
Labyrinthe::Labyrinthe(int x,int y, int c, int t)
{
n=x;
m=y;
cle=c;
tel=t;
M=new Elem* [n]; // création dynamique
for ( unsigned short i=0; i<n; i++ )
M[i]=new Elem [m];
Init_Lab(); // appel de la fonction initialisation labyrinthe
}
//----------------------------------------------------------------------------------------------
// Destructeur
//----------------------------------------------------------------------------------------------
Labyrinthe::~Labyrinthe ()
{
for (unsigned short i=0; i<n; i++ )
delete M[i];
delete M;
}
//----------------------------------------------------------------------------------------------
// Fonction Init_Lab
//----------------------------------------------------------------------------------------------
void Labyrinthe::Init_Lab ()
{
in_out(); // mise en place de l'entrée et de la sortie
Key(); // mise en place des clefs
Teleporter(); // mise en place des teleporteur
}
//----------------------------------------------------------------------------------------------
// Fonction In_out
//----------------------------------------------------------------------------------------------
void Labyrinthe::in_out ()
{
unsigned seed = time(NULL);
srand (seed); // utilisation du random
int i,j;
i=rand()%n;
M[0][i].debut=true; // on place le debut sur la première ligne
in_x=0; // sauvegarde des coord du début
in_y=i;
j=rand()%n;
M[n-1][j].fin=true; // et la fin sur la dernière ligne
}
//----------------------------------------------------------------------------------------------
void Labyrinthe::Key()
{
unsigned seed = time(NULL);
srand(seed);
int h=0; // nbr de clefs placées dans le labyrinthe
while (h<cle)
{
int i,j;
i=rand()%n;
j=rand()%m;
if (!M[i][j].key && !M[i][j].debut && !M[i][j].fin )
// la case ne peut pas déjà posséder une clef, ni être le début ou la fin du
// labyrinthe, ni un teleport, mais il ne sert à rien de tester ça pour le
// moment, aucun teleport n'a déjà été placé
{
M[i][j].key=true;
h++;
}
}
}
//----------------------------------------------------------------------------------------------
// Fonction Teleporter
//----------------------------------------------------------------------------------------------
void Labyrinthe::Teleporter()
{
unsigned seed = time(NULL);
srand(seed);
int h=0; // cpt de teleporter déjà placé
while (h<tel)
{
int i,j;
i=rand()%n;
j=rand()%m;
if (!M[i][j].key && !M[i][j].debut && !M[i][j].fin && !M[i][j].teleport )
// la case ne peut être ni une clef, ni le début, ni la fin, ni un teleport
{
M[i][j].teleport=true;
M[i][j].ligne=rand()%n; // il faudrait bcp de malchance pour que
M[i][j].colonne=rand()%m; // les teleport fassent des cycles ...
h++;
}
}
}
//----------------------------------------------------------------------------------------------
// Fonction Print
//----------------------------------------------------------------------------------------------
void Labyrinthe::Print()
// uniquement des artifices d'affichage
{
for (int i=0; i<n; i++ )
{
cout << "-";
for (int j=0; j<m; j++)
cout<< "--";
cout << endl;
for (int j=0; j<m; j++)
{
cout << "|";
if (M[i][j].debut)
cout << "D";
else if (M[i][j].fin)
cout << "F";
else if (M[i][j].key)
cout << "K";
else if (M[i][j].teleport)
cout << "T";
else
cout << " ";
}
cout << "|";
cout << endl;
}
cout << "-";
for (int j=0; j<m; j++)
cout<< "--";
}
//----------------------------------------------------------------------------------------------
// Fonction BB ( branch and bound )
//----------------------------------------------------------------------------------------------
void Labyrinthe::BB(int line,int column)
{
int x1, y1;
if( M[line][column].fin && cpt_key==cle) // si on arrive sur la case fin et que l'on a
// toutes les clefs, c'est fini
{
if(sol_part<sol)
sol=sol_part;
}
else
{
for (int i=0; i<4 ; i++) // sinon on teste les 4 direction possible
{
x1=line+vx[i];
y1=column+vy[i];
if ((x1>=0 && x1<n) && (y1>=0 && y1<m) && (M[x1][y1].cpt<cpt_key))
{
int j=cpt_key; // sauvegarde du nbr de clé
if(M[x1][y1].key) // cas d'une case cle
{
cpt_key++; // augmentation du compteur de cle
M[x1][y1].key=false; // la cle disparait -> booleen passe a false
}
sol_part++; // on avance d'une case
int save=M[x1][y1].cpt; // sauvegarde du nbr de clé lors du dernier
// passage sur la case
M[x1][y1].cpt=cpt_key; // on assigne à cette valeur le nbr de cle actuel
if(sol_part<=sol) // si le nbr de case n'a pas dépassé de le nbr de case max
{
if(M[x1][y1].teleport) // cas d'un teleporteur
{
x1=M[x1][y1].ligne;
y1=M[x1][y1].colonne; // on sauve les coord, qui seront notre
// prochain point
}
BB(x1,y1); // appel récursif
}
sol_part--;
M[x1][y1].cpt=save;
if(cpt_key>j)
{
cpt_key--;
M[x1][y1].key=true;
}
}
}
}
}
//----------------------------------------------------------------------------------------------
void main()
{
int x, y, c, t, q;
cout << "Entrez le nombre de lignes souhaitees :" << endl;
cin >> x;
cout << endl << "Entrez le nombre de colonnes souhaitees :" << endl;
cin >> y;
cout << endl << "Entrez le nombre de clefs souhaitees :" << endl;
cin >> c;
cout << endl << "Entrez le nombre de teleporteurs souhaitees :" << endl;
cin >> t;
Labyrinthe L (x,y,c,t);
cout << endl << endl;
L.Print();
L.BB(L.in_x,L.in_y);
if (sol==INT_MAX)
cout << endl << endl << "Pas de solution";
else
cout << endl << endl << sol;
cout << endl << "Appuyez sur une touche pour quitter :" << endl;
cin >> q;
}Assembleur :
Code:
XOR EAX,EAX ;mise à 0
XOR ESI,ESI ; mise à 0
MOV ECX,[m] ; m = nb colonne
MOV EDI,[n] ; n = nb ligne
MOV EBP,1
Bcle1:
MOV EBX,EDI ; on assigne le nb de ligne à EBX
XOR ESI,ESI ; on met à 0
ADD ESI,EAX ; on avance d'une colonne
XOR [A+ESI*4], EBP ; on est sur la case a la ligne 0 et on fait le XOR avec la colonne exposant 0 cad tjr 1
ADD ESI,ECX ; on avance d'une ligne
DEC EBX ; on décrémente EBX ( le nb de ligne )
XOR [A+ESI*4],EAX ; on est sur la case à la ligne 1 et on fait le XOR avec la colonne exposant 1 cad la ; colonne elle-meme
ADD ESI,ECX ; on avance d'une ligne
DEC EBX ; on décrémente EBX ( le nb de ligne )
MOV EDX,EAX ; on assigne le numéro de la colonne
Bcle2:
IMUL EDX,EAX ; on multiplie le numéro de la colonne par lui meme
XOR [A+ESI*4],EDX ; XOR avec la colonne exposant la ligne
ADD ESI,ECX ; on avance d'une ligne
DEC EBX ; on décrémente EBX
JNZ Bcle2 ; lorsque EBX ( les lignes ) vaut 0 on sort de la
boucle
INC EAX ; on incrémente EAX de 1
LOOP Bcle1 ; tant que ECX ( les colonnes ) ne vaut pas 0 on continueVisual Basic :
Code:
Dim strmot As String, strlettre As String * 1, strletmot As String * 1
Dim strletprec As String, strletinter As String * 1, stretap As String
Dim intlmot As Integer, inti As Integer, interreur As Integer
Dim blntrouve As Boolean
Const PENDU = 8
Private Sub Form_Load()
'le bonhomme est tout caché
Shape1.Visible = False
Shape2.Visible = False
Shape3.Visible = False
Shape4.Visible = False
Shape5.Visible = False
Line8.Visible = False
Line9.Visible = False
Line10.Visible = False
End Sub
Private Sub Command1_Click()
'le bonhomme est re-tout caché lorsqu'on clique sur démarrer
Shape1.Visible = False
Shape2.Visible = False
Shape3.Visible = False
Shape4.Visible = False
Shape5.Visible = False
Line8.Visible = False
Line9.Visible = False
Line10.Visible = False
'entrer le mot
strmot = InputBox("Entrez le mot a découvrir", "JOUEUR 1", "*^*^*^*^*^*^*", 5000, 8000)
intlmot = Len(strmot)
stretap = ""
For inti = 1 To intlmot Step 1
stretap = stretap & "-"
Next inti
Text1.Text = stretap
interreur = 0
'entrer lettre par lettre
Do
strlettre = InputBox("Découvrez une lettre du mot caché", "JOUEUR 2", , 5000, 8000)
strprec = stretap
stretap = ""
blntrouve = False
For inti = 1 To intlmot Step 1
strletmot = Mid(strmot, inti, 1)
If strletmot = strlettre Then
stretap = stretap & strlettre
blntrouve = True
Else
strletint = Mid(strprec, inti, 1)
stretap = stretap & strletint
End If
Next inti
If blntrouve = False Then
interreur = interreur + 1
End If
'apparition du bonhomme successivement
Select Case interreur
Case 1
Shape1.Visible = True
Case 2
Shape2.Visible = True
Case 3
Shape3.Visible = True
Case 4
Shape4.Visible = True
Case 5
Shape5.Visible = True
Case 6
Line8.Visible = True
Case 7
Line9.Visible = True
Case 8
Line10.Visible = True
End Select
Text1.Text = stretap
Loop Until interreur = PENDU Or strmot = stretap
'message de fin
If interreur = PENDU Then
MsgBox ("Looser")
Else
MsgBox ("congratulations")
End If
End Subvala vala
titloup
Elite
LoLMoTh a dit:
Kekum... c'était un exemple de portabilité... vois-tu s'il veut utiliser ses EXE sous LINUX depuis WINDOWS... il n'a que 1 seul choix :arrow: DELPHI et inversément :arrow: KYLIX
Maintenant s'il veut se compliquer la vie il fait du Assembleur sous Mainframe... mais là ce sera un tit peu plus compliqué pour avoir la machine qui va avec... :twisted:
ProfX
Elite
qu est ce que c est que ces conneries de dire que le quickbasic c etait depasse ??????????
je te pondd n importe quoi comme prog de gestion de base de donnee la dessus
et tu vera si c est depâsse bande de newbies pffffffffffffff
si tu veut aller vers le vb moi je ne te conseille pas le quick avant . y a plein de petite fonction tellement pratique sous quick qui n ont pas ete reprise sous vb
le swap par exemple snif
moi je m en fout je l ai recree mais bon y a surement d autre fonction qui ont ete abandonnee , mais je les ai pas en tete pour le moment
perso quand j ai besoin d un petit truc rapide sans interface ecran , je taf en quick
et si j ai besoin d une interface un peu compliquee , je prend le vb
je te pondd n importe quoi comme prog de gestion de base de donnee la dessus
et tu vera si c est depâsse bande de newbies pffffffffffffff
si tu veut aller vers le vb moi je ne te conseille pas le quick avant . y a plein de petite fonction tellement pratique sous quick qui n ont pas ete reprise sous vb
le swap par exemple snif
moi je m en fout je l ai recree mais bon y a surement d autre fonction qui ont ete abandonnee , mais je les ai pas en tete pour le moment
perso quand j ai besoin d un petit truc rapide sans interface ecran , je taf en quick
et si j ai besoin d une interface un peu compliquee , je prend le vb
titloup
Elite
GG les exemples... mais faut lui dire qu'il faut un minimum de connaissance pour n'importe quel langage :wink:
Mais n'empêche l'assembleur ROXE... j'ai même fait un jeu graphique avec ce machin... avec seulement 3000 lignes
Mais quand on voit les DEMOS de certains http://www.assembly.org
Mais n'empêche l'assembleur ROXE... j'ai même fait un jeu graphique avec ce machin... avec seulement 3000 lignes
Mais quand on voit les DEMOS de certains http://www.assembly.org
THiBOo
Elite
C++ c'est tout
Nan y en a d'autre hin mais C++ c'est tellement bien
Nan y en a d'autre hin mais C++ c'est tellement bien
THiBOo
Elite
heu clair faut un minimum de connaissance :shock: les cours restent ce qui se fait de mieux ... si tu t'en sens le courage achète un bouquin 'programmation en C++' au édition Schaum's est un très bon début ( mon premier bouquin :cry:1v0 - WOLF a dit:GG les exemples... mais faut lui dire qu'il faut un minimum de connaissance pour n'importe quel langage :wink:
Mais n'empêche l'assembleur ROXE... j'ai même fait un jeu graphique avec ce machin... avec seulement 3000 lignes
Mais quand on voit les DEMOS de certains http://www.assembly.org
) tu verras si t'y arrive ou pas pour l'assembleur pas mal le truc de 3000 lignes
et clair y en a qui font de ces truc :shock: faudra m'expliquer déjà que j'ai jamais assez avec mes 7 registre pour C++ aussi y a des exemples, regarde tout les jeux auxquel tu joue ... regarde hlguard, regarde wwcl ... du C++
j'ai matté un peu le source de wwcl et hlguard :shock: omg
captais rien
titloup
Elite
Mais c'est pas parce que tu fais du QBasic qu'on peut dire que tout le monde fait çaProfx a dit:
Ajourd'hui on n'utilise que des langages OO, et je ne pense pas que Qbasic en soit une... tout comme pour le C et le Pascal...
Chacun développe dans ce qu'il veut... mais je préfére de loin mon environnement RAD pour me faire vite mon tit programme et avoir toute l'aide et DEBUGGER dérriére... :wink:
ProfX
Elite
si il veut faire des petit truc sans pretentions avec le quick basic c est fastoche a mort
et parfaitement lisible comme language c est pratiquement de la langue parlee
en plus tu as une aide pas mal faite dedans
et parfaitement lisible comme language c est pratiquement de la langue parlee
en plus tu as une aide pas mal faite dedans
titloup
Elite
Erf... il n'y a pas 12 registres? Je pense que oui... dois aller vérifier :wink:THiBOo a dit:heu clair faut un minimum de connaissance :shock: les cours restent ce qui se fait de mieux ... si tu t'en sens le courage achète un bouquin 'programmation en C++' au édition Schaum's est un très bon début ( mon premier bouquin :cry:1v0 - WOLF a dit:GG les exemples... mais faut lui dire qu'il faut un minimum de connaissance pour n'importe quel langage :wink:
Mais n'empêche l'assembleur ROXE... j'ai même fait un jeu graphique avec ce machin... avec seulement 3000 lignes
Mais quand on voit les DEMOS de certains http://www.assembly.org
pour l'assembleur pas mal le truc de 3000 lignes
pour C++ aussi y a des exemples, regarde tout les jeux auxquel tu joue ... regarde hlguard, regarde wwcl ... du C++
j'ai matté un peu le source de wwcl et hlguard :shock: omg
captais rien
titloup
Elite
Un tit programme en assembleur qui affiche des LEDS à l'écran
Code:
.MODEL SMALL
.STACK 100h
.486
.DATA
MENU DB ' * CHOISISSEZ LA SEQUENCE 1, 2, 3 OU 0 POUR ARRETER: ','$'
NOEL DB '* MERCI ET AU REVOIR *'
POS DW ? ; VARIABLE POUR L'IMPRESSION DE "NOEL"
SAUV DW ? ; SAUVEGARDE (BX) POUR LA SEQUENCE 2
TEMPS DD 600 ; "PARAMETRE TEMPS" - VITESSE AFFICHAGE
.CODE
; ***********************************************************
; * ADRESSE DES VARIABLES DANS LE REGISTRE SEGMENT DS *
; ***********************************************************
MOV AX,@DATA ; AX <= ADRESSE DES VARIABLES DE "DATA"
MOV DS,AX ; DS <= AX
; ***********************************************************
; * NETTOYAGE DE L'ECRAN, PASSAGE A LA LIGNE SUIVANTE POUR *
; * AFFICHAGE DU MENU DES SEQUENCES ET DES LEDS ETEINTS *
; ***********************************************************
PROPRE:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV DX,378h ; DX <= 378h
MOV AL,00000000b ; AL <= 00000000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AH,0 ; AH <= 0
MOV AL,3 ; AL <= 3
INT 10h ; INTERRUPTION - NETTOYAGE DE L'ECRAN
MOV AH,0Eh ; AH <= 0Eh
MOV AL,0Ah ; AL <= 0Ah
INT 10h ; INTERRUPTION - SAUT DE LIGNE
MOV AL,0Dh ; AL <= 0Dh
INT 10h ; INTERRUPTION - RETOUR DU CHARIOT
MOV DX,OFFSET MENU ; DX <= ADRESSE DE LA VARIABLE "MENU"
MOV AX,DX ; AX <= DX
MOV AH,09h ; AH <= 09h
INT 21h ; INTERRUPTION - AFFICHAGE DE "MENU"
MOV AX,0B800h ; AX <= 0B800h
MOV ES,AX ; ES <= AX
MOV BX,2144 ; BX <= 2144
MOV ES:[BX],WORD PTR 04DBh ; AFF POSITON BX 1 LED FONCE
AFFREDF:
CMP BX,2172 ; COMPARAISON DE BX A 2172
JE CHOIX ; SI BX = 2172 ALORS BRANCHEMENT "CHOIX"
ADD BX,4 ; BX <= BX + 4
MOV ES:[BX],WORD PTR 04DBh ; AFF POSITION BX 1 LED FONCE
JMP AFFREDF ; BRANCHEMENT A "AFFREDF"
; ***********************************************************
; * TRAITEMENT DU CHOIX FAIT PAR L'UTILISATEUR *
; ***********************************************************
CHOIX:
MOV BX,2144 ; BX <= 2144
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AH,1 ; AH <= 1
INT 21h ; INTERRUPTION - CARACTERE ASCII DANS AL
DIRECT:
CMP AL,'1' ; COMPARAISON AL A '1'
JE SEQ1 ; SI AL = 1 ALORS BRANCHEMENT "SEQ1"
CMP AL,'2' ; COMPARAISON AL A '2'
JE SEQ2 ; SI AL = 2 ALORS BRANCHEMENT "SEQ2"
CMP AL,'3' ; COMPARAISON AL A '3'
JE SEQ3 ; SI AL = 3 ALORS BRANCHEMENT "SEQ3"
CMP AL,'0' ; COMPARAISON AL A '0'
JE FERMER ; SI AL = 0 ALORS BRANCHEMENT "FERMER"
JMP PROPRE ; BRANCHEMENT "DIRECT" CODE ASCII INCONNU
; ***********************************************************
; * RETOUR DE LA$BOUCLE "FREIN" ET RETOUR A LA BONNE PLACE *
; ***********************************************************
SUITE:
CMP AL,'1' ; COMPARAISON AL A '1'
JE REDVIF1 ; SI AL = 1 ALORS BRANCHEMENT "REDVIF1"
CMP AL,'2' ; COMPARAISON AL A '2'
JE REDVIF2 ; SI AL = 2 ALORS BRANCHEMENT "REDVIF2"
CMP AL,'3' ; COMPARAISON AL A '3'
JE REDVIF3 ; SI AL = 3 ALORS BRANCHEMENT "REDVIF3"
CMP AL,'W' ; COMPARAISON AL A 'W'
JE RAINBOW ; SI AL = W ALORS BRANCHEMENT "RAINBOW"
; ***********************************************************
; * DEBUT DU TRAITEMENT DE LA SEQUENCE NOEL 1 *
; ***********************************************************
SEQ1:
MOV ES:[BX],WORD PTR 0CDBh ; AFF POSITION BX 1 LED VIF
JMP CARTE ; BRANCHEMENT "CARTE"
REDVIF1:
MOV ES:[BX],WORD PTR 04DBh ; AFF POSITION BX 1 LED FONCE
CMP BX,2172 ; COMPARAISON DE BX AVEC 2172
JE PROPRE ; SI BX = 2172 BRANCHEMENT "PROPRE"
ADD BX,4 ; BX <= BX + 4
MOV ES:[BX],WORD PTR 0CDBh ; AFF POSITION BX 1 LED VIF
JMP CARTE ; BRANCHEMENT "CARTE"
; ***********************************************************
; * DEBUT DU TRAITEMENT DE LA SEQUENCE NOEL 2 *
; ***********************************************************
SEQ2:
MOV ES:[BX],WORD PTR 0CDBh ; AFF POSITION BX 1 LED VIF
MOV ES:[2172],WORD PTR 0CDBh ; AFF POSITION BX 1 LED VIF
MOV SAUV,2172 ; SAUV <= 2172
JMP CARTE ; BRANCHEMENT "CARTE"
REDVIF2:
MOV ES:[BX],WORD PTR 04DBh ; AFF POSITION BX 1 LED FONCE
PUSH BX ; LIFO <= BX
MOV BX,SAUV ; BX <= SAUV
MOV ES:[BX],WORD PTR 04DBh ; AFF POSITION BX 1 LED FONCE
POP BX ; BX <= LIFO
CMP BX,2172 ; COMPARAISON BX AVEC 2172
JE PROPRE ; SI BX = 2172 ALORS BRANCHEMENT "PROPRE"
ADD BX,4 ; BX <= BX + 4
MOV ES:[BX],WORD PTR 0CDBh ; AFF POSITION BX 1 LED VIF
PUSH BX ; LIFO <= BX
MOV BX,SAUV ; BX <= SAUV
SUB BX,4 ; BX <= BX + 4
MOV ES:[BX],WORD PTR 0CDBh ; AFF POSITION BX 1 LED VIF
MOV SAUV,BX ; SAUV <= BX
POP BX ; BX <= LIFO
JMP CARTE ; BRANCHEMENT "CARTE"
; ***********************************************************
; * DEBUT DU TRAITEMENT DE LA SEQUENCE SPECIAL NOEL 3 *
; ***********************************************************
SEQ3:
MOV ES:[BX],WORD PTR 02DBh ; AFF POSITION BX 1 LED VERT
JMP CARTE ; BRANCHEMENT "CARTE"
REDVIF3:
MOV ES:[BX],WORD PTR 01DBh ; AFF POSITION BX 1 LED BLEU
CMP BX,2172 ; COMPARAISON BX AVEC 2172
JE ARRIERE ; SI BX = 2172 ALORS BRANCHEMENT "ARRIERE"
ADD BX,4 ; BX <= BX + 4
MOV ES:[BX],WORD PTR 02DBh ; AFF POSITION BX 1 LED VERT
JMP CARTE ; BRANCHEMENT "CARTE"
ARRIERE:
MOV AL,'W' ; AL <= 'W'
MOV ES:[BX],WORD PTR 02DBh ; AFF POSITION BX 1 LED VERT
JMP CARTE ; BRANCHEMENT "CARTE"
RAINBOW:
MOV ES:[BX],WORD PTR 05DBh ; AFF POSITION BX 1 LED MAGENTA
CMP BX,2144 ; COMPARAISON BX AVEC 2144
JE PROPRE ; SI BX = 2144 ALORS BRANCHEMENT "PROPRE"
SUB BX,4 ; BX <= BX - 4
MOV ES:[BX],WORD PTR 02DBh ; AFF POSITION BX 1 LED MAGENTA
JMP CARTE ; BRANCHEMENT "CARTE"
; ***********************************************************
; * AFFICHAGE DES LEDS DE LA CARTE SUR " LPT1 " *
; ***********************************************************
CARTE:
PUSH AX ; LIFO <= AX
MOV DX,378h ; DX <= 378h
CMP BX,2144 ; COMPARAISON BX AVEC 2144
JE LED1 ; SI BX = 2144 ALORS BRANCHEMENT "LED1"
CMP BX,2148 ; COMPARAISON BX AVEC 2148
JE LED2 ; SI BX = 2148 ALORS BRANCHEMENT "LED2"
CMP BX,2152 ; COMPARAISON BX AVEC 2152
JE LED3 ; SI BX = 2152 ALORS BRANCHEMENT "LED3"
CMP BX,2156 ; COMPARAISON BX AVEC 2156
JE LED4 ; SI BX = 2156 ALORS BRANCHEMENT "LED4"
CMP BX,2160 ; COMPARAISON BX AVEC 2160
JE LED5 ; SI BX = 2160 ALORS BRANCHEMENT "LED5"
CMP BX,2164 ; COMPARAISON BX AVEC 2164
JE LED6 ; SI BX = 2164 ALORS BRANCHEMENT "LED6"
CMP BX,2168 ; COMPARAISON BX AVEC 2168
JE LED7 ; SI BX = 2168 ALORS BRANCHEMENT "LED7"
CMP BX,2172 ; COMPARAISON BX AVEC 2172
JE LED8 ; SI BX = 2172 ALORS BRANCHEMENT "LED8"
LED1:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM1 ; SI AL # '2' ALORS BRANCHEMENT NORM1
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,10000001b ; AL <= 10000001b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM1:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,10000000b ; AL <= 10000000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
LED2:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM2 ; SI AL # '2' ALORS BRANCHEMENT NORM2
SUB AX,AX ; AX <= AX - 1 (= 0)
MOV AL,01000010b ; AL <= 01000010b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM2:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,01000000b ; AL <= 01000000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
LED3:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM3 ; SI AL # '2' ALORS BRANCHEMENT NORM3
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00100100b ; AL <= 00100100b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM3:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00100000b ; AL <= 00100000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
LED4:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM4 ; SI AL # '2' ALORS BRANCHEMENT NORM4
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00011000b ; AL <= 00011000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM4:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00010000b ; AL <= 00010000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
LED5:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM5 ; SI AL # '2' ALORS BRANCHEMENT NORM5
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00011000b ; AL <= 00011000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM5:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00001000b ; AL <= 00001000b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
LED6:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM6 ; SI AL # '2' ALORS BRANCHEMENT NORM6
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00100100b ; AL <= 00100100b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM6:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00000100b ; AL <= 00000100b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
LED7:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM7 ; SI AL # '2' ALORS BRANCHEMENT NORM7
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,01000010b ; AL <= 01000010b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM7:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00000010b ; AL <= 00000010b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
LED8:
CMP AL,'2' ; COMPARAISON AL AVEC '2'
JNE NORM8 ; SI AL # '2' ALORS BRANCHEMENT NORM1
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,10000001b ; AL <= 10000001b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
NORM8:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,00000001b ; AL <= 00000001b
OUT DX,AL ; AFFICHAGE SUR LA CARTE DE AL
JMP FREIN ; BRANCHEMENT A "FREIN"
; ***********************************************************
; * BOUCLE POUR LA TEMPORISATION *
; ***********************************************************
FREIN:
SUB DX,DX ; DX <= DX - DX (= 0)
SUB AX,AX ; AX <= AX - AX (= 0)
POP AX ; AX <= LIFO
LENT:
MOV ECX,TEMPS ; ECX <= TEMPS
BOUCLE:
LOOP BOUCLE ; TANT QUE ECX > 0 ALORS ECX <= ECX - 1
INC DX ; DX <= DX + 1
CMP DX,11000 ; COMPARAISON DX AVEC 11000
JNE LENT ; SI DX # 11000 ALORS BRANCHEMENT "LENT"
SUB DX,DX ; DX <= DX - DX (= 0)
JMP SUITE ; BRANCHEMENT "SUITE"
; ***********************************************************
; * ARRET ET FERMETURE DU PROGRAMME *
; ***********************************************************
FERMER:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AH,0 ; AH <= 0
MOV AL,3 ; AL <= 3
INT 10h ; INTERRUPTION - NETTOYAGE DE L'ECRAN
MOV AH,0Eh ; AH <= 0Eh
MOV AL,0Dh ; AL <= 0Dh
INT 10h ; INTERRUPTION - RETOUR DU CHARIOT
MOV AL,0Ah ; AL <= 0Ah
SUB CX,CX ; CX <= CX -CX (= 0)
INTER:
INT 10h ; INTERRUPTION - SAUT DE LIGNE
INC CX ; CX <= CX + 1
CMP CX,28 ; COMPARAISON CX AVEC 28
JNE INTER ; SI CX # 28 ALORS BRANCHEMENT "INTER"
SUB BX,BX ; BX <= BX - BX (= 0)
MOV POS,1494 ; POS <= 1494
COLOR:
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AL,NOEL[BX] ; AL <= CODE ASCII DE NOEL[BX]
ADD AX,500h ; AX <= AX + 500h (= COULEUR MAGENTA)
PUSH BX ; LIFO <= BX
MOV BX,POS ; BX <= POS
MOV ES:[BX],WORD PTR AX ; AFF POSITION BX CODE DANS AX
ADD BX,2 ; BX <= BX + 2
MOV POS,BX ; POS <= BX
POP BX ; BX <= LIFO
ADD BX,1 ; BX <= BX + 1
CMP BX,22 ; COMPARAISON BX AVEC 22
JB COLOR ; SI BX < 22 BRANCHEMENT "COLOR"
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AH,1 ; AH <= 1
INT 21h ; INTERRUPTION - CARACTERE ASCII DANS AL
IN AL,60h ; LIT LE PORT 60h
CMP AL,1 ; COMPARAISON DE AL AVEC 1
JE PROPRE ; SI AL = 1 ALORS BRANCHEMENT "PROPRE"
SUB AX,AX ; AX <= AX - AX (= 0)
MOV AH,0 ; AH <= 0
MOV AL,3 ; AL <= 3
INT 10h ; INTERRUPTION - NETTOYAGE DE L'ECRAN
MOV AX,4C00h ; PREPARATION DE L'ARRET DU PGM
INT 21h ; INTERRUPTION 21h -> ARRET DU PGM
END ; FERMETURETHiBOo
Elite
EAX
EBX
ECX
EDX
ESI
EDI
EBP
J'en vois pas d'autre les autres sont surtout ESP ( stack pointer et des registre de segment ... mais ceux là je sais pas trop à quoi ils servent
EBX
ECX
EDX
ESI
EDI
EBP
J'en vois pas d'autre
les autres sont surtout ESP ( stack pointer et des registre de segment ... mais ceux là je sais pas trop à quoi ils servent
titloup
Elite
Je ne sais plus... mais je me demande si AX est la moitié de EAX ou si c'est un autre à part... enfin soit... je me suis bien amusé avec ce truc...THiBOo a dit:EAX
EBX
ECX
EDX
ESI
EDI
EBP
J'en vois pas d'autre
THiBOo
Elite
Ca c'est du beau prog wolf mais si on commence à sortir nos compostions on va pas en sortir
un joli démineur codé en 3D mais affiché en 2 ( suffit de supperposer mentalement les 3 tableaux )
mais si on commence à sortir nos compostions on va pas en sortir
Code:
// Programme fait par Vandevoorde Thibault groupe informatique : 3
# include <iostream.h>
# include <stdlib.h>
# include <time.h>
const int taille = 152;
typedef int matrice3D [3] [taille] [taille];
void bombe ( matrice3D, int, int, int );
void matrice_solution ( matrice3D, int, int, int );
void placement ( matrice3D, int, int );
void zero ( matrice3D, int, int );
void affiche ( matrice3D, matrice3D, int, int );
void rien ( matrice3D, int, int );
// note : l = navigateur du vecteur, h = navigateur de ligne, k = navigateur de colonne
// j'ai créé une matrice de 2 cases plus grande que celle demandée par l'utilisateur,
// cela permet d'incrémenter tout autour des bombes de manière aisée. Et aussi de ne pas
// devoir a chaque fois décrémenter de 1 la valeur entrée par l'utilisateur ( sauf pour le
// vecteur )
int main ( )
{
char rep; // déclaration d'une variable de type charactère
int nbr , longueur, largeur, l2, h2, k2, cpt=0, cptX=0, q;
bool die = false, test = false;
matrice3D M3D, M3D2; // création de 2 matrice3D
cout << " !!!! Bienvenue dans le fabuleux DEMINEUR 3D tm !!!! " << endl << endl;
cout << "Entrez le nombre de bombes souhaitees : " << endl << endl;
cin >> nbr;
cout << "Entrez le nombre de lignes souhaitees (max 150): " << endl << endl;
cin >> longueur;
cout << "Entrez le nombre de colonnes souhaitees (conseil : max 19) : " << endl << endl;
// si on entre une valeur supérieur à 19, la matrice sera affiché sur plusieurs ligne -> illisible
cin >> largeur;
cout << endl << endl;
zero ( M3D, longueur, largeur ); // initialisation de ma matrice solution à 0
matrice_solution ( M3D, longueur, largeur, nbr ); // crée les valeurs de ma matrice solution
rien ( M3D2, longueur, largeur ); // initialise ma matrice de jeu à inconnue partout ( 555 )
affiche ( M3D, M3D2, longueur, largeur ); // affiche la matrice jeu
while ( die == false && test == false ) // dès qu'une case retournée est une bombe ou que
// le nombre de drapeaux égale le nbr de bombe et
// sont correctement placés
{
cout << "Entrez le numero de la grille : " << endl;
cin >> l2;
l2 = l2-1; //permet d'entrer des valeurs comme 1, 2 ou 3 car vecteur est de 0 à 2
cout << "Entrez le numero de la ligne : " << endl;
cin >> h2;
cout << "Entrez le numero de la colonne : " << endl;
cin >> k2;
cout << "Cette case est-elle une bombe ? ( y/n )" << endl;
cin >> rep;
if ( rep == 'y' ) // si c'est une bombe on initialise la case a drapeau ( 444 )
{
M3D2 [l2] [h2] [k2] = 444;
cptX ++; // et on incrémente le compteur drapeau de 1
}
else if ( M3D [l2] [h2] [k2] == 666 ) // si la case retournée est une bombe
{
M3D2 [l2] [h2] [k2] = 777; // init a 777 ( = erreur )
die = true; // et die passe à true
}
else
M3D2 [l2] [h2] [k2] = M3D [l2] [h2] [k2]; // sinon la case retournée prend
// la valeur de la case de la matrice solution
if ( cptX >= nbr ) // test permettant de voir si les drapeaux ont été correctement
// placé, et ce test ne commencera qu'après un certain nombre de
{ // de drapeaux placés
for ( int l1=0; l1 < 3; l1++ )
{
for ( int h1=1; h1 < longueur+1; h1++ )
{
for ( int k1=1; k1 < largeur+1; k1++ )
{
if ( M3D [l1] [h1] [k1] == 666 ) // si une case de la matrice solution est une
{ // bombe
if ( M3D2 [l1] [h1] [k1] == 444 ) // et si la case de la matrice jeu est un
cpt++; // drapeau, on augmente le compteur de 1.
}
}
}
}
}
if ( cpt == nbr ) // si le nbr de drapeau = le nbr de bombe
test = true; // test passe à true et c'est gagné
affiche ( M3D, M3D2, longueur, largeur ); // et on affiche a chaque tour la matrice
} // jeu modifié
if ( die == true ) // si la boucle s'est arreté car die est passé à true
{
cout << "Dommage, essayez encore une fois..." << endl; // message d'encouragement
affiche ( M3D, M3D, longueur, largeur ); // affichage de la solution
}
else if ( test == true ) // si la boucle s'est arreté car test est passé à true
cout<<"BRAVO, vous avez GAGNE !!! reessayez avec plus de bombes... ;-)"<< endl;
cout << "Appuyer sur une touche pour quitter :" << endl;
cin >> q;
return 0;
}
void matrice_solution ( matrice3D M3D, int longueur, int largeur, int nbr )
{
bombe ( M3D, nbr, longueur, largeur ); // appel de la fonction bombe
placement ( M3D, longueur, largeur ); // appel de la fonction placement
}
void zero ( matrice3D M3D, int longueur, int largeur )
// initialise toute la matrice à zéro
{
for ( int h=0; h <= (longueur+2); h++ )
{
for ( int k=0; k <= (largeur+2); k++ )
{
M3D [0] [h] [k] = 0;
M3D [1] [h] [k] = 0;
M3D [2] [h] [k] = 0;
}
}
}
void bombe ( matrice3D M3D, int nbr, int longueur, int largeur )
// fonction random
{
unsigned seed = time(NULL);
srand(seed);
for ( int cpt=0; cpt < nbr; ) // le compteur ne peut pas etre supérieur au nbr de bombe
{
int l, h, k;
l = rand()%3; // l = navigateur de vecteur ( de 0 à 2 )
h = 1+rand()%longueur; // h = navigateur de lignes ( de 1 à longueur )
k = 1+rand()%largeur; // k = navigateur de colonnes ( de 1 à largeur )
if ( M3D [l] [h] [k] != 666 ) // si la case n'est pas encore une bombe
{
M3D [l] [h] [k] = 666; // cette case devient une bombe
cpt++; // et on augmente compteur de 1
}
}
}
void placement ( matrice3D M3D, int longueur, int largeur )
// incrémentation des cases autour des bombes
{
for ( int l=0; l < 3; l++ )
{
if ( l == 0 ) // si on est dans la première grille
{
for ( int h=1; h < (longueur+1); h++ )
{
for ( int k=1; k < (largeur+1); k++ )
{
if ( M3D [0] [h] [k] == 666 )
{
for ( int l1 = l; l1 < (l+2); l1++ )
{
for ( int h1 = (h-1); h1 < (h+2); h1++ )
{
for ( int k1 = (k-1); k1 < (k+2); k1++ )
// incrémentation tout autour de la bombe et dans la grille suivante aussi
{
if ( M3D [l1] [h1] [k1] != 666 )
M3D [l1] [h1] [k1] +=1;
}
}
}
}
}
}
}
else if ( l == 1 ) // si on est dans la 2eme grille
{
for ( int h=1; h < (longueur+1); h++ )
{
for ( int k=1; k < (largeur+1); k++ )
{
if ( M3D [1] [h] [k] == 666 )
{
for ( int l1 = (l-1); l1 < (l+2); l1++ )
{
for ( int h1 = (h-1); h1 < (h+2); h1++ )
{
for ( int k1 = (k-1); k1 < (k+2); k1++ )
// incrémentation tout autour de la bombe et dans la grille suivante et précédante
{
if ( M3D [l1] [h1] [k1] != 666 )
M3D [l1] [h1] [k1] += 1;
}
}
}
}
}
}
}
else if ( l == 2 ) // si on est dans la 3eme grille
{
for ( int h=1; h < (longueur+1); h++ )
{
for ( int k=1; k < (largeur+1); k++ )
{
if ( M3D [2] [h] [k] == 666 )
{
for ( int l1 = ( l-1 ); l1 < (l+1); l1++ )
{
for ( int h1 = (h-1); h1 < (h+2); h1++ )
{
for ( int k1 = (k-1); k1 < (k+2); k1++ )
// incrémentation tout autour de la bombe et dans la grille précédante
{
if ( M3D [l1] [h1] [k1] != 666 )
M3D [l1] [h1] [k1] += 1;
}
}
}
}
}
}
}
}
}
void affiche ( matrice3D M3D, matrice3D M3D2, int longueur, int largeur )
// permet d'afficher la matrice et aussi de faire de jolies petites cases autour ...
{
int cpt;
for ( int l=0; l < 3; l++ ) // permet d'afficher la matrice de manière lisible
{
cout << l+1 << "." << endl << endl;
for ( cpt = 1; cpt < (largeur+1); cpt++ )
if ( cpt <= 9 )
cout << " " << cpt << " ";
else if ( cpt <= 99 )
cout << " " << cpt << " ";
cout << endl;
for ( cpt = 1; cpt < (largeur+1); cpt++ )
cout << "----";
cout << endl;
for ( int h=1; h < (longueur+1); h++ )
{
for ( int k=1; k < (largeur+1); k++ )
{
if ( M3D2 [l] [h] [k] == 444 ) // 444 = drapeau
cout << " " << "x" << " ";
else if ( M3D2 [l] [h] [k] == 555 ) // 555 = inconnue
cout << " " << "?" << " ";
else if ( M3D2 [l] [h] [k] == 666 ) // 666 = BOMBE
cout << " " << "B" << " ";
else if ( M3D2 [l] [h] [k] == 777 ) // 777 = erreur
cout << " " << "!" << " ";
else if ( M3D2 [l] [h] [k] <= 9 )
cout << " " << M3D2 [l] [h] [k] << " ";
else
cout << " " << M3D2 [l] [h] [k];
cout << "|";
}
cout << " " << h;
cout << endl;
for ( k=1; k < (largeur+1); k++ )
cout << "----";
cout << endl;
}
cout << endl;
}
}
void rien ( matrice3D M3D2, int longueur, int largeur )
// initialise une matrice à la valeur 555 = inconnue = ?
{
for ( int h=0; h <= (longueur+2); h++ )
{
for ( int k=0; k <= (largeur+2); k++ )
{
M3D2 [0] [h] [k] = 555;
M3D2 [1] [h] [k] = 555;
M3D2 [2] [h] [k] = 555;
}
}
}THiBOo
Elite
AX c'est sur 16 bits1v0 - WOLF a dit:Je ne sais plus... mais je me demande si AX est la moitié de EAX ou si c'est un autre à part... enfin soit... je me suis bien amusé avec ce truc...THiBOo a dit:EAX
EBX
ECX
EDX
ESI
EDI
EBP
J'en vois pas d'autre
EAX sur 32
AX est composé de AH ( partie haute, les 8 premiers bit ) et AL ( partie basse, les 8 derniers bits ), ça permet de travailler en 8 bits si il le faut
titloup
Elite
Ben EAX c'est à part alors... car il n'y a pas de partie haut dans EAX... lol j'en sais plus rien
Vais aller faire dodo
Vais aller faire dodo
RBC9
Elite
tiens juste pour rire , et puisqu on joue au malin avec Linux ,1v0 - WOLF a dit:
Ton Delphi , tu programmes pour MaC aussi , tant qu on est a faire le con ...
Juste pour savoir , car entre les théories vaseuses et la réalité , y a une marge .. par exmple , certains corps de metier sont a 90 % en Mac , et ne sont pas pret d en changer ...
alors tant qu a dire celui la est mieux pour faire joujou et frimer sur Linul ..
Now , pour je sais plus lequel qui viens lacher "moi j aime pas crosoft je prefere le C++ le trucmuche .. "
dis mon gars , le c++ Crosoft , et celui de Borland , tu y vois Bcp de diff toi ?
moi pas . c est le meme language ... une interface et quelques library les separent .
[/quote]
Ajourd'hui on n'utilise que des langages OO, et je ne pense pas que Qbasic en soit une... tout comme pour le C et le Pascal...
[/quote]
celle là c est le comble .. alors la ... cette info , tu la tiens de ton prof d info , un gars ayant du se recycler dans l enseignement face a son incapacite de se mettre sur le marché ?
tu seras mort et moi complement pourri , le jour ou les applis de par le monde ecrite dans ces languages OO depasseront les appli existante et tournant a ce jour en vieux "Brol" comme certain disent.
Des grosses boites en Cobol , ASM370 , voir Fortran , y en a plus que tu ne crois.
DEs appli en Cliiper (Dbase compilé) , y en a des miliers.
Alors oui , les nouvelles appli sont crées avec les languages actuels , mais ,c est pas demain qu on aura plus ces vieux languages.
Pour finir , venir lacher VB c est de la merde , alors que la question est comment faire facilement et rapidement un exe ...
l'interface VB est simple et accessible , le language est facile , il inculque les regles de bases de la programmation sans en imposer les rigueurs et complexités que l on rencontre souvent en c++
le Vb est également tout aussi "Puissant" qu le C++ quand a ce que l on peut gerer , creer etc
par bien des coté il "ressemble" au C, le seul point noir qu on puisse lui reprocher etant sa "lenteur" ...
PS : Linul , rien a battre , le jour ou j aurai rien a foutre de mes journées , peut être envisagerai de perdre mon temps avec ça ..
mais a ce jour , j ai un OS , Windows , qui fonctionne correctement , qui ne plante pas pluys ni moins qu un Linul, mais qui a l avantage d être plus rependu , ou tout au moins de beneficier d un parc info bcp plus grand.
Cet Os , me permet de faire toute les taches nécessaires , cet OS correpond au besoin bureautique de la plupart des sociétés , je te parle pas de serveur , mais de poste de travail
, ou cet os me permet de faire des tas de choses qu avc Linul je ne opeut meme pas envisager , car inexistant.
Demain , ou après demain , peut être ...
mais aujourd hui , faut arreter de venir nous faire chier avec ce truc , sans avoir d autres argumentation que :
"Moi je Own , j ai Linul .............. Windaube Sux"
spawny
Elite
Moi je Own , j ai Linul .............. Windaube Sux
- Statut
