Using C++ in GCC is OK

Dravere schrieb:

Nexus schrieb:

C++ ohne Templates, Exceptions und Mehrfachvererbung? Das kommt dem "C mit Klassen" schon bedenklich nahe.

Naja, über die Mehrfachvererbung und auch Exceptions könnte man vielleicht noch streiten. Wobei ich mich schon ein wenig frage, was denn so schwer an den Exceptions sein soll.
Bei den Templates fürchte ich fast, dass da ein Missverständnis vorliegt. Wahrscheinlich wollen sie keine grossen Templatemetaprogrammierungs-Tricks. Die Container aus der Standardbibliothek möchten sie schliesslich zulassen, also wieso auch nicht Templates für eigene Container zulassen?

Eigene templates sind nicht erlaubt, STL in vollem Umfang dagegen schon.
Die eigentlichen Guidelines werden AFAIK aber noch ausgearbeitet.

trojalinde schrieb:

player4245 schrieb:

Ich versteh das nicht. Auf der einen Seite ist das Gejammer groß wenn es mal jemand wagt C mit C++ zu mischen und auf der anderen Seite entscheidet man sich zu so einem Schritt.

@naich : Zu behaupten Arrays wären langsamer als OOP-Container zeugt nicht gerade von fachlicher Kompetenz.
Auch halte ich das Argument von dir, dass man in C leichter schwere Fehler macht für unsinnig. Das hängt vom Programmdesign ab.

Du Honk, ich rede von dynamischen C-Arrays vs. vector von C++. Statische Arrays sind ja wohl die reinste Platzverschwendung und somit Resourcenverschwendung, zumal man sie wenn man es denn brauch in C++ auch einsetzen kann. Beim Vergleich C zu C++ kannst du leider nicht mit reiner Geschwindigkeit punkten.

Mal ganz davon abgesehen, dass dich schon plumpe Beleidigungen aus einer fachlichen Disskusion disqualifizieren, ist ein dynamisch in C angelegtes Array trotzdem schneller.
Es kommt natürlich auch darauf an was man vor hat.
Aber du kannst mir gerne Messwerte präsentieren die deine Aussagen belegen. Ich glaube allerdings nicht das man von einem C-Bashing-Troll so etwas (unparteiisch) verlangen kann.

Zu deinem restlichen Beitrag kann ich nur folgendes sagen:

try
{
Statische Arrays sind ja wohl die reinste Platzverschwendung und somit
Resourcenverschwendung, zumal man sie wenn man es denn brauch in C++ auch einsetzen kann. Beim Vergleich C zu C++ kannst du leider nicht mit reiner Geschwindigkeit punkten.
}
catch (NullArgumentException e)
{
  e.printStackTrace();
}

C-Array und std::vector sind gleich schnell. Der Vector ist dabei aber nicht so fehleranfällig. Klarer Sieger Vector in Sachen Komfort und da er im Speed dem CArray in nix nachsteht stellt sich die Frage nicht was man einsetzen sollte.

Hier ist ein Vergleich des erzeugten Assemblercodes wo man sieht das die Zugriffe gleich schnell sind.

// Assembly code was generated by gcc 4.1.0 invoked with  g++ -O3 -S  on a x86_64-suse-linux machine.

#include <vector>

struct S
{
  int padding;

  std::vector<int> v;
  int * p;
  std::vector<int>::iterator i;
};

int pointer_index (S & s) { return s.p[3]; }
  // movq    32(%rdi), %rax
  // movl    12(%rax), %eax
  // ret

int vector_index (S & s) { return s.v[3]; }
  // movq    8(%rdi), %rax
  // movl    12(%rax), %eax
  // ret

// Conclusion: Indexing a vector is the same damn thing as indexing a pointer.

int pointer_deref (S & s) { return *s.p; }
  // movq    32(%rdi), %rax
  // movl    (%rax), %eax
  // ret

int iterator_deref (S & s) { return *s.i; }
  // movq    40(%rdi), %rax
  // movl    (%rax), %eax
  // ret

// Conclusion: Dereferencing a vector iterator is the same damn thing as dereferencing a pointer.

void pointer_increment (S & s) { ++s.p; }
  // addq    $4, 32(%rdi)
  // ret

void iterator_increment (S & s) { ++s.i; }
  // addq    $4, 40(%rdi)
  // ret

// Conclusion: Incrementing a vector iterator is the same damn thing as incrementing a pointer.

@player4245: Schade da habe ich wohl nicht ganz recht gehabt, du scheinst aber auch nicht gerade der Überflieger in Sachen C zu sein wenn du nicht weisst das carray und vector gleich schnell sind. Also bis dann Honky Monky und nicht ärgern wenn andere mehr wissen, so ist das nunmal im Leben Kleiner.

Süß. Aber deine Äußerungen lassen auch nicht grad auf besondere Kenntnisse schliessen. Und nun geh mal schön ins Bett. Es ist schon spät.

Na auf jeden Fall sind dynamische carrays nicht schneller als vector, dass du das eingesehen hast reicht mir ja schon. Es ist halt immer so schön wenn sogenannte Experten bei den einfachsten Fragen einfach Falschaussagen treffen und dann von Noobs zurechtgewiesen werden. Mit dem schönen Gefühl kann ich jetzt wirklich beruhigt schlafen gehen und weiß was mich an Fachwissen erwartet wenn ich den Namen player4245 lese

von welchem noob wurde ich bitte schön zurechtgewiesen? In dem beitrag den du meintest sprachen wir von statischen Arrays. Aber mir ist bereits aufgefallen das du eine schwierigkeit darin hast dich deutlich auszudrücken. Auf die frage wie viel Fachwissen dich hinter dem namen player4245 erwartet, kann ich nur mit sehr viel antworten

payer4245 alias Honk schrieb:

..ist ein dynamisch in C angelegtes Array trotzdem schneller.

Du hast also von statischen Arrays gesprochen, soso. Viel blabla und nix dahinter du solltest dir einen Anzug anziehen eine IT-Firma aufmachen und viel geschwollenen Bockmist erzählen und stell dann bitte auch ein paar ein die nicht einen Stock im Hintern haben dafür aber Ahnung von den Grundlagen.

So und nochmal für Dumme und ganz kurz damit es verständlich für dich ist.

Der Zugriff auf ein dynamisches carray ist in C nicht schneller als auf einen vector in C++.

Haste es jetzt kapiert?

Janjan

trojalinde schrieb:

Der Zugriff auf ein dynamisches carray ist in C nicht schneller als auf einen vector in C++.

Aber auch nicht annähernd Erwähnenswert langsamer. Die zahlreichen Vorteile der Klassen der STL sollte man nicht aufzählen müssen.

Nein das muss man nicht ernsthaft erwähnen. Ich verstehe sowie nicht warum C mit C++ verglichen wird, da man mit C++ viel höher abstrahiert und tief in den Methoden kann so low-level wie nötig programmiert werden, hier kann sogar in Extremfällen die Mischung von C++ mit C gewünscht sein. Es können also in C++ viel mehr Paradigmen abgedeckt werden als in C ohne auf Geschwindigkeit oder Systemnähe verzichten zu müssen.

Die Diskussionen C oder C++ stellt sich logisch also gar nicht wenn beide Sprachen zur Auswahl stehen und auch beherrscht werden.