Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Utilizzando getchar e putchar su una variabile di tipo char da me definita il valore di ritorno è sempre il primo carattere. Come faccio a gestire per esempio il 4^ carattere ? E come faccio a gestire tutta la parola ?
Inoltre ho scritto 2 frammenti di codici
Codice sorgente - presumibilmente C++
#include <stdio.h>
int main()
{
char ch;
while(getchar()!='\n'){
ch =getchar();
putchar(ch);
}
return0;
}
Con questo codice se io inserisco la parola ciao mi stampa io. Perchè non ciao ?
Codice sorgente - presumibilmente C++
#include <stdio.h>
int main()
{
char ch;
while(1){
ch =getchar();
putchar(ch);
}
return0;
}
Con questo codice mi stampa tutta la parola.
Ultima modifica effettuata da gforce il 03/04/2010 alle 18:08
Non mi ricordo molto del C, ma nel primo codice usi due volte getchar, uno nella condizione e uno nelle istruzioni! Quindi il primo getchar nelle condizioni prende il primo carattere, ma poi nelle istruzioni prendi il secondo e stampi quello. Poi rifai da capo e prendi il terzo, poi il quarto e stampi il quarto.
Quindi potresti togliere il getchar nelle istruzioni e lasciare quello nelle condizioni così:
Codice sorgente - presumibilmente C/C++
while ( (ch = getchar()) != '\n') {
E invece di usare un MALEFICO while(1), il tutto diventa:
Codice sorgente - presumibilmente C++
#include <stdio.h>
int main()
{
char ch;
while((ch =getchar())!='\n'){
putchar( ch );
}
putchar( ch );
return0;
}
Se ti serve leggere e stampare stringhe inserite in input al programma continuamente evitando che si chiuda tutto, cioè non una volta sola (tipo col comando "cat"), puoi fare così:
Codice sorgente - presumibilmente C++
#include <stdio.h>
int main()
{
char ch;
for(;;){
while((ch =getchar())!='\n'){
putchar( ch );
}
putchar( ch );
}
return0;
}
Anche se ti conviene così:
Codice sorgente - presumibilmente C++
#include <stdio.h>
int main()
{
char ch;
for(;;){
ch =getchar();
putchar( ch );
}
return0;
}
Se ti serve qualcosa di ancora più corto, ecco un'altra (pessima) alternativa:
Codice sorgente - presumibilmente Plain Text
main(){for(;;)putchar(getchar());}
oppure
Codice sorgente - presumibilmente Plain Text
main(){putchar(getchar());main();}
Inutile far notare la bruttura delle ultime due...
Sicuramente non sono stato chiaro, ma il codice parla da solo, quasi sempre. Cosa buona e giusta potrebbe anche essere un libro/manuale sul C: non mangiano mica! Al massimo ti mangia il portafoglio se il manuale è buono.
Poi se vuoi fare qualcosa di leggero e veloce, puoi semplificare tutto in assembly (32 bit). Questo funziona per me:
asm("int $0x80"); // Chiama il kernel, esegue il tutto
// asm("popa"); // Reimposta i registri
asm("call _start"); // Chiama _start ye ricomincia il ciclo dall'inizio
}
E lo compili senza includere headers o librerie standard: senza "#include <stdio.h>" e con l'opzione -nostdlib per il compilatore (io uso gcc). La differenza si vede: da 4649 bytes a 1037 bytes... un po' meglio eh?
...Oppuuuure, lo scrivi direttamente in asm visto che ci sei. In my_cat.S:
Codice sorgente - presumibilmente C/C++
.global _start
_start:
movl $3, %eax
movl $1, %edx
movl %esp, %ecx
movl $1, %ebx
int $0x80
movl $4, %eax
movl %esp, %ecx
movl $1, %ebx
movl $1, %edx
int $0x80
jmp _start
E poi: as -o my_cat.o my_cat.S && ld -o my_cat my_cat.o && rm my_cat.o
L'eseguibile adesso mi si è ridotto a 708 bytes!
Se poi hai tempo da perdere, puoi accorciarlo ancora un pochino, ottenendo 692 bytes (sulla mia macchina):
Codice sorgente - presumibilmente C/C++
.global _start
_start:
xorl %eax, %eax
xorl %ebx, %ebx
xorl %edx, %edx
movb $3, %al
inc %edx
movl %esp, %ecx
inc %ebx
int $0x80
movb $4, %al
movl %esp, %ecx
//movb $1, %bl
//movb $1, %dl
int $0x80
jmp _start
Probabilmente potresti renderlo ancora più corto, non sono un guru. Per esempio "jmp _start" viene tradotto "e9 e7 ff ff ff" mentre credo si possa accorciare a "eb f9". Ah comunque il codice non è perfetto, potrebbe non funzionare in alcuni casi perchè ho badato solo alla lunghezza, non alla correttezza... in pratica funziona.
Morale della favola: Ridurre un programma al 15%, sicuramente è *cool* e ne aumenta la velocità di esecuzione.
PS: Si, ok, ovviamente non ce ne frega un cazzo se scriviamo due righe di codice (tipo queste) e se abbiamo un 8 core sotto il culo xD
Ultima modifica effettuata da TheWorm il 22/04/2010 alle 19:33