Voilà, sous MSDOS c´est soulant de voir les textes s´afficher linéairement et ça gâche le programme, il n´y aurait-il pas une fonction qui permette d´effacer l´écran a un mment voulu pour y laisser place à un nouveau texte ? ????

Tu veux dire pour affciher tes question toujours au même endroit ?

bah si.

j´ai souvenir de cette fonction, mais il ne semble qu´elle ne fonction pas sur tout les compilateur:

< conio.h>
ClrScr();

Marche pas avec dev-cpp !

Tiré de la MSDN, j´vais continuer à chercher, mais j´ai déjà trouvé un truc sous la W32 API:

BOOL FillConsoleOutputCharacter(
HANDLE hConsoleOutput, // handle to screen buffer
TCHAR cCharacter, // character
DWORD nLength, // number of cells
COORD dwWriteCoord, // first coordinates
LPDWORD lpNumberOfCharsWritten // number of cells written
) ;

Graçe à ça, t´as juste à remplir le buffer de la console de caractères NULL ( \0), pour le nombre de charactères de la console. Pour trouver ce nombre, tu appelle:
BOOL GetConsoleScreenBufferInfo(
HANDLE hConsoleOutput, // handle to screen buffer
PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo // screen buffer information
) ;
Le CONSOLE_SCREEN_BUFFER_INFO résultant possédant le champ suivant:
COORD dwSize;

Qui représente une structure avec deux champs, X et Y. Ces deux champs représentent respectivement la taille des colonnes et rangées de la console, tu n´a qu´a multiplier les deux pour trouver le nombre de caractères.

Bien, alors de la, tu remplis l´output buffer de ces caractères. Mais ça ne suffit pas. Il faut aussi ramener le curseur au départ...

BOOL SetConsoleCursorPosition(
HANDLE hConsoleOutput, // handle to screen buffer
COORD dwCursorPosition // new cursor coordinates
) ;

Le deuxième paramètre représente les coordonées du futur curseur, dans la console. Tu n´a qu´a employer une structure COORD avec les champs X et Y à 0, et le tour est joué!

Bon, alors, de toutes ces infos, fait en une bête fonction... genre BOOL ClearConsoleScreen(void)...

Oh, et en passant, toutes ces fonctions demandent le Handle du Output de ta console:
pour le trouver, utilise

HANDLE GetStdHandle(
DWORD nStdHandle // input, output, or error device
) ;

comme ça: HANDLE HCOutput = GetStdHandle(STD_OUTPUT_HANDLE);

Voilou, c´est à peu près ça, la manière que j´ai trouvé! Autant dire que je n,ai pas testé, et que il faudrait mieux que quelqu´un trouve autre chose de plus simple, mais en dernier recours, ça peut aller...

Kelios
---------

, ça à l´air compliqué ton truc Kelios !

Heu, ouais, c´est pas la simplicité extrême on dirait
Il risuqe d´avoir du mal à mettre ça en place, s´il il bidouille les structures de contrôle!

Kelios
---------

Ma technique marche, j,ai essayé.
Voici le source:

//////////////////////////////////////////////////
//////
// Main.h: Header de main.cpp

//Includes

1. include < stdio.h>
2. include < windows.h>

//Déclarations

HANDLE HOutput;

//////////////////////////////////////////////////
//////
// Main.cpp : Coeur de PClearScreen

//Préparations

1. include " main.h"

//Déclarations
int main(void);
bool ClearScreen(HANDLE Out);

//Fonctions

//************************************************

• • ***

// INT MAIN(VOID)
int main(void)
{
HOutput = GetStdHandle(STD_OUTPUT_HANDLE);

//Messages divers
printf("Hello a tous!\n");
Sleep(1000);
printf("Ce message va s´effacer\n");
Sleep(1000);

//Nettoyage de l´écran
if(!ClearScreen(HOutput))
MessageBox(NULL, " Erreur fatale! Tentative d´affichage ratée...", " Erreur", MB_OK | MB_ICONERROR);

//On termine
Sleep(1000);
printf("Merci, c´est tout!\n");
Sleep(1000);

//On quitte
return 0;
}

//************************************************

• • ***

