voila ça vient de la ngck mais je comprends pas pourquoi mon code marche

1. include "../Ngck_moteur/Ngck.h"

int x;
int y;
int moveH;
//déplacement horizontal
int moveV;
//déplacement vertical
void InitialiseGame()
{
x=0;
y=0;
moveH=1;
moveV=1;
}
//
--------------------------------------------------
---------
void GameLoop()
{

x=x+moveH;
y=y+moveV;
if(moveV==20)
moveV=-moveV;
if(moveV==0)
moveV=-moveV;
if(moveH==0)
moveH=-moveH;
if(moveH=30)
moveH=-moveH;
KPrintSquare(x,y);

en fait le carré devrait bouger dans tout les sens et rebondir quand il touche un bord
sauf que la ça fait apparaitre un carré une fraction de seconde c´est quoi le problème?

ne me donnez pas la réponse ça je peux l´avoir facile mais disez moi l´erreur svp pour que je trouve un autre moyen de coder

ps:je vous remercierais(clin d´oeil a lapintade)lol

personne ne peut me répondre?

ah non laissez tomber j´ai trouver

Ok je repond pas.
juste une suggestion x=x+moveH tu peux le remplacer par x += moveH, c´est plus rapide puisque tu n´a pas a creer de variable temporaire pour stocker le resultat.

"personne ne peut me répondre?"

Les ups sont interdits. Tu post et tu attends une reponse. C´est assez impoli de s´impatienter.

TomtomClancy > Pour les debutants, je trouve que c´est mieux d´utiliser la forme "normale". Ca leur permets de bien comprendre l´algorithmique. Je suis donc pas trop pour leur conseiller d´utiliser directement des notation abregée de C++.

de plus cette notation n´est pas plus rapide.
Il suffit de faire un peu d´assembleur pour s´en convaincre.

"de plus cette notation n´est pas plus rapide"

Il est possible que les compilo optimise maintenant ces syntaxe.
Mais c´est bien plus rapide, que la premiere notation, suffi de faire un peu de 3D pour s´en convaincre.

en C++ l´operateur + creer une variable temporaire qu´il renvoie puis l´oprateur egale qui recopie la valeur dans la variable de gauche.
Ce qui te fais donc 2 operations, contrairement a += qui n´en fait qu´une sans creer de variable temporaire.

Donc plus rapide d´execution.

pas sur les types primaires voyons!

Ca change pas, types primaires ou non. Je vois pas pourquoi tu veux continuer la dessus.
Tu pense donc que les operateur +=, ++; /=, *=
sont juste la pour faire plus court dans l´ecriture
Fais une petite recherche sur ces operateurs. tu verra toi meme

C´est pas trop la question ici.

sur les types primaire ils ne font absolument rien de plus en C.
En C++ le probleme est plus compliqué sur les objets, mais c´est exactement la même chose sur les types
primaires, et je le prouve:
mandan:~/test> cat test.cpp
void toto(int c, int b)
{
b = b + c;
}
mandan:~/test> cat test.s
.file "test.cpp"
.text
.align 2
.globl _Z4totoii
.type _Z4totoii, @function
_Z4totoii:
.LFB2:
pushl %ebp
.LCFI0:
movl %esp, %ebp
.LCFI1:
movl 8(%ebp), %edx
leal 12(%ebp), %eax
addl %edx, (%eax)
popl %ebp
ret
.LFE2:
.size _Z4totoii, .-_Z4totoii
.ident "GCC: (GNU) 4.0.2 20050808 (prerelease) (Ubuntu 4.0.1-4ubuntu9)" .section .note.GNU-stack,"",@progbits
mandan:~/test> cat test2.cpp
void toto(int c, int b)
{
b = b + c;
}
mandan:~/test> cat test2.s
.file "test2.cpp"
.text
.align 2
.globl _Z4totoii
.type _Z4totoii, @function
_Z4totoii:
.LFB2:
pushl %ebp
.LCFI0:
movl %esp, %ebp
.LCFI1:
movl 8(%ebp), %edx
leal 12(%ebp), %eax
addl %edx, (%eax)
popl %ebp
ret
.LFE2:
.size _Z4totoii, .-_Z4totoii
.ident "GCC: (GNU) 4.0.2 20050808 (prerelease) (Ubuntu 4.0.1-4ubuntu9)" .section .note.GNU-stack,"",@progbits

Pour info, tu confond l´interpretation syntaxique du langage et le code généré! En effet syntaxiquement b+c est une expression évaluable. mais b+=c est evaluable egalement, la preuve: c = (b += c);

Petite precision la dessus.
Effectivement, *en pratique*, sur les types primaires tu veras pas la differences.
Par contre, x+=5 et x=x+5 ne sont pas pareil. Si la plupart sinon la totalite des compilos vont optimiser la chose, en theorie x+=5 EST plus rapide, si plus rapide il doit y avoir.
En asm 68k:
; x=x+5
move.l x,d0
add.l #5,d0
move.l d0,x ; d0 sera utiliser si l´evaluation est utilise

; x+=5
add.l #5,x ; move.l x,d0 sera utilise si evaluation

D´ailleurs x+=5 fonctionne lorsque x est une addresse en lecture seule :P

Mais bon, c´est chipoter la.. Mais il est vrai qu´il est bien de prendre l´habitude de faire x+= pour savoir ce qui se passe en dessous, et surtout pour pas ralentir un prog c++

/kufa

kufa : +1

et l
ordre d´evaluation implique des copies temporaires. Vive les optims du compilo, mais il faut prendre des bonnes habitudes.