Linked by anonymous on Tue 29th Mar 2011 16:05 UTC
General Development The C++ programming language is about to be updated, as the ISO steering committee for the language has approved the final draft specifying its next version. The ISO/IEC Information Technology Task Force will review the steering committee's Final Draft International Standard will review and, barring any complications, publish the draft later this year. It will be known as C++ 2011.
Thread beginning with comment 468349
To view parent comment, click here.
To read all comments associated with this story, please click here.
MORB
Member since:
2005-07-06

Right, so when the speed of linked lists in C vs C++ is the same, however the code bloat due to STL is 200K extra (and grows in proportion to the number of linked list objects in use), you call this a bad excuse not to use STL?

You're not stating on which compiler, with which compilation options (debug builds don't count) or even how you measure this 200k difference (if you don't strip symbols from the binary it's obviously going to be a lot bigger, but it doesn't count either).

Now take this code size overhead and multiple by the number of different containers in use and the number of container instances and you end up with a hefty bloat.


You don't have 200k of container code implementation, that's simply wrong. And don't tell me "prove it" when you didn't even provide any detail as to the origin of that "200k" overhead claim.

Also, either it depends on the number of different container types (non-inline code) or the number of times containers are used (inline code).

Interestingly, a plain C container implementation would either involve inline code, or functions and their overhead would scale similarly.

Bad excuse? You betcha.

Reply Parent Score: 3

rom508 Member since:
2007-04-20

Bad excuse? You betcha.


Use STL linked list for storing and traversing struct01{int n1, int n2;} data type, note executable size. Then create 10 linked lists, storing struct01{int n1; int n2;}, struct02{int n1; int n2;}, ... struct10{int n1; int n2;} and note executable size.

Reply Parent Score: 1

MORB Member since:
2005-07-06

Done.

Here is the first test as I compiled it, on a 32 bits kubuntu linux using gcc 4.4:

#include <iostream>
#include <list>

struct struct01{ int n1; int n2; };

int main( int a, char** b )
{
std::list< struct01 > list01 { {1,2}, {2,3}, {2,3}, {2,3} };

for( auto it = list01.begin(); it != list01.end(); ++it )
std::cout << "derp\n";

return 0;
}


I've initialized the list with stuff and printed out something in the loop to make sure it's not optimized away for having no side effect. This gives additional overhead but still a far cry from what you claim, so I don't care.

Compiled with gcc 4.4.1 in i386 code, with optimization:
g++ derp.cpp -o derp -O3 -std=c++0x

The binary weights a whopping 7816 bytes. After striping (with strip -s), it's 5608 bytes.

And now for the second test:

#include <iostream>
#include <list>

struct struct01 { int n1; int n2; };
struct struct02 { int n1; int n2; };
struct struct03 { int n1; int n2; };
struct struct04 { int n1; int n2; };
struct struct05 { int n1; int n2; };
struct struct06 { int n1; int n2; };
struct struct07 { int n1; int n2; };
struct struct08 { int n1; int n2; };
struct struct09 { int n1; int n2; };
struct struct10 { int n1; int n2; };

int main( int a, char** b )
{
std::list< struct01 > list01 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct02 > list02 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct03 > list03 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct04 > list04 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct05 > list05 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct06 > list06 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct07 > list07 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct08 > list08 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct09 > list09 { {1,2}, {2,3}, {2,3}, {2,3} };
std::list< struct10 > list10 { {1,2}, {2,3}, {2,3}, {2,3} };

for( auto it = list01.begin(); it != list01.end(); ++it )
std::cout << "derp\n";
for( auto it = list02.begin(); it != list02.end(); ++it )
std::cout << "derp\n";
for( auto it = list03.begin(); it != list03.end(); ++it )
std::cout << "derp\n";
for( auto it = list04.begin(); it != list04.end(); ++it )
std::cout << "derp\n";
for( auto it = list05.begin(); it != list05.end(); ++it )
std::cout << "derp\n";
for( auto it = list06.begin(); it != list06.end(); ++it )
std::cout << "derp\n";
for( auto it = list07.begin(); it != list07.end(); ++it )
std::cout << "derp\n";
for( auto it = list08.begin(); it != list08.end(); ++it )
std::cout << "derp\n";
for( auto it = list09.begin(); it != list09.end(); ++it )
std::cout << "derp\n";
for( auto it = list10.begin(); it != list10.end(); ++it )
std::cout << "derp\n";

return 0;
}


It compiles to a vastly bloated binary of 11913 bytes. After striping, it's 9704 bytes.

Reply Parent Score: 4