Hallo LUG,
ich habe mich gerade ein bisschen mit Strukturen beschäftigt und habe ein Problem, das mich ein bisschen verwirrt. Ich wollte ein Array von 20 Strukturen erzeugen, auf dessen Elemente ich dann auf die Art "menu[1].zustand=1" zugreifen kann. Mein angehängtes Programm soll das mit einer Zeichen- kette demonstrieren. Allerdings erhalte ich vom Compiler die Fehlermeldung:
main.c: In function `main': main.c:21: request for member `beschreibung' in something not a structure or union main.c:28: parse error at end of input
Meine Frage: muss ich bei einer Struktur _jedes_ Element einzeln mit malloc allozieren oder was hab ich übersehen?
Schon mal im Vorraus vielen Dank,
Matthias
On Wed, Aug 15, 2001 at 02:53:03PM +0200, Matthias Petermann wrote:
exit(EXIT_FAILURE); strcpy( menu[0].beschreibung, "Testbeschreibung" ); endwin();
^^^^^^
das endwin ist noch ein Überbleibsel aus dem ursprüng- lichen Problemprogramm, das mit curses arbeitet. (Tut aber nichts zur Sache)
Matthias
On Wed, Aug 15, 2001 at 02:53:03PM +0200, Matthias Petermann wrote:
Meine Frage: muss ich bei einer Struktur _jedes_ Element einzeln mit malloc allozieren oder was hab ich übersehen?
Du definiert erst den struct und bei "struct list *menu[20];" wird schon der Platz für die 21 stucts reserviert. Das malloc kannst du dir also sparen.
strcpy( menu[0].beschreibung, "Testbeschreibung" );
strcpy( *(menu[0]).beschreibung, "Testbeschreibung" );
und weil das zu doof ist gibts dafür ne andere Syntax:
strcpy( menu[0]->beschreibung, "Testbeschreibung" );
Reinhard
Hallo Reinhard,
vielen Dank für Deine Hilfe. Ich werd das gleich mal so probieren.
On Wed, Aug 15, 2001 at 03:20:39PM +0200, Reinhard Foerster wrote:
Du definiert erst den struct und bei "struct list *menu[20];" wird schon der Platz für die 21 stucts reserviert. Das malloc kannst du dir also sparen.
...also gibt es in C keine Möglichkeit, Strukturen mit dyn. Speicherverwaltung anzulegen? So wie ich mein Buch verstanden habe (allerdings hab ich da nichts über Zeiger auf Strukturen gefunden) lege ich mit Konstruktionen wie "struct list *menu[20]" nur 21 "Speicher- plätze" für je einen Zeiger auf die später erzeugten Daten an...
Matthias
On Wed, Aug 15, 2001 at 03:25:06PM +0200, Matthias Petermann wrote:
So wie ich mein Buch verstanden habe (allerdings hab ich da nichts über Zeiger auf Strukturen gefunden) lege ich mit Konstruktionen wie "struct list *menu[20]" nur 21 "Speicher- plätze" für je einen Zeiger auf die später erzeugten Daten an...
Genau. Dann stimmte also deine Definition, nur der Zugriff war falsch. Du hattet nur vergessen, die Zeiger des Arrays zu dereferenzieren, bevor du auf die member der struct zugreifst
Reinhared
On Wed, Aug 15, 2001 at 03:25:06PM +0200, Matthias Petermann wrote:
...also gibt es in C keine Möglichkeit, Strukturen mit dyn. Speicherverwaltung anzulegen?
sinngemäß folgendes Beispiel:
struct example { int value; char anothervalue[80]; struct example *next; struct example *previous; }
+ ein wenig Theorie über verkettete Listen. + ein paar Funktionen zum einfachen Ranhängen und Lösche von Mitgliedern
Ist es das, was du suchst?
Matthias
Ulf
On Wed, Aug 15, 2001 at 03:20:39PM +0200, Reinhard Foerster wrote:
On Wed, Aug 15, 2001 at 02:53:03PM +0200, Matthias Petermann wrote:
Meine Frage: muss ich bei einer Struktur _jedes_ Element einzeln mit malloc allozieren oder was hab ich übersehen?
Du definiert erst den struct und bei "struct list *menu[20];" wird schon der Platz für die 21 stucts reserviert. Das malloc kannst du dir also sparen.
Sorry, so war das falsch. Wenn du
struct list menu[20];
machst, werden die stucts reserviert, bei
struct list *menu[20];
nicht.
Aber du wolltest wahrschienlich struct list menu[20]; weil dann menu[0].beschreibung das ist, was du vermutet hast :)
Alles klaro jetzt?
Reinhard
Ja, jetzt klappts... Danke nochmal.
Eine Kleinigkeit beschäftigt mich noch:
bis jetzt dachte ich, dass mit "struct list *menu[20]" - wie bereits vorhin geschrieben - Platz für '21' Zeiger reserviert wird (0-20). Allerdings löst irgend etwas um malloc auf menu[20] einen "Segmentation fault" aus. Das Programm hab ich noch einmal angehängt. Die Variable "durchlaeufe" ist auf 20 gesetzt, d.H. mit der folgenden Schleife werden menu[0]-menu[19] alloziert. Setze ich die Variable auf '20' läuft das Programm gegen den Baum, weil es versucht menu[21] zu benutzen. Was bedeutet "struct list *menu[20]" wirklich? Werden 20 Zeiger reserviert oder 21? Wenn 21, dann müsste "struct list *menu[0]" Platz für genau einen Zeiger reservieren, oder?
Matthias
On Wed, Aug 15, 2001 at 03:20:39PM +0200, Reinhard Foerster wrote:
On Wednesday 15 August 2001 16:07, Matthias Petermann wrote:
Ja, jetzt klappts... Danke nochmal.
Eine Kleinigkeit beschäftigt mich noch:
bis jetzt dachte ich, dass mit "struct list *menu[20]" - wie bereits vorhin geschrieben - Platz für '21' Zeiger reserviert wird (0-20). Allerdings löst irgend etwas um malloc auf menu[20] einen "Segmentation fault" aus. Das Programm hab ich noch einmal angehängt. Die Variable "durchlaeufe" ist auf 20 gesetzt, d.H. mit der folgenden Schleife werden menu[0]-menu[19] alloziert. Setze ich die Variable auf '20' läuft das Programm gegen den Baum, weil es versucht menu[21] zu benutzen. Was bedeutet "struct list *menu[20]" wirklich? Werden 20 Zeiger reserviert oder 21? Wenn 21, dann müsste "struct list *menu[0]" Platz für genau einen Zeiger reservieren, oder?
1) struct list *menu[20]; heißt: Pointer der auf 20 Elemente lange struct list Arrays zeigen darf.
2) struct list menu[20]; heißt: Array von 20 mal struct list (0..19)
3) struct list *menu; heißt: Pointer auf struct list, wenn Du ihm mit malloc(sizeof(struct list)*20) genug Speicher zuweist kannst Du ihn genauso verwenden, wie Variante 2), nur mußt Du ihn selbst mit free(menu) wieder freigeben.
Bei 2 und 3 ist das legal und möglich: menu[3].zustand=5; bei beiden führt das (meistens) zum Absturz (oder anderen lustigen Effekten): menu[21].zustand=7; menu[200]=0; menu[-8]=99; ->> ACHTUNG: keine der Varianten wird einen Fehler des Compilers hervorrufen!
Und das alles hat durchaus berechtigte Anwendungen.
Wenn Dir das zu hoch ist: Scriptsprachen, wie Tcl, Python und Co. sind wesentlich besser gesichert. Auch Java macht sich da recht gut. Pascal ist auch nicht ganz so intuitionsfeindlich.
Das ist der Preis, den man für eine flexible _und_ schnelle Sprache zahlt. ;-)
Konrad
On Wed, Aug 15, 2001 at 04:33:12PM +0200, Konrad Rosenbaum wrote:
- struct list *menu[20];
heißt: Pointer der auf 20 Elemente lange struct list Arrays zeigen darf.
Was??? Nach deiner Beschreinung ist menu nur ein einzelner Zeiger auf ... Also auf i386-linux ein 4 byte großes Etwas um das mal zu veranschaulichen.
menu ist aber ein 20-elementiges Array mit 20 (nicht initialisierten) Zeigern auf struct list und somit ein 80 Byte großes Etwas.
Reinhard
On Wednesday 15 August 2001 18:17, Reinhard Foerster wrote:
On Wed, Aug 15, 2001 at 04:33:12PM +0200, Konrad Rosenbaum wrote:
- struct list *menu[20];
heißt: Pointer der auf 20 Elemente lange struct list Arrays zeigen darf.
Was??? Nach deiner Beschreinung ist menu nur ein einzelner Zeiger auf ... Also auf i386-linux ein 4 byte großes Etwas um das mal zu veranschaulichen.
menu ist aber ein 20-elementiges Array mit 20 (nicht initialisierten) Zeigern auf struct list und somit ein 80 Byte großes Etwas.
Ups, hast Recht.
Meines würde so aussehen: struct list (*menu)[20];
Arrays und Pointer in C mischen macht irgendwie keinen Spass.
Konrad
Am Mittwoch, 15. August 2001 12:47 schrieben Sie:
On Wednesday 15 August 2001 18:17, Reinhard Foerster wrote:
Was??? Nach deiner Beschreinung ist menu nur ein einzelner Zeiger auf ... Also auf i386-linux ein 4 byte großes Etwas um das mal zu veranschaulichen.
menu ist aber ein 20-elementiges Array mit 20 (nicht initialisierten) Zeigern auf struct list und somit ein 80 Byte großes Etwas.
Ups, hast Recht.
Meines würde so aussehen: struct list (*menu)[20];
Arrays und Pointer in C mischen macht irgendwie keinen Spass.
Wieso, ich dachte Arrays und Pointer in C wären das gleiche :)
Stephan
On Thu, Aug 16, 2001 at 09:52:50PM -0400, Stephan Goetter wrote:
Am Mittwoch, 15. August 2001 12:47 schrieben Sie:
^^^ Also ich nicht...
Arrays und Pointer in C mischen macht irgendwie keinen Spass.
Wieso, ich dachte Arrays und Pointer in C wären das gleiche :)
http://www2.informatik.uni-wuerzburg.de/dclc-faq/kap2.html
Eric
Am Donnerstag, 16. August 2001 17:19 schrieben Sie:
On Thu, Aug 16, 2001 at 09:52:50PM -0400, Stephan Goetter wrote:
Am Mittwoch, 15. August 2001 12:47 schrieben Sie:
Also ich nicht...
Arrays und Pointer in C mischen macht irgendwie keinen Spass.
Wieso, ich dachte Arrays und Pointer in C wären das gleiche :)
Ihr Compiler schon ab und an mit Optimierung und innerhalb einer Funktion.
#include <stdio.h> int main(){ char a[] = "hello"; char *p = "world"; putchar(a[3]); putchar(p[3]); }
.file "test.c" .version "01.01" gcc2_compiled.: .section .rodata .LC0: .string "hello" .LC1: .string "world" .text .align 16 .globl main .type main,@function main: pushl %ebp movl .LC0, %eax movl %esp, %ebp subl $36, %esp movl %eax, -24(%ebp) movw .LC0+4, %ax movw %ax, -20(%ebp) movsbl -21(%ebp),%eax pushl %eax call putchar movsbl .LC1+3,%eax movl %eax, (%esp) call putchar leave ret .Lfe1: .size main,.Lfe1-main .ident "GCC: (GNU) 2.96 20000731 (Linux-Mandrake 8.0 2.96-0.48mdk)"
On Friday 17 August 2001 03:52, Stephan Goetter wrote:
Am Mittwoch, 15. August 2001 12:47 schrieben Sie:
On Wednesday 15 August 2001 18:17, Reinhard Foerster wrote:
Was??? Nach deiner Beschreinung ist menu nur ein einzelner Zeiger auf ... Also auf i386-linux ein 4 byte großes Etwas um das mal zu veranschaulichen.
menu ist aber ein 20-elementiges Array mit 20 (nicht initialisierten) Zeigern auf struct list und somit ein 80 Byte großes Etwas.
Ups, hast Recht.
Meines würde so aussehen: struct list (*menu)[20];
Arrays und Pointer in C mischen macht irgendwie keinen Spass.
Wieso, ich dachte Arrays und Pointer in C wären das gleiche :)
"Äquivalent" und "das Gleiche" ist noch ein gewisser Unterschied. Ersteres bedeutet, dass man sie identisch nutzen kann, letzteres würde bedeuten, dass man sie auch identisch alloziert. Und bei der Allokation liegt die Schwierigkeit von Pointer-Array-Mischlingen. Die Syntax von C ist hier etwas schwierig zu verstehen - deswegen benutze ich fast grundsätzlich reine Arrays oder reine Pointer.
Konrad
Konrad Rosenbaum (konrad.rosenbaum@t-online.de) wrote:
KR> man sie auch identisch alloziert. Und bei der Allokation liegt die ^ ^
BTW und OT: Heisst es allozieren, allokieren, alloziiert, allokiert, Allokation, Alloziation, oder was .... ?
On Fri, Aug 17, 2001 at 02:44:35PM +0200, Andreas Reich wrote:
Konrad Rosenbaum (konrad.rosenbaum@t-online.de) wrote:
KR> man sie auch identisch alloziert. Und bei der Allokation liegt die ^ ^
BTW und OT: Heisst es allozieren, allokieren, alloziiert, allokiert, Allokation, Alloziation, oder was .... ?
Eigentlich allocate... ;)
Die anderen Begriffe sind typische Eindeutschungen bei denen sich nicht entschieden werden konnte ob das 'c' als 'k' oder 'z' übernommen werden soll.
Ciao, Tobias der etwas gegen Eindeutschungen in der Komputersprache hat
Hallo,
noch einmal vielen Dank für Eure zahlreichen Tipps. Ich glaube es nun verstanden zu haben, zumindest soweit dass ich erst einmal weiterkomme.
On Wed, Aug 15, 2001 at 04:33:12PM +0200, Konrad Rosenbaum wrote:
Wenn Dir das zu hoch ist: Scriptsprachen, wie Tcl, Python und Co. sind wesentlich besser gesichert. Auch Java macht sich da recht gut. Pascal ist auch nicht ganz so intuitionsfeindlich. Das ist der Preis, den man für eine flexible _und_ schnelle Sprache zahlt. ;-)
Naja, ich bin ja dabei die Sprache(n) zu lernen. Da ich im 1. Semester in Programmiersprachen 'C' habe, wollte ich mich da mal ein wenig "einarbeiten". Ich habe mir 'Programmieren in C' von K./R. und ein sog. 'C-Lernbuch' ausgeliehen und will das jetzt ernsthaft lernen :)
Eine andere Frage habe ich noch: Gibt es für den Pinguin ein Programm, mit dem ich mir den momentanen Speicherverbrauch eines Prozesses anzeigen lassen kann? Mit 'top' geht das zwar auch; allerdings ist das recht umständlich.
Viele Grüße,
Matthias
On Wednesday 15 August 2001 18:38, Matthias Petermann wrote:
Eine andere Frage habe ich noch: Gibt es für den Pinguin ein Programm, mit dem ich mir den momentanen Speicherverbrauch eines Prozesses anzeigen lassen kann? Mit 'top' geht das zwar auch; allerdings ist das recht umständlich.
ps v
On Wed, Aug 15, 2001 at 04:07:16PM +0200, Matthias Petermann wrote:
Ja, jetzt klappts... Danke nochmal.
Eine Kleinigkeit beschäftigt mich noch:
bis jetzt dachte ich, dass mit "struct list *menu[20]" - wie bereits vorhin geschrieben - Platz für '21' Zeiger reserviert wird (0-20). Allerdings löst irgend etwas um malloc auf menu[20] einen "Segmentation fault" aus. Das Programm hab ich noch einmal angehängt. Die Variable "durchlaeufe" ist auf 20 gesetzt, d.H. mit der folgenden Schleife werden menu[0]-menu[19] alloziert. Setze ich die Variable auf '20' läuft das Programm gegen den Baum, weil es versucht menu[21] zu benutzen. Was bedeutet "struct list *menu[20]" wirklich?
20 zeiger sind es nur, also [0]-[19].
dann müsste "struct list *menu[0]" Platz für genau einen Zeiger reservieren, oder?
Das wären noch 0 Zeiger. Keine Ahnung, was ein Compiler dazu sagt. Sinn macht es nicht.
Reinhard
On Wed, Aug 15, 2001 at 04:07:16PM +0200, Matthias Petermann wrote:
Ja, jetzt klappts... Danke nochmal.
Eine Kleinigkeit beschäftigt mich noch:
bis jetzt dachte ich, dass mit "struct list *menu[20]" - wie bereits vorhin geschrieben - Platz für '21' Zeiger reserviert wird (0-20). Allerdings löst irgend etwas um malloc auf
0 - 19 -> das sind 20 Elemente.
menu[20] einen "Segmentation fault" aus. Das Programm hab ich noch einmal angehängt. Die Variable "durchlaeufe" ist auf 20 gesetzt, d.H. mit der folgenden Schleife werden menu[0]-menu[19] alloziert. Setze ich die Variable auf '20' läuft das Programm
Idiomatisch ist etwas in der Art:
#define SZ 20 int iv[SZ];
int i;
for (i = 0; i < SZ; ++i) DO SOMETHING;
gegen den Baum, weil es versucht menu[21] zu benutzen. Was bedeutet "struct list *menu[20]" wirklich? Werden 20 Zeiger reserviert oder 21? Wenn 21, dann müsste "struct list *menu[0]" Platz für genau einen Zeiger reservieren, oder?
Eben. Und darum sind's 20 und nicht 21.
Best regards from currently Schwerin/Germany Viele Gruesse aus Schwerin/Mecklenburg-Vorpommern Heiko Schlittermann
On Wednesday 15 August 2001 14:53, Matthias Petermann wrote:
ich habe mich gerade ein bisschen mit Strukturen beschäftigt und habe ein Problem, das mich ein bisschen verwirrt. Ich wollte ein Array von 20 Strukturen erzeugen, auf dessen Elemente ich dann auf die Art "menu[1].zustand=1" zugreifen kann. Mein angehängtes Programm soll das mit einer Zeichen- kette demonstrieren. Allerdings erhalte ich vom Compiler die Fehlermeldung:
main.c: In function `main': main.c:21: request for member `beschreibung' in something not a structure or union main.c:28: parse error at end of input
Meine Frage: muss ich bei einer Struktur _jedes_ Element einzeln mit malloc allozieren oder was hab ich übersehen?
Nein Du musst sie alle _gleichzeitig_ allozieren.
Ausserdem sind Pointer (*) und array ([..]) einigermaßen äquivalente Typen. Der Unterschied ist einfach, dass Du bei Pointern mit malloc rangehst und bei Arrays dem Compiler von Anfang an sagst, wieviel Speicher Du brauchst. Du musst Dich also für eine Variante entscheiden. In Deinem Fall hattest Du folgendes gemacht:
1. Du hast einen Pointer auf ein Array angelegt. 2. Du hast versucht das erste Element auf das der Pointer zeigt zu dereferenzieren und ihm neuen Speicher zuzuweisen, was aber gleich zwei Haken hatte: a) die Dereferenzierung eines Pointers auf Array ergibt Array und Arrays kann man keinen neuen Speicher zuweisen (man hat schließlich explizit den Compiler als dafür zuständig deklariert, indem man ein Array genommen hat) b) der Pointer hatte noch keinen Speicher zugewiesen bekommen und soetwas zu dereferenzieren bringt das Program meistens ins Datennirvana.
Ansonsten kannst Du Pointer und Array identisch behandeln. Siehe Anhang.
Übrigens: Du solltest mit malloc geholten Speicher auch mit free wieder freigeben. Wenn das Programm nicht gerade nur für wenige Millisekunden läuft verbraucht das sonst unnötig Speicher.
Konrad
On Wed, Aug 15, 2001 at 02:53:03PM +0200, Matthias Petermann wrote:
Hallo LUG, #include <stdio.h> #include <stdlib.h> #include <string.h>
int main() { struct list { int zustand; char beschreibung[40]; };
struct list *menu[20];
Also 20 Pointer auf 20 Strukturen. Wenn ich jetzt nicht ganz blöd bin. Wenn Du ein Array von 20 Strukturen willst (wolltest Du aber wohl nicht), dann \verb!struct list menu[20]! Hat aber mit Dynamik nix mehr zu tun.
Und da Du jetzt 20 Pointer hast, mußt Du nun auch 20x Platz für die Strukturen allozieren.
for (i = 0; i < 20; ++i) { menu[i] = (struct list*) malloc(sizeof(struct list)); assert(menu[i]); /* FIXME */ }
menu[0] = (struct list *) malloc( sizeof(struct list) ); if (menu[0] == NULL ) { printf("Fehler bei der Speicherzuordnung\n"); exit(EXIT_FAILURE); strcpy( menu[0].beschreibung, "Testbeschreibung" );
Und nun liegt in menu[0] ja ein _Pointer_, also kannst Du nicht mit "." auf Strukturelemente zugreifen, sondern mußt den Pointer derefenzieren.
strncpy((*menu[0]).beschreibung, "Testbeschreibung", 39);
Die Klammern bei (*menu[0]).beschreibung, weil der "." stärker klebt als der "*". Und weil wir keine Klammeraffen sind, hat man "->" erfunden.
(*menu[0]).beschreibung und menu[0]->beschreibung
sind identisch. Also
strncpy(menu[0]->beschreibung, "Testbeschreibung", 39);
Eine andere Möglichkeit, die vielen Mallocs zu sparen, wäre (unkommentiert) etwa das folgende:
struct list *p = malloc(20 * sizeof(struct list)); struct list *menu[20]; for (i = 0; i < 20; ++i) menu[i] = p + i;
strncpy(menu[0]->beschreibung, ....
Der Rest dann wie gehabt. Oder gleich so:
struct list *menu = malloc(20 * sizeof(struct list)); strncpy(menu[0].beschreibung, ....
Oder? Man möge mich korrigieren. Ich bin leider kein Professional Programmer und habe nicht so sehr viel Programmierlebenserfahrung und bin auch kein Informatiker und weiß eigentlich nicht, wie _wirklich_ programmmiert wird ;-)
Best regards from currently Schwerin/Germany Viele Gruesse aus Schwerin/Mecklenburg-Vorpommern Heiko Schlittermann
Hallo,
nochmal vielen Dank für die wirklich aufschlussreichen Erklärungen zu meiner Frage. Mich würde noch etwas ganz allgemeines zu C interessieren. Ich arbeite gerne mit der Framebuffe-Konsole bei 100x37 Zeichen. Diese habe ich jetzt des Öfteren auch schon voll ausgenutzt, d.H. mehrere Zeilen im C-Programm ist >80 Zeichen gewesen. So ein Programm ist dann auf einer 80-Zeichen-Konsole sicher nicht mehr richtig lesbar. In meinem Lernbuch steht u.A. dass C keine Vorschriften in Punkto Design von Quelltexten macht; entsprechend rar sind daher auch die Beschreibungen dazu :( Eine interessante Datei habe ich in den Kernel-Quellen gefunden (linux/Documention/CodingStyle), in der u.A. das richtige Setzen von Klammern und Einrückungen bei for,if,etc...-Konstrukten ge- zeigt wird. Gibt es zu diesem Thema irgendwo noch Genaueres zu lesen bzw. kann mir jemand ein Buch empfehlen?
Danke, Matthias
On Wed, Aug 15, 2001 at 09:30:46PM +0200, Heiko Schlittermann wrote:
Also 20 Pointer auf 20 Strukturen. Wenn ich jetzt nicht ganz blöd bin. Wenn Du ein Array von 20 Strukturen willst (wolltest Du aber wohl nicht), dann \verb!struct list menu[20]! Hat aber mit Dynamik nix mehr zu tun... []
On Thursday 16 August 2001 20:45, Matthias Petermann wrote:
In meinem Lernbuch steht u.A. dass C keine Vorschriften in Punkto Design von Quelltexten macht; entsprechend rar sind daher auch die Beschreibungen dazu :( Eine interessante Datei habe ich in den Kernel-Quellen gefunden (linux/Documention/CodingStyle), in der u.A. das richtige Setzen von Klammern und Einrückungen bei for,if,etc...-Konstrukten ge- zeigt wird. Gibt es zu diesem Thema irgendwo noch Genaueres zu lesen bzw. kann mir jemand ein Buch empfehlen?
Es gibt da noch die GNU-CodingStyles(*), die sich sehr stark am alten K&R-C orientieren und in den Standardwerken zu C (u.a. die Bücher von K&R) sind wohl auch recht häufig solche Sachen drin. Letztendlich muss der Programmierer selbst entscheiden, welcher Stil am besten zu ihm passt. Eines sollte Dir dabei aber immer klar sein: der Projektleiter entscheidet - sprich: wenn Du in ein Projekt reinkommst versuch' als erstes rauszufinden welcher Stil verwendet wird. Nur eines ist schlimmer als schlecht formatierter Code: inkonsistent formatierter Code.
(*) irgendwo auf http://www.gnu.org
Das gemeine an dieser Sache ist, dass kein Stil per se besser ist als irgendein anderer - jeder hat seine Vor- und Nachteile.
Ich persönlich fahre mit dem Linux-Style immernoch am besten. Aber man kann da durchaus anderer Meinung sein (unter Windows z.B. sind 80 Zeichen _eindeutig_ zu wenig und ein Tab als Einrückung _eindeutig_ zu viel, da die Funktionsnamen viel zu lang sind).
Mal einige Beispiele: a) Einrückung == Tab == 8Spaces Vorteile: sehr übersichtlicher Code; einfach zu erzeugen (1x Tab-Taste); gute Warnung, wenn der Code zu komplex wird (es geht über den Rand) Nachteile: bei komplexen Schleifen/if's geht es schnell über den Rand (Anm.: sowas sollte man sowieso vermeiden)
b) Einrückung == 1 oder 2 Spaces Vorteil: sehr verdichteter Code mit vielen Indent-Levels ist möglich Nachteile: es wird schnell unübersichtlich
c) öffnende Klammer { unter for, if, while, switch Vorteil: öffnende Klammer { kann sehr leicht der schließenden Klammer } zugeordnet werden Nachteil: es schafft künstlichen Abstand zwischen Code und for/if/... => Folge: der Lesefluß wird unnötigerweise unterbrochen
d) öffnender Klammer { dahinter Vorteil: keine Unterbrechung des Leseflusses Depends: } wird nun dem ersten Buchstaben des Statements statt { zugeordnet
usw.
Was Dir persönlich mehr liegt musst letztlich Du entscheiden. Ich fand Linus' Argumente sehr einleuchtend.
Your milage may vary.
Konrad
lug-dd@mailman.schlittermann.de
-
Andreas Reich -
Eric Schaefer -
Heiko Schlittermann -
konrad.rosenbaum＠t-online.de -
Matthias Petermann -
Reinhard Foerster -
Stephan Goetter -
Tobias Koenig -
Ulf Lorenz