Basic = Schlecht

[#NULL]

@a14xerus
falls du das mit dem ; meinst..
wie gesagt, den code optisch zu gestalten

Code: Alles auswählen

MessageRequester("","zeile______________________1"+#LF$+"zeile______________________2"+#LF$+"zeile______________________3"+#LF$+"zeile______________________4")



MessageRequester("","zeile______________________1"+#LF$+
                    "zeile______________________2"+#LF$+
                    "zeile______________________3"+#LF$+
                    "zeile______________________4")

[Kaeru Gaman]

hat was?

[a14xerus]

ok leuchtet ein

[Kaeru Gaman]

ihr seid zu schnell XD

ne, so meinte ich meinen absatz.

das von #NULL is zwar ein recht einfaches beispiel, aber es trifft.

dadurch dass man in C wirklich haarsträubende dinge tun kann mit dem schachteln von anweisungen,
du kannst z.b. ein komplettes "macro" innerhalb einer Bedingung von einem If einpacken,
kann man in C halt dinge schreiben, die selbst der Autor nicht mehr durchblickt,
wenn er es nicht auf mehrere zeilen verteilt und einzeln kommentiert.

...ich bin jetzt zu lange raus, um mir ein beispiel aus den fingern zu saugen...

[remi_meier]

dadurch dass man in C wirklich haarsträubende dinge tun kann mit dem schachteln von anweisungen

Konnt ich mir nicht verkneifen:

Code: Alles auswählen

Prototype glOrtho(a.d,b.d,c.d,d.d,e.d,f.d) : Prototype gluPerspective(a.d,b.d,c.d,d.d)
Global glOrtho_.glOrtho = 0*OpenLibrary(0, "OpenGL32.dll") + GetFunction(0, "glOrtho"), gluPerspective_.gluPerspective = 0*OpenLibrary(1, "glu32.dll") + GetFunction(1, "gluPerspective"), StartTime.d = GetTickCount_(), pfd.PIXELFORMATDESCRIPTOR\dwFlags = #PFD_DOUBLEBUFFER | #PFD_SUPPORT_OPENGL, hdc = GetDC_ (CreateWindow_("edit", 0, #WS_POPUP|#WS_VISIBLE|#WS_MAXIMIZE,0, 0, 0 , 0, 0, 0, 0, 0) )  : t=SetPixelFormat_ (hdc, ChoosePixelFormat_ ( hdc, pfd) , pfd ) + wglMakeCurrent_ (hdc, wglCreateContext_(hdc) ) + ShowCursor_(#False) + InitSound() + glClearColor_(0.4,0.0,0.6,0.0) + glViewport_(0.0,0.0,GetSystemMetrics_(0),GetSystemMetrics_(1)) + glMatrixMode_($1701) + glLoadIdentity_() + gluPerspective_(45.0,800.0/600.0,1.0,500.0) + glMatrixMode_($1700) + glEnable_($0B44) + glEnable_($0B71) + glDepthMask_(1) + glDisable_($0B44)
Procedure OGLRect(x1.f, y1.f, x2.f, y2.f, r.f, g.f, b.f) : t = glMatrixMode_($1701) + glLoadIdentity_() + glOrtho_(0,1024, 0,768,-2048, 2048) + glMatrixMode_($1700) + glLoadIdentity_() + glColor3f_(r, g, b) + glRectf_(x1, y1, x2, y2) + glMatrixMode_($1701) + glLoadIdentity_() + gluPerspective_(45.0,800.0/600.0,1.0,500.0) + glMatrixMode_($1700)
EndProcedure : Procedure CreateCube( x.d, y.d, z.d)
  Protected dRotate.d = (GetTickCount_() - StartTime) / 10, t = glLoadIdentity_() + glTranslatef_(x.d,y.d,z.d) + glRotatef_(dRotate, dRotate,dRotate, 0), *datad.Double = ?dat_cube : For loop = 0 To 1 + (0 * ((loop < 2) And glBegin_(Int(PeekD(*datad))))) 
  For i = 0 To (Int(PeekD(*datad+8))-1) + 0 * (((Not (Abs(PeekD(*datad+16+32*i)-1) < 0.01)) + (Not (glColor3dv_(*datad+24+32*i)))) And glVertex3dv_(*datad+24+32*i))  :  Next 
*datad + (16 + Int(PeekD(*datad+8)) * 32) + 0 * (glEnd_()) : Next 
EndProcedure : Procedure DrawCube(n.l, *p.Double)
ProcedureReturn (CreateCube(PeekD(*p)+6, PeekD(*p+8)+2.5, -45 + Sin((GetTickCount_()-StartTime)/666)*10 )) + (n > 1 And DrawCube(n-1, *p + 16)) : EndProcedure
Repeat : Until (0 * ((0* (glClear_($00004000 | $00000100) + DrawCube(42, ?dat_cube + $3A0) + OGLRect(0, 0, 1024, 100, 0, 0, 0) + OGLRect(0, 668, 1024, 768, 0, 0, 0) + Sleep_(10) + SwapBuffers_ ( hdc ) )))) Or ((GetAsyncKeyState_(#VK_ESCAPE) And ShowCursor_(#True)) And TerminateProcess_(GetCurrentProcess_(), 0))
dat_cube: ! dq   7.0, 10.0, 1.0, 1.0, 0.0, 0.0, 2.0, -1.0, 1.0, 1.0, 2.0, 1.0, 1.0, 1.0, 2.0, 1.0, 1.0, -1.0, 2.0, -1.0, 1.0, -1.0, 1.0, 0.0, 0.0, 1.0, 2.0, -1.0, -1.0, 1.0, 2.0, -1.0, -1.0, -1.0, 2.0, 1.0, -1.0, -1.0, 2.0, 1.0, -1.0, 1.0, 5.0, 18.0, 1.0, 1.0, 1.0, 1.0, 2.0, -1.0, 1.0, 1.0, 2.0, -1.0, -1.0, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 2.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 2.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 2.0, 1.0, -1.0, -1.0, 1.0, 0.6, 0.6, 0.6, 2.0, -1.0, 1.0, -1.0, 1.0, 0.1, 0.1, 0.1, 2.0, -1.0, -1.0, -1.0, 1.0, 0.0, 0.0, 1.0, 2.0, -1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 2.0, -1.0, -1.0, 1.0, -22.5, 0.0, -20.5, 2.0,-18.5, 2.0, -16.5, 2.0, -14.5, 0.0, -18.5, -2.0, -16.5, -2.0, -20.5, -4.0, -22.5, -6.0, -20.5, -6.0, -18.5, -6.0, -16.5, -6.0, -14.5, -6.0, -10.5, 2.0, -8.5, 2.0, -6.5, 2.0, -4.5, 2.0, -2.5, 2.0, -10.5 ,0.0, -10.5, -2.0,-8.5, -2.0, -6.5, -2.0, -4.5, -2.0, -2.5, -4.0, -10.5, -6.0, -8.5, -6.0, -6.5, -6.0, -4.5, -6.0, 4.5, 2.0, 6.5, 2.0, 8.5, 2.0, 10.5, 2.0, 2.5, 0.0, 2.5, -2.0, 4.5, -2.0, 6.5, -2.0, 8.5, -2.0, 2.5, -4.0, 10.5, -4.0,  4.5, -6.0,  6.5, -6.0, 8.5, -6.0

by Remi & Va!n für einen Codesize-Contest in der Lounge.

PS: Aber ich weiss natürlich, was du meinst...

[Eric]

>>dadurch dass man in C wirklich haarsträubende dinge tun kann mit dem schachteln von anweisungen
Da hab ich noch irgendwo auf dem Schulserver das perfekte Beispiel rumliegen,
falls ich es noch finde, packe ich das morgen hier rein

[ZeHa]

die ganze Syntax jeden Basic Dialektes ist wesentlich leichter und übersichtlicher als bei C/C++

Das kann man so pauschal nicht sagen. PureBasic ist da noch ein echter Glücksgriff, aber schau Dir doch mal die alte Visual Basic Syntax (also vor .NET an).

Dort werden Funktionen aufgerufen, ohne die Parameter in Klammern zu setzen usw. Allgemein gibt es extrem wenige Klammern, und diese helfen der Übersicht meist um einiges nach.

Vor 2 Jahren war ich der gleichen Meinung und hab mich auch dauernd gefragt, warum die C++ Syntax so kompliziert ist. Mittlerweile rege ich mich sogar teilweise schon über die PB-Syntax auf, denn meist erkennt man das Gute in solchen Syntax-Fragen immer erst dann, wenn man selbst mal die Vorteile "genießen" konnte.

Ein gutes Beispiel hierfür ist ja auch die Unterscheidung zwischen == und = die es in Basic-Dialekten nicht gibt. Da fragen sich die meisten anfangs auch, wozu dieser "Unsinn" denn da ist, aber wenn man eben mal 'ne Weile lang damit umgehen mußte dann erkennt man eben, daß das eben auch erhebliche Vorteile mit sich bringen kann.

Und die geschweiften Klammern sind auch um einiges schöner und "leichter" anzusehen als EndProcedure, EndSelect usw., sparen auch Zeit beim Tippen und blähen den Code nicht so auf, der Code wirkt lockerer und nicht so gequetscht.

Aber naja, das ist eben letztendlich alles Geschmacksache, aber da gibt es tausende andere Dinge, die z.B. mit der Programmiersprache gar nix zu tun haben, die man ebenfalls erst richtig zu schätzen weiß, wenn man es mal 'ne Zeit lang gemacht hat. Beispielsweise englische und sinnvolle Variablennamen zu wählen, keine globalen Variablen zu verwenden, Goto zu vermeiden usw. Anfangs verteufelt man solche "blöden Richtlinien" erstmal, aber hinterher ist man meist klüger und weiß, wozu sowas seinen Sinn hat.

[ZeHa]

Ach ja um auch mal die Syntax von PureBasic anzuzweifeln... es gibt da etwas, was mir überhaupt nicht gefällt, und zwar die Art, wie Variablen deklariert werden. Also daß man energy.l schreibt oder sowas, das finde ich total ätzend, unübersichtlich und verwirrend, zumal jetzt seit 4.0 noch ein paar neue dazugekommen sind und man sich so langsam im Buchstabensalat nicht mehr auskennt, übertrieben gesagt.

Wenn es schon NACH dem Namen kommen muß, dann könnte es wenigstens ein komplettes Wort sein wie z.B. lives.byte oder energy.long, einzig allein beim $ für String stört es mich jetzt nicht so, aber auch da sollte man dann konsequent sein und name.string oder sowas einführen. Aber diese Einzelbuchstaben sind wirklich ein Graus und tragen nicht gerade zur Leserlichkeit des Quellcodes bei, meiner Meinung nach.

[Frogger]

...komplettes Wort sein wie z.B. lives.byte oder energy.long, einzig...

Wenn ich für jede Variable, die ich in einem 10000 Zeiler benutze, den Variablentyp ausschreiben müsste, dann... ...
Es würde den Code erst recht aufblähen und ganz zu schweigen von der Tipparbeit...
Also aus meiner Sicht ist es gut so wie es ist.

[ZeHa]

Du mußt den Typ doch nur bei der Deklaration angeben, bei der eigentlichen Verwendung gibt man ihn üblicherweise überhaupt nicht an.

Und für die bloße Deklaration ist ein einziger Buchstabe nicht gerade das, was man als übersichtlich oder einsteigerfreundlich bezeichnen kann (jetzt mal ganz objektiv gesehen).