Débuter sur PC - Page 4

Ah bah non, tant qu'à faire il faut supposer bourrinement que le terminal fait 80x25, on va pas s'embêter avec des cas particuliers

Euh sinon en fait j'ai compris, tu penses à une imprimante à jet d'encre ? je pensais à une imprimante laser moi... qui construit une image de la page en RAM et n'imprime effectivement que quand tu lui dis que la page est terminée

Je ne trouve pas de focntions, toutes celles qui sont dans conio bug ou ne focntionne pas et aucune ne fait ce que je veux.

Voilà ce que je recherche:

Lorsque j'affiche un texte avec printf ou cout, le pointeur de texte ce met après ce que j'ai affiché, or mois je voudrais revenir en arrière et afficher par dessus.

Tu envoies des backspaces (\b, ASCII 8).
Si tu veux revenir tout au début de la ligne, utilise carriage return (\r, ASCII 13).

Sally> je pensais même à une bonne vieille imprimante à aiguille (faut se remettre dans le contexte )
Et heureusement que stdio ne suppose pas que le terminal est en 80x25, sinon les progs ANSI seraient peu portables sur TI (oui, je sais, c'est déjà le cas à cause de la RAM )

Pollux: Ben parfois c'est pratique pour debugguer.

Oui, alors tu peux utiliser ncurses & co (un truc pas portable, quoi). Si on commence à mettre des trucs moyennement portables dans le standard, ça incite à les utiliser même quand il n'y en a pas vraiment besoin...

geogeo
: Je ne trouve pas de focntions, toutes celles qui sont dans conio bug ou ne focntionne pas et aucune ne fait ce que je veux.

Tu utilises quoi comme compilateur? MinGW? Si c'est le cas, essaye ce conio-là: http://cvs.sourceforge.net/viewcvs.py/dev-cpp/V5/source/conio/.

Sinon, il y a une alternative: pdcurses (une implémentation de curses pour entre autres Windows et DOS). http://pdcurses.sourceforge.net/. C'est plus portable que conio, même s'il existe une implémentation de conio qui utilise les curses (linux-conio (http://www.funet.fi/pub/Linux/lib/), que tu devrais d'ailleurs pouvoir utiliser avec pdcurses et MinGW dans le pire des cas).

Pollux
: Oui, alors tu peux utiliser ncurses & co (un truc pas portable, quoi). Si on commence à mettre des trucs moyennement portables dans le standard, ça incite à les utiliser même quand il n'y en a pas vraiment besoin...

Au contraire, curses (ncurses, pdcurses etc.) est très portable. Au moins autant que conio.h (qui était DOS-only au départ).

OK j'utilise DevC++ mais je ne pense pas utiliser les fonctionnalitées de MinGW. Merci pour les liens je vais regarder ça.

geogeo
: OK j'utilise DevC++ mais je ne pense pas utiliser les fonctionnalitées de MinGW.

Euh si, Dev-C++, c'est MinGW, avec une IDE en plus.

Ceci dit, si tu ne veux rien faire de plus compliqué que revenir en arrière sur la même ligne, \b et \r marchent et y a pas plus portable (c'est dans le standard ASCII)

Ça marche si on a un terminal ANSI. Les terminaux Windows sont "stupides" par défaut, parce que l'implémentation des codes ANSI de M$ a des trous de sécurité dans tous les sens. Bref, je ne suis pas sûr que \r fasse ce qu'il est censé faire.

\r marche parfaitement sous Windows

Kevin > le standard ANSI c'est pour les séquences d'échappement, mais là c'est des caractères de contrôle, c'est différent je pense (et beaucoup plus portable).

ok donc \r c'est plus simple.
Mais j'ai jamais une doc mentionner ça sur celle que j'ai bref.

clrscr() n est en effet pas une fonction appartenant au C ANSI standart, bien qu elle soit presente dans certain header, en particulier dans conio.h ( pour Borland -DOS- ) par contre il existe des sequences d echappement permettant d effacer l ecran:

#define my_clrscr() printf("\033[H\033[J") // ( ou quelque chose d approchant )

pour ceux etant sous linux, il existe un header ncruses.h qui doit aussi contenir clrscr()
pour d autre sequence d echappement ( gotoxy, couleur,... ) : http://www.april.org/groupes/doc/termi/termi.txt

mobi38

Ok merci beaucoups.

Les séquences d'échappement ne marchent pas sous Windows avec les règlages par défaut! Et ils changent aussi selon les terminaux Linux utilisés (bon, peut-être pas celle-là, mais en général ). curses (ncurses, pdcurses, ...) est là pour ça.

J'ai un petit problème je comprend pas pourquoi mon programme est si lent que ça, il faut regarder la routine LZW_Compress.

http://perso.wanadoo.fr/tisofts/divers/LZW.cpp

Si vous pouvais m'éclairer sur ce sujet ça serait sympa, surtout que les sources sont loin d'être complexe.

A savoir que mon DICO fait 8192 et MAX_STR 255 le reste c'est pas trop important à savoir je pense.

C'est bon corrigé.

Par contre je me perd avec les headers .h...

J'ai mon programme principal qui appel LZW.h, dedans ce trouve une déclaration de variable. LZW.h est aussi appelé par LZW.cpp qui modifie cette variable ainsi que main.cpp qui appel bien sûr LZW.h.
Le problème c'est que le compilateur me renvoye une erreur comme quoi il y a plusieurs définitions de ma variable! (multiple definition of xxxx)
Comment corriger ce problème et donc modifier à partir de n'importe quel fichier cpp appellant LZW.h la variable voulue déclarée dans LZW.h?

Merci d'avance.

N'inclut pas le header plusieurs fois.
Fais par exemple un main.cpp qui contient #include "LZW.h", puis tes fichiers .cpp.

ok je vois.

[EDIT] euh pas vraiment en faite.

Dans mon LZW.h j'ai des défintiions qui sont utilisé dans LZW.cpp, donc si j'inclus que LZW.h dans main, le compilateur me signale qu'il ne trouve pas les définitions voulues dans LZW.cpp .

Si j'ai bien compris le problème, c'est très simple. Il suffit d'empêcher d'inclure plusieurs fois le même header avec le préprocesseur.
Donc tout tes headers devraient avoir cette forme: (pour un header qui s'appelle exemple.h)

#ifndef EXEMPLE_H /* Tu peux mettre le nom que tu veux mais prendre le nom du header est une bonne idée */
#  define EXEMPLE_H

/* Tu mets toutes tes déclarations ici */

#endif

De cette manière tu n'auras jamais plus d'une déclaration de chaque variable/fonction.
Ensuite le header tu l'inclues dans tous les fichiers C où tu en as besoin, il ne sera inclus qu'une seule fois par compilation, donc pas de déclarations multiples.

Si j'ai bien compris le problème, c'est très simple. Il suffit d'empêcher d'inclure plusieurs fois le même header avec le préprocesseur.
Donc tout tes headers devraient avoir cette forme: (pour un header qui s'appelle exemple.h)

#ifndef EXEMPLE_H /* Tu peux mettre le nom que tu veux mais prendre le nom du header est une bonne idée */
#  define EXEMPLE_H

/* Tu mets toutes tes déclarations ici qui ne seront lues par le compilateur que lors du premier "passage" puisque EXEMPLE_H sera défini après */

#endif

De cette manière tu n'auras jamais plus d'une déclaration de chaque variable/fonction.
Ensuite le header tu l'inclues dans tous les fichiers C où tu en as besoin, il ne sera inclus qu'une seule fois par compilation, donc pas de déclarations multiples.

BiHi> Oui mais mais moi j'ai un autre problème dans le genre:
exemple :

class Truc{
  ...
  void fonctionChiante1(Chose c);
}

class Chose{
  ...
  void fonctionChiante2(Truc t);
}

et la même avec le ifndef ca passera pas

C'est dans 2 headers différents?
Je crois qu'il suffit de déclarer la classe avant pour que le compilateur puisse savoir ce dont tu parles. Ca donnerait:

class Chose;

class Truc{
  ...
  void fonctionChiante1(Chose c);
}

class Truc;

class Chose{
  ...
  void fonctionChiante2(Truc t);
}

Au pire, définir des namespaces.

Ah ok pas pensé au ifdef... merci encore.

namespaces? c'est quoi aujuste car j'ai ça dans tous mes headers.

Un truc bien/nul du C++.
Chaque classe appartient à un namespace. Si t'as deux classes Moteur, tu définis les espaces de nom Bateau et Voiture,
comme ça t'aura pas de conflit entre les deux classes. ENsuite tu dis dans lequel tu parle (donc si tu es en train de parler de
bateaux ou de voitures) avec namespace bateau par exemple.
Et si tu es dans le namespace Bateau tu peux praler d'un moteur de voiture par voiture.Moteur.