25/03/16 9:25
GN
Immagino dipenda dall'architettura e dal compilatore, comunque ho fatto una veloce prova con GCC (MingW perchè sono su Windows) su x86_64 e l'assembly generato è identico, quindi penso si possa dedurre che non c'è alcuna differenza.
In altre parole ho fatto:
test.c
test1.c
Eseguito i comandi
E ottenuto i seguenti risultati:
test.s
test1.s
Per trovare le differenze ho lanciato da shell MSYS:
E ho ottenuto come output:
Ovvero l'unica differenza è (ovviamente) nel nome del file sorgente che viene lasciato nell'assembly (se non sbaglio) come informazione di debug.
In altre parole ho fatto:
test.c
#include <stdio.h> int main(){ for(;;){ printf("ciao\n"); } return 0; }
test1.c
#include <stdio.h> int main(){ while(1){ printf("ciao\n"); } return 0; }
Eseguito i comandi
gcc -S test.c gcc -S test1.c
E ottenuto i seguenti risultati:
test.s
.file "test.c" .def __main; .scl 2; .type 32; .endef .section .rdata,"dr" .LC0: .ascii "ciaoImmagino dipenda dall'architettura e dal compilatore, comunque ho fatto una veloce prova con GCC (MingW perchè sono su Windows) su x86_64 e l'assembly generato è identico, quindi penso si possa dedurre che non c'è alcuna differenza.
In altre parole ho fatto:
test.c#include <stdio.h> int main(){ for(;;){ printf("ciao\n"); } return 0; }
test1.c#include <stdio.h> int main(){ while(1){ printf("ciao\n"); } return 0; }
Eseguito i comandigcc -S test.c gcc -S test1.c
E ottenuto i seguenti risultati:
test.s.file "test.c" .def __main; .scl 2; .type 32; .endef .section .rdata,"dr" .LC0: .ascii "ciao{parsed_message}" .text .globl main .def main; .scl 2; .type 32; .endef .seh_proc main main: pushq %rbp .seh_pushreg %rbp movq %rsp, %rbp .seh_setframe %rbp, 0 subq , %rsp .seh_stackalloc 32 .seh_endprologue call __main .L2: leaq .LC0(%rip), %rcx call puts jmp .L2 .seh_endproc .ident "GCC: (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 5.1.0" .def puts; .scl 2; .type 32; .endef
test1.s.file "test1.c" .def __main; .scl 2; .type 32; .endef .section .rdata,"dr" .LC0: .ascii "ciao{parsed_message}" .text .globl main .def main; .scl 2; .type 32; .endef .seh_proc main main: pushq %rbp .seh_pushreg %rbp movq %rsp, %rbp .seh_setframe %rbp, 0 subq , %rsp .seh_stackalloc 32 .seh_endprologue call __main .L2: leaq .LC0(%rip), %rcx call puts jmp .L2 .seh_endproc .ident "GCC: (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 5.1.0" .def puts; .scl 2; .type 32; .endef
Per trovare le differenze ho lanciato da shell MSYS:diff test.s test1.s
E ho ottenuto come output:1c1 < .file "test.c" --- > .file "test1.c"
Ovvero l'unica differenza è (ovviamente) nel nome del file sorgente che viene lasciato nell'assembly (se non sbaglio) come informazione di debug." .text .globl main .def main; .scl 2; .type 32; .endef .seh_proc main main: pushq %rbp .seh_pushreg %rbp movq %rsp, %rbp .seh_setframe %rbp, 0 subq , %rsp .seh_stackalloc 32 .seh_endprologue call __main .L2: leaq .LC0(%rip), %rcx call puts jmp .L2 .seh_endproc .ident "GCC: (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 5.1.0" .def puts; .scl 2; .type 32; .endef
test1.s
.file "test1.c" .def __main; .scl 2; .type 32; .endef .section .rdata,"dr" .LC0: .ascii "ciaoImmagino dipenda dall'architettura e dal compilatore, comunque ho fatto una veloce prova con GCC (MingW perchè sono su Windows) su x86_64 e l'assembly generato è identico, quindi penso si possa dedurre che non c'è alcuna differenza.
In altre parole ho fatto:
test.c#include <stdio.h> int main(){ for(;;){ printf("ciao\n"); } return 0; }
test1.c#include <stdio.h> int main(){ while(1){ printf("ciao\n"); } return 0; }
Eseguito i comandigcc -S test.c gcc -S test1.c
E ottenuto i seguenti risultati:
test.s.file "test.c" .def __main; .scl 2; .type 32; .endef .section .rdata,"dr" .LC0: .ascii "ciao{parsed_message}" .text .globl main .def main; .scl 2; .type 32; .endef .seh_proc main main: pushq %rbp .seh_pushreg %rbp movq %rsp, %rbp .seh_setframe %rbp, 0 subq , %rsp .seh_stackalloc 32 .seh_endprologue call __main .L2: leaq .LC0(%rip), %rcx call puts jmp .L2 .seh_endproc .ident "GCC: (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 5.1.0" .def puts; .scl 2; .type 32; .endef
test1.s.file "test1.c" .def __main; .scl 2; .type 32; .endef .section .rdata,"dr" .LC0: .ascii "ciao{parsed_message}" .text .globl main .def main; .scl 2; .type 32; .endef .seh_proc main main: pushq %rbp .seh_pushreg %rbp movq %rsp, %rbp .seh_setframe %rbp, 0 subq , %rsp .seh_stackalloc 32 .seh_endprologue call __main .L2: leaq .LC0(%rip), %rcx call puts jmp .L2 .seh_endproc .ident "GCC: (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 5.1.0" .def puts; .scl 2; .type 32; .endef
Per trovare le differenze ho lanciato da shell MSYS:diff test.s test1.s
E ho ottenuto come output:1c1 < .file "test.c" --- > .file "test1.c"
Ovvero l'unica differenza è (ovviamente) nel nome del file sorgente che viene lasciato nell'assembly (se non sbaglio) come informazione di debug." .text .globl main .def main; .scl 2; .type 32; .endef .seh_proc main main: pushq %rbp .seh_pushreg %rbp movq %rsp, %rbp .seh_setframe %rbp, 0 subq , %rsp .seh_stackalloc 32 .seh_endprologue call __main .L2: leaq .LC0(%rip), %rcx call puts jmp .L2 .seh_endproc .ident "GCC: (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 5.1.0" .def puts; .scl 2; .type 32; .endef
Per trovare le differenze ho lanciato da shell MSYS:
diff test.s test1.s
E ho ottenuto come output:
1c1 < .file "test.c" --- > .file "test1.c"
Ovvero l'unica differenza è (ovviamente) nel nome del file sorgente che viene lasciato nell'assembly (se non sbaglio) come informazione di debug.
aaa
25/03/16 10:22
I compilatori moderni ottimizzano parecchio e quindi non vedrai mai differenze di codice in questi casi.
E' solo una questione di chiarezza sintattica ... in questo caso mi sembra più chiaro il ciclo while
E' solo una questione di chiarezza sintattica ... in questo caso mi sembra più chiaro il ciclo while
25/03/16 10:22
TheDarkJuster
In realtà alcuni compilatori trasformano il for in un while PRIMA di processare il sorgente, in questo modo il risultato della compilazione sarà completamente identico sia in caso di while che in caso di for.
Comunque trovo il for più leggibile e comodo, perchè il ciclo è riassunto in una sola riga.
Comunque trovo il for più leggibile e comodo, perchè il ciclo è riassunto in una sola riga.
aaa
25/03/16 10:28
Postato originariamente da TheDarkJuster:
Comunque trovo il for più leggibile e comodo, perchè il ciclo è riassunto in una sola riga.
Comunque trovo il for più leggibile e comodo, perchè il ciclo è riassunto in una sola riga.
Le preferenze personali vanno bene ma c'è qualcosa che non capisco ....
Questo
for( ; ; )
è più chiaro di
while(true)
?? A me sembra l'esatto opposto e sono entrambi di una riga ...
Ultima modifica effettuata da 25/03/16 10:29
25/03/16 10:50
TheDarkJuster
perchè il for si preferisce usarlo quando hai bisogno di cicli con numero di esecuzioni finito....
aaa
25/03/16 11:06
Postato originariamente da TheDarkJuster:
perchè il for si preferisce usarlo quando hai bisogno di cicli con numero di esecuzioni finito....
perchè il for si preferisce usarlo quando hai bisogno di cicli con numero di esecuzioni finito....
Bella questa .... e
for ( ; ; )
ti sembra che sia un ciclo finito?
25/03/16 11:13
TheDarkJuster
No, mi riferivo alla leggibilità:
Nell'esempio è facile capire quante volte sia eseguito step() però nel caso del for è più immediato da capire: la scrittura è più compatta ed espressiva.
Però ti "aiuta" più del while nello scrivere invariante pre/post condizione di un ciclo......
for (int i=0; i<k; i++) { step(); }
int i=0; while ( i<k) { step(); i++; }
Nell'esempio è facile capire quante volte sia eseguito step() però nel caso del for è più immediato da capire: la scrittura è più compatta ed espressiva.
Però ti "aiuta" più del while nello scrivere invariante pre/post condizione di un ciclo......
aaa