C vs. D - Ein Vergleich

Man betrachte diese beiden einfachen Codeschnippsel die einen einfachen Fehler enthalten:

D Programm:

import std.stdio;

void main(string[] args)
{
    int bla = 0;
    while (bla = 1) /* Compiler meldet Fehler und weigert sich das
                       zu compilieren. */

    {
         writefln("Hello World, Reloaded");
    }
}

Das gleiche in C:

#include <stdio.h>

int main()
{
    int bla = 0;
    while (bla = 1) /* Compiler compiliert das, denn es ist ein
                       korrektes C Programm. Lediglich die Optionen
                       -Wall und -pedantic weißen auf den Fehler hin,
                       aber es bleibt ein korrektes Programm */
    {
         printf("Hello World, Reloaded");
    }
    return 0;
}

Das sagt doch schon alles, oder?
D bewahrt den Nutzer davor, fehlerhafte Programme zu schreiben.

Oder kann hier jemand schildern, warum eine Zuweisung in einer Bedingungsabfrage sinnvoll sein soll?

Shade Of Mine

Interessantes schrieb:

Oder kann hier jemand schildern, warum eine Zuweisung in einer Bedingungsabfrage sinnvoll sein soll?

strcpy:

while(*trg++=*src++)
  ;

Gibt jetzt keine 100mio Beispiele, aber genug.

Julian__

bool b = false;
while((b = getInput()) /*!= false*/) { use_b(); }

irgendwie so, wenn man eben einen wert direkt abfragt, der danach weiterverwendet wird? zumindest in c++ kenn ich das so, D kenne ich nicht.

mfg
julian

linux_c89

ich schreibe oft (grad bei socketfunktionen z.B.) Zuweisungen in if's, z.B. sowas

if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)

Und mein Compiler warnt mich wenn ich keine Klammern um die Zuweisung setze (aber ich hab glaub ich auch Wall an, is insgesamt sinnvoll)

cooky451

Interessantes schrieb:

Man betrachte diese beiden einfachen Codeschnippsel die einen einfachen Fehler enthalten:

D Programm:
import std.stdio;

void main(string[] args)
{
    int bla = 0;
    while (bla = 1) /* Compiler meldet Fehler und weigert sich das
                       zu compilieren. */

    {
         writefln("Hello World, Reloaded");
    }
}
Das gleiche in C:
#include <stdio.h>

int main()
{
    int bla = 0;
    while (bla = 1) /* Compiler compiliert das, denn es ist ein
                       korrektes C Programm. Lediglich die Optionen
                       -Wall und -pedantic weißen auf den Fehler hin,
                       aber es bleibt ein korrektes Programm */
    {
         printf("Hello World, Reloaded");
    }
    return 0;
}
Das sagt doch schon alles, oder?
D bewahrt den Nutzer davor, fehlerhafte Programme zu schreiben.

Oder kann hier jemand schildern, warum eine Zuweisung in einer Bedingungsabfrage sinnvoll sein soll?

Also ich finde dass nicht so schlimm. Bzw. ich würde es schon fast als Gegenargument zu D sehen dass das nicht kompiliert wird. Meiner Meinung nach sollten Sprachen nach möglichst einfachen und überall gültigen Regeln funktionieren.

linux_c89 schrieb:

ich schreibe oft (grad bei socketfunktionen z.B.) Zuweisungen in if's, z.B. sowas
if((sock=socket(AF_INET,SOCK_STREAM,0))==-1)
Und mein Compiler warnt mich wenn ich keine Klammern um die Zuweisung setze (aber ich hab glaub ich auch Wall an, is insgesamt sinnvoll)

Also dieser Verlgeich hinkt. Da das ja keine Zuweisung ist, sondern ein normaler Verlgeich.

Die Zuweisung selbst ist ja nur eingebettet und hat man if nicht direkt etwas zu tun.

linux_c89

Und was ist jetzt der Unterschied zu sowas (auch von mir häufig verwendet)

if((buf=malloc(1024)))

Ich finde es ist gerade einer der Vorteile von C dass er nur warnt und es trotzdem compiliert, d.h. er sagt "Ich sehe da keinen Sinn drin aber der Programmierer wirds schon wissen".

supertux

Interessantes schrieb:

Man betrachte diese beiden einfachen Codeschnippsel die einen einfachen Fehler enthalten:

D Programm:
import std.stdio;

void main(string[] args)
{
    int bla = 0;
    while (bla = 1) /* Compiler meldet Fehler und weigert sich das
                       zu compilieren. */

    {
         writefln("Hello World, Reloaded");
    }
}
Das gleiche in C:
#include <stdio.h>

int main()
{
    int bla = 0;
    while (bla = 1) /* Compiler compiliert das, denn es ist ein
                       korrektes C Programm. Lediglich die Optionen
                       -Wall und -pedantic weißen auf den Fehler hin,
                       aber es bleibt ein korrektes Programm */
    {
         printf("Hello World, Reloaded");
    }
    return 0;
}
Das sagt doch schon alles, oder?
D bewahrt den Nutzer davor, fehlerhafte Programme zu schreiben.

Oder kann hier jemand schildern, warum eine Zuweisung in einer Bedingungsabfrage sinnvoll sein soll?

Spar dir deine Trollversuche, die sind billig.

Ich habe einen Verglich: Motorrad vs. Auto.

Es ist stau, mit dem Motorrad kann ich mich trotzdem weiter bewegen. Das sagt doch schon alles, oder? Ein Motorad bewahrt den Nutzer davor, stehen zu bleiben. Ein Glück, dass es nicht wie aus Eimern gießt oder schneit.

Es gibt genug Gründe, warum man/ich eine Zuweisung in einer if Anfrage haben will. Und ein guter C Compiler warnt dich, du kannst also entscheiden, was du genau machen willst.