Reducing the size of compiled file

**Diablo84** · 04-06-2005

Hi,

As a learning curve i wrote a very simple console program. The compiled executable for this is about 460kb. It seems that anything from a few lines of code to 100 or more is still around 460kb in size.

A friend of mine who uses Visual Studio tells me that there are two compile options, debug and release, the latter option greatly reducing the file size but does not include the behind the scenes debugging etc.

I am using Bloodshed Dev C++ 4.9.9.2, does anyone know if it is possible to achieve a similar reduction in file size with this compiler?

Thank you.

**laserlight** · 04-06-2005

For starters, you could strip the executable using strip or by passing -s to g++ (the default compiler for Dev-C++).

Besides that, you could look into optimising by passing -O1, -O2 or -Os, the latter being specifically intended to optimise for size.

You could also try reducing the size with UPX.

**Salem** · 04-06-2005

Man, this really needs to be in the FAQ
Try a board search for "executable size"
Lots to read

**Diablo84** · 04-06-2005

Thank you

Originally Posted by Salem

Try a board search for "executable size"

... and sorry, should have tried the search first :\

**joshdick** · 04-06-2005

Why is it that so many people are concerned over whether their program is 500kb or 200kb? Or are they all just embedded programmers and I don't know it?

**Diablo84** · 04-06-2005

For me it's simply a case of "out of interest", rather then it being an important issue. I couldn't understand why the executable was nearly half a meg in size when there was a relatively small amount of code.

iostream seems to be responsible judging by comments in threads returned from the search. I am wondering if there is a way to use only the things i need from the include file, for example i recall seeing something like:

using std::cout, std::cin, std::endl;

Presuming that i correct can i use that in place of:

using namespace std;

Or will that have no effect of the file size?

**joshdick** · 04-06-2005

Kudos for your curiosity.

What #include does is just copy and paste the entirety of another file into your source code. So restricting your namespace usage won't affect size because all of <iostream> will still be included in your code whether you use it or not.

I've heard of some people using pre-processor directives to prevent certain things from being included in their program, but that would mean mucking with (a) the pre-processor and (b) standard header files.

**Diablo84** · 04-06-2005

Needless to say, anything like that is beyond me at the moment. I feel better knowing what's happening to cause the large file size.

I figure it makes more sense to question everything now rather then getting a year down the line only to realise i don't understand the simple things.

Thank you for the information.

**DougDbug** · 04-06-2005

Why is it that so many people are concerned...

I think it's just a little shocking to find that 100 bytes of HelloWorld.CPP becomes 500,000 bytes of HelloWorld.EXE!

**Salem** · 04-07-2005

But after you've gotton over the initial hump at the start, it all settles down. You can add lots of code and the size of the excutable either doesn't change or just creeps up slowly in response to the increase in size of your code.

**major_small** · 04-07-2005

yeah, including <iostream> throws a whole big heap of code into your program... just as an examle, iostream #includes at least <istream> and <ostream>, <istream> includes <ios> and <limits>, <ostream> just includes <ios>.

<ios> has it's own list of includes, as follows:

Code:

#include <iosfwd>
#include <exception>     // For ios_base::failure
#include <bits/char_traits.h>   // For char_traits, streamoff, streamsize, fpos
#include <cstdio>   // For SEEK_SET, SEEK_CUR, SEEK_END
#include <bits/localefwd.h>  // For class locale
#include <bits/ios_base.h>  // For ios_base declarations.
#include <streambuf> 
#include <bits/basic_ios.h>

stopping at <ios> for the sake of sanity, I'll count how many new lines of code were just #included into mine (this will depend on your compiler's implementation):

<limits> in itself is 1,143 lines long, <ios> is 53 lines long, <istream> is 774 lines long, <ostream> is 548 lines long, and <iostream> is 80 lines long.

that makes at least 2,598 extra lines. that's not including all those other files that <ios> included, but I assure you it's thousands more than that.

however, as I said before, pretending that <ios> is the end of the train, you can see that this 'hello world' application:

Code:

#include<iostream>

int main()
{
    std::cout<<"Hello World";
}

ends up being over 2,600 lines... way over.

in other words, simply #including <iostream> brings in so many lines of code, that it inflates the size of your program in a way that you would have to write hundreds, maybe a thousand lines of code to see any significant change in the size of your code.

**7stud** · 04-07-2005

however, as I said before, pretending that <ios> is the end of the train, you can see that this 'hello world' application:

Code:

#include<iostream>

int main()
{
    std::cout<<"Hello World";
}

ends up being over 2,600 lines... way over.

Thread: Reducing the size of compiled file

Thread Tools

Search Thread

Display

Reducing the size of compiled file

Similar Threads

To find the memory leaks without using any tools

Formatting a text file...

Need Help Fixing My C Program. Deals with File I/O

gcc link external library

Encryption program