Hilfe bei Matrixmultiplikation in C als Funktion
-
ich hab jetzt verstanden, was du meinst. die einen regen sich über einmalig 3 takte rechenzeitverlust auf, die anderen nicht.
aber wieso optimiert der compiler das nicht raus?
-
HansKlaus schrieb:
also ich habs eben durch den gcc geschickt,
Was hast du gejagt? Deinen 6-Zeiler ohne Code?
HansKlaus schrieb:
hat er ohne zu murren genommen, sowohl mit gcc main.c als auch mit gcc -x c main.c, es gibt keine Warnungen, keine Fehler, keine Speicherzugriffsverletzungen.
Das -x c hat keinen Effekt, da du ja eine .c Datei hast.
Aber -Wall und -std:c89 oder -std:c99 wären eine Option.
-
#include <stdio.h> const int zeilen=5; const int spalten=6; int main() { int matrix[zeilen][spalten]; int i=0; int j=0; int zahl=0; for(i=0;i<zeilen;i++) { for(j=0;j<spalten;j++) { matrix[i][j]=zahl; zahl++; } } for(i=0;i<zeilen;i++) { for(j=0;j<spalten;j++) { printf("%3d",matrix[i][j]); } printf("\n"); } return 0; }lese- und schreibzugriff auf den speicher. keine Compilermeldungen, weder mit -std=c89 noch mit std=c99.
-
Du hast nicht nur keine Ahnung von C sondern auch keine Ahnung vom Compiler.
Deine Implizierung, "Compiler läuft durch, also funktioniert das Programm und enthält keine Fehler" ist nur Ausdruck deines dümmlich-naiven Horizonts.
Solche pubertären Deppen wie du kommen hier (leider) regelmäßig zu Wort, das Schema ist immer das Gleiche: mit irgendwo aufgeschnapptem Halbwissen plappern sie rum, machen gar Annahmen, warum die C Erfinder das so festgelegt haben, pauschalisieren ihre deppenhaften Vorstellungen schnell als "allgemeingültig", treffen Annahmen, warum das in C so und nicht anders funktioniert weil der Compiler keine (ihnen begreifliche) Fehler wirft.
Du hast keine Ahnung von C.
Das wird auch nicht besser, wenn du ständig deine Infiltrierungen deines Profs und Schrottcode wiederholst.
Wenn du mal 25 Jahre professionelle C Erfahrung hast, kannst du dich hier mal wieder melden (und wirst über deine jetzigen sinnfreien, naiv-stümperhaften Aussagen nur den Kopf schütteln und einsehen, es wäre besser gewesen, sie nie gemacht zu haben).
Also:
Klappe halten, wenn man keine Ahnung hat. Und du hast keine Ahnung.
-
*Seufz*
Für etwas, das man einfach fix in jedem guten C-Lehrbuch nachlesen könnte, hältst du gewaltig lange an deinen Fehlvorstellungen fest.
Beispielcode:
#include <stdio.h> const int zeilen=5; const int spalten=6; int main() { int matrix[zeilen][spalten]; return 0; }GCC mit C89, pedantic:
test.c:8:5: warning: ISO C90 forbids variable length array 'matrix' [-Wvla] int matrix[zeilen][spalten]; ^ test.c:8:5: warning: ISO C90 forbids variable length array 'matrix' [-Wvla] test.c:8:9: warning: unused variable 'matrix' [-Wunused-variable] int matrix[zeilen][spalten]; ^Dies ist, was dir ein anderer Compiler als Meldung geben könnte (und wird).
Mit C99 wird Maschinencode erzeugt (ohne Optimierung, da sonst das unbenutzte Array entfernt würde):
.file "test.c" .globl zeilen .section .rodata .align 4 .type zeilen, @object .size zeilen, 4 zeilen: .long 5 .globl spalten .align 4 .type spalten, @object .size spalten, 4 spalten: .long 6 .text .globl main .type main, @function main: .LFB0: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 .cfi_offset 6, -16 movq %rsp, %rbp .cfi_def_cfa_register 6 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $32, %rsp .cfi_offset 14, -24 .cfi_offset 13, -32 .cfi_offset 12, -40 .cfi_offset 3, -48 movq %rsp, %r10 movq %r10, %r12 movl $6, %r10d movslq %r10d, %r10 subq $1, %r10 movq %r10, -56(%rbp) movl $6, %r10d movslq %r10d, %r10 movq %r10, %r13 movl $0, %r14d movl $5, %r10d movslq %r10d, %r10 subq $1, %r10 movq %r10, -48(%rbp) movl $6, %r10d movslq %r10d, %r10 movq %r10, %r8 movl $0, %r9d movl $5, %r10d movslq %r10d, %r10 movq %r10, %rax movl $0, %edx movq %r9, %r11 imulq %rax, %r11 movq %rdx, %r10 imulq %r8, %r10 addq %r11, %r10 mulq %r8 leaq (%r10,%rdx), %r8 movq %r8, %rdx movl $6, %eax cltq movq %rax, %rsi movl $0, %edi movl $5, %eax cltq movq %rax, %rcx movl $0, %ebx movq %rdi, %rdx imulq %rcx, %rdx movq %rbx, %rax imulq %rsi, %rax leaq (%rdx,%rax), %r8 movq %rsi, %rax mulq %rcx leaq (%r8,%rdx), %rcx movq %rcx, %rdx movl $6, %eax movslq %eax, %rdx movl $5, %eax cltq imulq %rdx, %rax salq $2, %rax leaq 3(%rax), %rdx movl $16, %eax subq $1, %rax addq %rdx, %rax movl $16, %edi movl $0, %edx divq %rdi imulq $16, %rax, %rax subq %rax, %rsp movq %rsp, %rax addq $3, %rax shrq $2, %rax salq $2, %rax movq %rax, -40(%rbp) movl $0, %eax movq %r12, %rsp leaq -32(%rbp), %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %rbp .cfi_def_cfa 7, 8 ret .cfi_endproc .LFE0: .size main, .-main .ident "GCC: (geht niemanden hier etwas an)" .section .note.GNU-stack,"",@progbitsHingegen mit defines (egal ob C89 oder C99):
.file "test.c" .text .globl main .type main, @function main: .LFB0: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 .cfi_offset 6, -16 movq %rsp, %rbp .cfi_def_cfa_register 6 subq $8, %rsp movl $0, %eax leave .cfi_def_cfa 7, 8 ret .cfi_endproc .LFE0: .size main, .-main .ident "GCC: (geht niemanden hier etwas an)" .section .note.GNU-stack,"",@progbitsSelbst wenn du kein Assembler verstehst, sollte offensichtlich sein, dass es hier riesige Unterschiede gibt. Im zweiten Compilat existieren die Objekte
zeilenundspaltennicht mehr. Das kann man so wollen oder nicht; wichtig ist, dass es einen Unterschied macht.Viel wichtiger und auch viel größer ist jedoch der Unterschied bei der Speicherallokierung in der main. Die im zweiten Fall ebenfalls nicht wirklich existiert, da es sich einfach nur um einen Offset beim Start der Funktion handelt. Beim ersten Code muss hingegen richtig Arbeit verrichtet werden (und zwar weit mehr als 3 Takte), da es sich um eine (semi-)dynamische Allokation handelt.