// BOOL CLEARSCREEN(HANDLE Out)
bool ClearScreen(HANDLE Out)
{
COORD FirstChar = {0,0};
CONSOLE_SCREEN_BUFFER_INFO Info;
unsigned int Size=0;
unsigned int Written=0;

//Obtiens les informaions nécessaires à propos de la console
if(!GetConsoleScreenBufferInfo(Out,&))
return false;

//À partir de ces informations, trouve le taille de l´écran
if(Info.dwSize.X > = 0 && Info.dwSize.Y > = 0)
Size = ( int) Info.dwSize.X*Info.dwSize.Y;
else return false;

//Remplit l´écran de ´\0´
if(!FillConsoleOutputCharacter(Out, ´\0´, Size, FirstChar,(LPDWORD) &) || Written ! = Size)
return false;

//Replace le curseur au début
if(!SetConsoleCursorPosition(Out,FirstChar))
return false;

//Tout c´est bien passé?
return true;
}

À compiler pour les indécis. ; P

Kelios
---------

Kelios tu peux m´accepter s´il te plait dans tes contacts

Huh? Attend que je me connecte...

Kelios
---------

Bonjour,

Ce dont je me souviens de mes cours de C++, il n´y a pas moyen en mode DOS d´effacer l´écran directement ( Enfin, mon prof m´a dit qu´il y avait pas moyen...).

Il nous avait donné deux solutions:
- Celle d´arnaud81 ( avec le clrscr mais c´est un appel système qu´il faut faire et c´est propre à Windows).
- faire plein de cout < < endl; pour effacer l´écran.

HuHu Kelios, tu es bien gentil mais bon, ce serait cool de pas aussi brûler des étapes, j´en suis qu´à msndos pour l´instant et non en mode graphique, par contre, si j´ai trouver une fonction qui " éfface" l´écran => il faut utiliser la lib" #include < stdlib.h>" et la fonction system("cls"); !

A Kelios : #include < windows.h>, c´est bien beau, mais si je veux faire un programme sous MS-DOS ? ??

Attention, system("cls"); n´est pas une fonction ! !! C´est la fonction " system" appelée avec le paramètre " cls" qui va executer la commande système " cls", comme si tu tappais " cls" à l´invite MS-DOS.

Certes, c´est une solution qui a l´énorme avantage d´être simple, rapide à mettre en place, et qui fait proprement ce qu´on lui demande, mais :
- C´est dépendant de l´OS : sous nux, " cls" t´envoie balader, la commande système à utiliser étant " clear", il faudrait faire system("clear")
- La librairie à inclure est peut-être énorme
- Ce n´est pas forcément le plus efficace : un appel système est souvent très couteux en temps de traitement ( à ne pas confondre avec la longueur du code, je parle ici de temps à l´execution).

Comme il n´y a pas d´autre solution ( le prof de Diwi a dit vrai), un petit coup de system("cls") si tu tournes sous dos/windows à coup sûr, sans oublier de laisser un commentaire " CECI NE MARCHE QUE SOUS WINDOWS" facile à retrouver le jour où tu porteras ton programme sur une autre plateforme.

Merci de ces petites précisions

-> Nesca

" A Kelios : #include < windows.h>, c´est bien beau, mais si je veux faire un programme sous MS-DOS ? ? ? "
Eh bien tu ne peut pas! J´ai pourtant bien spécifié que c´était du WIN32 API... WIN32, c´est pas DOS16, c´est WIN32... Évidemment, il était évident que ça ne serait pas portable...
Bon, oui, il a spécifié MS-DOS au début, mais j´ai compris qu´il parlais d´une console DOS sous Windows et je le crois toujours.

" laisser un commentaire " CECI NE MARCHE QUE SOUS WINDOWS" facile à retrouver le jour où tu porteras ton programme sur une autre plateforme."
Bon, sécurisons un peu mon code alors...

//////////////////////////////////////////////////
//////
// Main.h: Header de main.cpp

1. ifndef _MAIN_H
2. define _MAIN_H

1. ifndef WIN32
2. error Désolé, ce programme ne fonctione que sous un environment Windows 32 bits.
3. else //WIN32

//Includes

1. include < stdio.h>
2. include < windows.h>

//Déclarations

HANDLE HOutput;

1. endif//WIN32
2. endif//_MAIN_H

Ça va mieux?

Kelios
---------

Programme sous MSDOS, soit tu utilises iostream ou stdio et tu ne peux pas effacer la page.

Soit tu utilises Conio comme disait Arnaud et la tu peux.

Ca serait pas plus simple ça :
system("cls");
?

Je suis en train de rire, car tu as parfaitement raison : c´est en effet la solution la plus simple que tu as proposé
et je me dis qu´on a bien cherché compliqué

bah au cas où,

< < " éfface" l´écran => il faut utiliser la lib" #include < stdlib.h>" et la fonction system("cls"); !

hUhU vous lisez trop vite :p