mehrdim. char Arrays

[Bruno]

Hallo!

Habe ich schon durch... FileName statt &FileName gibt:

warning: passing arg 1 of `strcpy' makes pointer from integer without a cast

Ich glaube es liegt daran, das MainFileName als char* definiert ist, das kommt allerdings aus den libs der Firma mit denen ich arbeite.

Der andere Fehler: strcpy(includes[inclzahl],inclname); liefert dasselbe Verhalten!

Ciao

Jürgen

[Xin]

Habe ich schon durch... FileName statt &FileName gibt:

warning: passing arg 1 of `strcpy' makes pointer from integer without a cast

Wie gesagt... Filename muss auch Platz für mehr als einen Buchstaben bieten.
1 Buchstabe:

Code: Alles auswählen

char Filename;

256 Buchstaben:

Code: Alles auswählen

char Filename[256];

Filename ist (bei char Filename[256]) damit der Zeiger (Datentyp char*) auf den ersten von beliebig vielen Buchstaben (wir wissen, es sind 256)
Wenn Du nur einen Buchstaben hast (Datentyp char) und den Adressoperator anwendest, dann ist das der Datentyp (char *), also der erste von beliebig vielen Buchstaben. Wir wissen, es ist nur einer, aber der Computer soll da reichlich Daten reinschreiben.

Der andere Fehler: strcpy(includes[inclzahl],inclname); liefert dasselbe Verhalten!

Das glaube ich nicht, da

Code: Alles auswählen

strcpy(&includes[inclzahl][80],inclname);

das gleiche wie

Code: Alles auswählen

strcpy(includes[inclzahl+1],inclname);

ist und das beschreibt den Fehler exakt.

Code: Alles auswählen

strcpy(includes[inclzahl],inclname);

muss entsprechend andere Ergebnisse liefern. Bitte Ausgabe mitposten und auf die Indizes achten!

[fat-lobyte]

Gerade in solchen Fällen ist GDB unglaublich nützlich um schnell auf Fehler draufzukommen
Setz doch vor den vermuteten Problemstatements einen breakpoint, und sieh dir mal ganz genau an was da überall im Speicher steht. Achte auch auf den Typ (Char, Char Array oder Zeiger auf Char Arrays).

[Bruno]

Hallo!

Das Problem ist mittlerweile gelöst (war genau so wie oben beschrieben!) und ich werde mich um ein Compiler update kümmern müssen.

Ein Kollege hat mir mit einem anderen Compiler noch ein paar "Unschönheiten" in meinem Code gezeigt.

ich denke, daß mir der aktuelle Compiler einfach zuviel "durchgehen" läßt.

Ciao

Jürgen

[fat-lobyte]

ich denke, daß mir der aktuelle Compiler einfach zuviel "durchgehen" läßt.

Ja, das ist Grundsätzlich ein großes Problem des GCC. Es empfiehlt sich jedes Programm mit den Flags "-Wall -pedantic -ansi" zu kompilieren. Dann ist zwar "-pedantic" wirklich Pädantisch, aber zumindest hilft dir die Statische analyse deinen Code sauber zu halten.

[Xin]

ich denke, daß mir der aktuelle Compiler einfach zuviel "durchgehen" läßt.

Ja, das ist Grundsätzlich ein großes Problem des GCC.

Och, Visual C++ kann das aber auch. Die Fehlermeldungen des GCC empfinde ich als deutlich aussagekräftiger.

Es empfiehlt sich jedes Programm mit den Flags "-Wall -pedantic -ansi" zu kompilieren. Dann ist zwar "-pedantic" wirklich Pädantisch, aber zumindest hilft dir die Statische analyse deinen Code sauber zu halten.

Volle Zustimmung. Moderne C++-Compiler bieten hervorragende Unterstützung der semantischen Analyse, auf die man auf keinen Fall verzichten sollte.

Kapselt man die von Dir zu lösenden Probleme entsprechend in überschaubare Klassen, lässt sich performante und sehr sichere Software erstellen.

[fat-lobyte]

Och, Visual C++ kann das aber auch. Die Fehlermeldungen des GCC empfinde ich als deutlich aussagekräftiger.

Eine Kombination aus GCC und MSVC hat sich für mich als durchaus ernsthaften Check herausgestellt. Manche Dinge findet man einfach nur, wenn man mit versch. Compilern kompiliert.

Volle Zustimmung. Moderne C++-Compiler bieten hervorragende Unterstützung der semantischen Analyse, auf die man auf keinen Fall verzichten sollte

Hab jetzt letztens nen neueren Compiler auf der Landschaft gesehen: LLVM(für C/C++: clang). Der sieht recht vielversprechend aus:

Code: Alles auswählen

  $ gcc-4.2 -fsyntax-only t.c
  t.c:7: error: invalid operands to binary + (have 'int' and 'struct A')
  $ clang -fsyntax-only t.c
  t.c:7:39: error: invalid operands to binary expression ('int' and 'struct A')
    return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);
                         ~~~~~~~~~~~~~~ ^ ~~~~~

Mal ausprobieren, wie der in meine Landschaft passt...

[Xin]

Och, Visual C++ kann das aber auch. Die Fehlermeldungen des GCC empfinde ich als deutlich aussagekräftiger.

Eine Kombination aus GCC und MSVC hat sich für mich als durchaus ernsthaften Check herausgestellt. Manche Dinge findet man einfach nur, wenn man mit versch. Compilern kompiliert.

Ich benutze ebenfalls beide. Alle paar Monate jage ich die Sachen durch Visual Studio und da sind meistens dann doch noch 2, 3 Dinge, die klever bemängelt werden.

Hab jetzt letztens nen neueren Compiler auf der Landschaft gesehen: LLVM(für C/C++: clang). Der sieht recht vielversprechend aus:

Code: Alles auswählen

  $ gcc-4.2 -fsyntax-only t.c
  t.c:7: error: invalid operands to binary + (have 'int' and 'struct A')
  $ clang -fsyntax-only t.c
  t.c:7:39: error: invalid operands to binary expression ('int' and 'struct A')
    return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);
                         ~~~~~~~~~~~~~~ ^ ~~~~~

Mal ausprobieren, wie der in meine Landschaft passt...

Nice. Das kommt schon fast an den Stil von SAS/C ran. Auf dem Compiler habe ich gelernt und mich häufig geärgert, dass die Fehlermeldungen häufig so eindeutig waren, dass er sie nicht automatisch gleich korrigiert und durchkompiliert.

[cloidnerux]

Hab jetzt letztens nen neueren Compiler auf der Landschaft gesehen: LLVM(für C/C++: clang). Der sieht recht vielversprechend aus:

Interessant.
Kenne ich nun noch einen C/C++-Compiler, neben MSVC, GCC, Intel C, Borland C++ und Digital Mars C++.

Sind ja doch schon eine Menge Unterschiedliche, da frage ich mich doch, wozu das ganze?
Ja, Intel hat immer die Aktuellsten und neusten features Implementiert, Microsoft hat ein auf Windows angepasstest Produkt, Borland ist ein alter Hase, GNU brauchte was eigenes, Quelloffenes und Digital mars versucht sich auch auf HPC zu spezialisieren und LLVM setzt sich selber auch die Performance Krone auf.

Mich würde es nun doch mal Interessieren, in wie fern die sich jetzt bei Alltäglichen aufgaben Unterscheiden?
Es können ja schließlich nicht alle gleichzeitig schneller als alle anderen sein

Mal sehn, vlt bastel ich mir mal ein Test zusammen.