C++ Programmgröße

[Grugeschu]

Hallo ich habe eine Frage bezüglich der Größe von Programmen.

Also ich habe mal nachgeschaut wie die Größe der Programme ist.
Also hab ich was simples mit C++ erstellt und was Simples mit Pascal.

Also ich hab ein Pascalprogramm mit 98 zeilen Code zur Berechnung von mehreren Sachen.
Erstellt mit: Dev Pascal
Sourcegröße 4KB
Kompiliert 28,5 KB

Ein C++ Programm 26 Zeilen Code.
Erstellt mit:wxDev C++
Sourcegröße: 318 byte (keine Clustergrößen)
Kompiliert: 476 KB


Also in dem C++ Programm sind nur Integerwerte verbaut. Im Pascal Programm sind viele Datentypen verwendet (real string integer usw)
Aber warum is die Binary von dem C++ so groß?

Es kann ja nicht sein das der Compiler da mehr einbaut oder ?
OK wenn der Präpozessor die ganze iostream.h einbidet kommt weitaus mehr Code zusammen aber Pascal hat aber auch seine Standardbibliotheken und bindet wohl auch mehr ein als das was ich das schreibe.

Weiß jemand also woran es liegen kann, dass Programm so groß ist, vllt Kompiler oder sonst was?

 

[Spartaner117]

Ich würd sagen, das ist sehr ungewöhnlich.

Ich hab bei meinem aktuellen Programm ~1100 Zeilen (Dazu noch ein Haufen includes),
und der Compiler spuckt Debug: 150kb/Release 64 KB aus.
Ich hab VS .NET 03, aber ich glaub kaum dass so ein großer Unterschied am Compiler festzumachen ist.

Blöde Frage, aber hast du als Release compiliert?

Die 26 Zeilen könntest du zur Not ja auch hier posten.
Sieht aber eigendlich nach z.B. einer falschen Projekteinstellung aus.

 

[ph4nt0m]

Handelt es sich bei deinen Programmen und Anwendungen mit grafischer Oberfläche? Der Hinweis auf wxDev C++ bringt mich zu der Annahme. Denn dann könnte es durchaus sein, dass du in deinem Programm das wxWidgets Framework verwendest und der Linker dir die benötigten Dlls statisch dazu bindet.

ph4nt0m

 

[7H3 N4C3R]

Das liegt dadran, dass die gesamte Standard-Lib angezogen wird. Wenn man die weglässt und dagegen die auf dem System vorhandenen C(++)-Standard-Bibliotheken benutzt, kommt man auf wenige KB üblicherweise. Sonst kommen schon ein paar 100KB hinzu, wenn man eine Standalone-Anwendung baut.

Weitere Faktoren sind z.B. wie gut der Compiler optimiert, ob Optimierung überhaupt eingeschaltet ist, wie der Compiler optimiert (auf Geschwindigkeit oder Größe), ob Debugsymbole enthalten sind.

 

[Grugeschu]

hmmm joa habe cout und cin befehle anstatt mit using namespace std; mit std::cout und std::cin gemacht aber das mach keinen unterschied bei der kompilierten datei.

 

[ph4nt0m]

Dass der Effekt dabei ausbleibt, war zu erwarten. Wie sieht es denn jetzt aus: Reden wir hier von GUI-Anwendungen (mit wxWidgets?) oder meinst du ganz normale Konsolenprogramme?

ph4nt0m

 

[Grugeschu]

ne is alles auf konsolenbasis. Also cout und unter Pascal uses crt; und writeln.

 

[muckelzwerg]

Wäre es bei 26 Zeilen nicht einfacher das Programm hier mal zu posten, anstatt es zu beschreiben?
Dann könnten es Interessierte auch selbst kompilieren.

-- -- muckelzwerg

 

[FreddyMercury]

Dev-c++ (bzw. gcc) macht standardmaessig enie DEBUG VErsion von deinem Programm. Wenn du auf Release stellst, ist deine Version auch kleiner. Zudem kannst du noch Optimierungen vornehmen lassen, die deine Binary groesser oder klenier machen.

 

[XunnD]

Sobald eine wx-lib eingebunden wird, bläht sich die EXE auf!

