3. C++ Overhead gegenüber C

C++ Overhead gegenüber C

  • V

    Daniel E. schrieb:

    volkard schrieb:

    'Meine' C++-Programme sind besser als 'meine' C-Programme.

    Schreib' einen C++-Compiler. 🙂

    was hat das damit zu tun? ich brauch doch keinen, denn bei mir sind die c++-programme ok. irgendwie sind alle deine kommentare völlig unverständlich.

    0
  • D

    Floh schrieb:

    versuch doch mal ein C-Programm als C und als C++ zu kompilieren und schau was rauskommt. ich wette mit dir das macht performancetechnisch keinen unterschied.

    Na dann. Mal ein schneller Hack, von heute Nachmittag. [Achtung Unix!]

    $ gcc32 -O2 ip.c -o c && g++32 -O2 ip.c -o cpp && ls -l c cpp
-rwxr-xr-x  1 de  de    5188 Jul 14 19:42 c
-rwxr-xr-x  1 de  de  191311 Jul 14 19:42 cpp
$ time ./c ; time ./cpp # gibt nur die Fehlermeldungen aus, sollte von daher weitestgehend uninteressant sein
Usage: ./c <iface>

real    0m0.005s
user    0m0.004s
sys     0m0.001s
Usage: ./cpp <iface>

real    0m0.008s
user    0m0.000s
sys     0m0.001s
$  strip c cpp ; ls -l c cpp
-rwxr-xr-x  1 de  de   3528 Jul 14 19:45 c
-rwxr-xr-x  1 de  de  27544 Jul 14 19:45 cpp
$ cat ip.c

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <net/if.h>
#include <arpa/inet.h>

int main(int argc, char** argv)
{
     struct ifreq ifa;
     struct sockaddr_in *i;
     int fd;

     if(argc < 2) {
          fprintf(stderr, "Usage: %s <iface>\n", *argv);
          return EXIT_FAILURE;
     }
     ++argv;
     if (strlen(*argv) >= sizeof ifa.ifr_name) {
          fprintf(stderr, "%s is to long\n", *argv);
          return EXIT_FAILURE;
     }

     strcpy(ifa.ifr_name, *argv);

     if((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
          perror("socket");
          return EXIT_FAILURE;
     }

     if(ioctl(fd, SIOCGIFADDR, &ifa)) {
          perror("ioctl");
          return EXIT_FAILURE;
     }

     i = (struct sockaddr_in*)&ifa.ifr_addr;
     puts(inet_ntoa(i->sin_addr));

     return 0;
}

    Zugegeben, objektiv ist was anderes.

    Artchi: wem Du glaubst und wen Du beleidigst ist mir recht schnuppe. Aber ich will dir kein Buch verkaufen.

    0
  • V

    Daniel E. schrieb:

    Na dann. Mal ein schneller Hack, von heute Nachmittag. [Achtung Unix!]

    jo, mit msvc nicht nachvollziehbar.

    0
  • B

    Bei mir (gcc 3.2.2) ist c 5758 und cpp 5971 Bytes groß (ungestrippt.) Gestrippt 3764 bzw. 3948.

    EDIT: sorry, das ist ohne -O2 gewesen. Mit wäre cpp 5909 groß. c teste ich nicht nochmal.

    0
  • ?

    achtung: unix-unbegabter!

    was sagt mir dein benchmark? zähl ich die milisekunden zusammen? dann ist c++ um eine schneller.

    0
  • B

    nein, die kann man nicht zusammenzählen. "real" ist die Zeit aus der realen Welt, "sys" und "user" die im Kernel bzw. Userspace verbrachte Prozessorzeit. Die Messungen sind in der Größenordnung aber bullshit, wenn C für das eine write() 4ms braucht, braucht C++ die auch.

    0
  • R

    @Daniel E.

    hmm, mal ein paar tests von mir (ich hab mal dein Programm genommen)

    > uname -a
Linux debian01 2.4.20 #10 Son Apr 6 12:04:45 CEST 2003 i686 GNU/Linux
> gcc -v
[...]
gcc version 3.2.3 20030415 (Debian prerelease)
> gcc -O3 -o demo_cc demo.cc
> g++ -O3 -o demo_++ demo.cc
> gcc -O3 -o demo_c demo.c
> ls -lh demo_c demo_cc demo_++
-rwxr-xr-x    1 ki     us         5,0K 2003-07-14 20:18 demo_++
-rwxr-xr-x    1 ki     us         4,9K 2003-07-14 20:18 demo_c
-rwxr-xr-x    1 ki     us         4,9K 2003-07-14 20:17 demo_cc
> time ./demo_++
Usage: ./demo_++ <iface>

real    0m0.008s
user    0m0.010s
sys     0m0.000s
> time ./demo_cc
Usage: ./demo_cc <iface>

real    0m0.002s
user    0m0.000s
sys     0m0.000s
> time ./demo_c 
Usage: ./demo_c <iface>

real    0m0.003s
user    0m0.000s
sys     0m0.000s

    Wie es aussieht ist die C++ Stdlib das Problem (bei der GCC). (Der Zeitunterschied zwischen demo_c und demo_cc ist innerhalb der Messtolleranz)

    0
  • A

    Warum testet ihr COMPILER? Ich hab gedacht es geht um C und C++... irgendwie unsinnig, da man unter VC++ nur EINEN Compiler sowohl für C als auch C++ habe.

    Daniel! Du testest GCC und GPP (oder wie sich der C++-GNU schimpft)... also hast du hier zwei völlig verschiedene Compiler-Implementierungen getestet, und nicht zwei Sprachen. Sorry, das ist Unfug!

    0
  • D

    Artchi schrieb:

    Warum testet ihr COMPILER? Ich hab gedacht es geht um C und C++... irgendwie unsinnig, da man unter VC++ nur EINEN Compiler sowohl für C als auch C++ habe.

    Hast Du ganz, ganz fein beobachtet, aber keiner außer dir kann in den Sprachbeschreibungen die Seite finden, wo draufsteht, wie lange so Dinger zum ausführen dauern. Darum vergleichen wir einfach mal mit einer gängigen Implementierung und versuchen herauszufinden, was da alles so abgeht.

    irgendwie unsinnig, da man unter VC++ nur EINEN Compiler sowohl für C als auch C++ habe.

    Das ist vielleicht ein Programm, trotzdem sind es 2 Compiler (also Compiler für zwei grundauf verschiedene Sprachen). Ein C-Programm muss kein C++-Programm sein, kann aber.

    Du testest GCC und CPP...

    Jaja. 'cpp' ist (wenn Du nicht das von mir erstellte Binary meinst) ein Präprozessor. Damit tue ich mich schwer, C-Quelltext zu übersetzten.

    Sorry, aber Unfug!

    Ja, das ist eine schöne Zusammenfassung deines Artikels.

    An all die anderen: Danke für eure Mitmessungen (insbesondere kingruedi mit dem Hinweis auf die Bibliothek). -- Und ja, der 'time'-Benchmark ist für diese Ausgabe absolut sinnfrei.

    0
  • T

    archi...wie willst du die sprache sonst testen? es hängt doch alles an der jeweiligen implementation...und die verkörpert nun mal der compiler...oder willst du die grammatik der sprache testen...

    ne ne...aber um nen ordentlichen benchmark zu machen müssten ein paar grundvorraussetzungen gegeben sein 🙂

    0
Anmelden zum Antworten