Riecht alles nach static linking, was die großen Files erzeugt...

 

[gruffi]

@Kartoffel200
Ich nehme mal an, wir sprechen hier vom Release Build?
Leider ist der GCC bezüglich IO Streams immer noch sehr ineffizient und die Executable wird unnötig aufgebläht. Dagegen lässt sich momentan nichts anderes machen, als auf zukünftige Versionen zu warten. Ausser du wechselst zu printf und Konsorten. Aber die Nachteile sollten bekannt sein.
Ein Vergleich mit dem MSC verdeutlicht das Dilemma. Ein simples "Hello world" lässt eine Executable von weniger als 100 KB entstehen, mit dem GCC sind das 500 KB.
Und wie schon erwähnt wurde, weitere Bibliotheken wie wxwidgets können die Executable noch weiter aufblähen.

 

[asdfman]

Ein simples "Hello world" lässt eine Executable von weniger als 100 KB entstehen, mit dem GCC sind das 500 KB.

#include <iostream>
using namespace std;

int main() {
        cout << "Hello, World!" << endl;
        return 0;
}

g++ -o hello hello.cpp
5756 bytes hier.

€: Meine Version von GCC hier ist 4.2.3, falls das relevant ist.

 

[CoolHandLuke]

Ha, interessant: das gleiche Programm mit der gleichen GCC-Version 4.2.3 erzeugt bei mir ein ausführbares Programm mit einer Größe von 8841 Bytes!

 

[gruffi]

@asdfman
Getestet auf welchem System?

Bei mir ist es wie bei Kartoffel200 Windows XP SP2, allerdings Pro. Compiler ist GCC 4.3.0 (TDM-1 MinGW). Dateigrösse beträgt 480256 Bytes. Aber auch nur mit strip (-s). Ohne sind es satte 2,7 MB.

Das printf Äquivalent

#include <cstdio>

int main()
{
	printf("Hello, World!\n");
	return 0;
}

begnügt sich dagegen mit gerade mal 4608 Bytes.

 

[7H3 N4C3R]

5756 bytes hier.

8841 Bytes!

Macht mal ein ldd auf's Executable und summiert die Größe der angezogenen Bibliotheken drauf Die Ergebnisse wären nochmal interessant und sollten sich in der Größenordnung der anderen befinden.

 

[CoolHandLuke]

linux-gate.so.1 => (0xb7f29000)
libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0xb7e1c000)
libm.so.6 => /lib/tls/i686/cmov/libm.so.6 (0xb7df7000)
libgcc_s.so.1 => /lib/libgcc_s.so.1 (0xb7deb000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7c9c000)
/lib/ld-linux.so.2 (0xb7f2a000)

 

[7H3 N4C3R]

Mit Größen der Files bitte Oder mit -static linken.

 

[muckelzwerg]

layer0@navi_ultramobile ~ $ g++ -Wall -o hello hello.cpp -static
layer0@navi_ultramobile ~ $ ls -l hello
-rwxr-xr-x 1 layer0 layer0 581714 17. Apr 22:26 hello
layer0@navi_ultramobile ~ $ g++ -Wall -o hello hello.cpp
layer0@navi_ultramobile ~ $ ls -l hello
-rwxr-xr-x 1 layer0 layer0 7009 17. Apr 22:27 hello

(Mit der Summe der Libs passt es nicht. Die liegt höher)

-- -- muckelzwerg

 

[IceMatrix]

das problem sind hier statische bibliotheken. abhängig vom linker und dessen einstellung kann es vorkommen, dass große teile von bibliotheken statisch mit reingelinkt werden, obwohl sie zum teil gar nicht aufgerufen werden. binutils (ld) ist mir da in böser erinnerung. versuche einfach mal das programm aus der befehlszeile zu kompilieren, dann kannste leichter entscheiden, zu welchen bibliotheken überhaupt gelinkt werden soll. n c++ programm kann locker unter 32kb groß werden!!

 

[cplusplus]

Mit strip kann man executables von unnötigen Bytes und Symbolen entledigen. Das Tool kommt mit den binutils. Der größte Unterscheid in der Größe von executables dürfte aber beim Linken liegen (statisch vs dynamisch).

Edit: strip wurde oben schon erwähnt, sorry.