Re: C++ vs C when it comes to speed...
<mast2as@yahoo.com> wrote in message
news:1172787087.012856.47820@z35g2000cwz.googlegroups.com...
I am sure this topic has been discussed a thousand times
Yes, and the answer is the same: Neither language has
a 'speed', only specific implementations can be measured
for speed.
More below.
and I read a
few things about it today on the net. I also want to say I am trying
to start a polemic here, I am just curious and willint to learn and
improve the way I am approaching some coding issues that I have at the
moment. I use C++ programming for my work, but I am not a developper
so please be patient & tolerant in your answers ;-)
Okay for the last few days I have been struggling with mixing some C
and C++ code. I usually try to make my code C++ all the way through.
Recently because I had to implement some old C specs I decided for
some weird reasons to mix C and C++ code. Not a good thing to do I
know. Anyway I really struggled with the idea for the last few days
and spend quite some time going back & fort different versions of the
code, some had more C than C++, some where only C++. I must say that
in what I am doing, execution SPEED is important.
So today I decided to do this very simple test. I wrote the same
functionalities but one version is C++ the other C and run these
functions in a loop (10 000 times).
The C++ versions takes 5 seconds
The C version takes 1 second to execute
Since you don't show both versions, we can't know how
closely the algorithms for each match one another.
This a big difference. I realised that the difference is mostly coming
in the push_back function of the std::vector class. If I comment that
line out, the C++ code runs in 1 second. I used to find the STL lib
very very convenient but I never realised they had such an impact of
the application performances. Here is the program that I used for the
test... Maybe I am doing something wrong so I apologize in advance.
As I said in the pre-ambule of the post, I am trying to be
constructive. The feedbacks I would like to have are more:
1/ i am doing something wrong in the C++ implementation that would
slow it down.
I'll guess yes, probably, if you've done what I think in
the C version: preallocate storage (which you did not do
in the C++ code below).
2/ is it a good thing to do to use C coding in a C++ app
No, never. They are two separate, distinct languages, each
with its own 'best practices'. If you want a C program, write it
in C. If you want a C++ program, write it in C++.
if speed is
an issue
Almost without exception, the largest factor concerning time
performance is algorithms, not language or 'clever tricks'.
Note that with the C++ standard library, all the algorithm
details are not readily apparent.
and I want the app to run as fast as it could.
Thanks everyone.
// 1. comparing speed C vs C++
I suspect you're not comparing the same procedures between
the languages.
More below.
// Running on Max OS X, Power PC G4, 1.5 Ghz
// c++ -o ribparser ribparser.cpp
#include <stdlib.h>
#include <stdio.h>
#include <fstream>
#include <string>
#include <vector>
#include <ctime>
class RibParser
{
std::string m_ribFile;
public:
std::ifstream ifs;
RibParser( std::string ribFile ) : m_ribFile( ribFile )
{
char rixm[512];
try
{
ifs.open( ribFile.c_str() );
if ( ifs.fail() )
{
sprintf( rixm, "%s: Can't open\n", ribFile.c_str() );
throw( rixm );
}
}
catch( char *rixm )
{
printf( rixm );
ifs.close();
exit( 0 );
}
int ch;
In your C version, I suspect you've defined or allocated an array
whose
size can accomodate the input. If so, to more closely approximate
that
with this program, change the following line:
std::vector<char> token;
to:
std::vector<char> token(number_of_array_elements_in_C_program);
while( ! ifs.eof() )
Change the above line to:
while(ifs)
{
ch = ifs.get();
// comment this line out and the app runs in 1 second
token.push_back( ch );
}
}
~RibParser()
{
ifs.close();
}
};
static const size_t ARRAY_INCR = 8;
void RibParserC( const char *ribFile )
{
char *token;
size_t tokenByteSize = 0;
size_t tokenArraySize = ARRAY_INCR;
FILE *source;
if ( ( source = fopen( ribFile, "r" ) ) == NULL )
{
printf( "%s: Can't open\n", ribFile );
fclose( source );
exit( 0 );
}
token = (char*)malloc( ARRAY_INCR );
int ch;
do
{
ch = fgetc( source );
token[tokenByteSize] = ch;
tokenByteSize++;
if ( ( tokenByteSize % tokenArraySize ) == 0 )
{
token = (char*)realloc( token, tokenArraySize + ARRAY_INCR );
tokenArraySize += ARRAY_INCR;
}
} while ( ch != EOF );
fclose( source );
free( token );
}
int main( int argc, char ** argv )
{
time_t start, end;
time( &start );
for ( size_t i = 0; i < 10000; ++i )
{
RibParser ribParser( "/Users/jean-colas/Desktop/comment.rib" );
}
time( &end );
double diff = difftime( end, start );
printf( "seconds %f %d\n", diff, CLOCKS_PER_SEC );
time( &start );
for ( size_t i = 0; i < 10000; ++i )
{
RibParserC( "/Users/jean-colas/Desktop/comment.rib" );
}
time( &end );
diff = difftime( end, start );
printf( "seconds %f %d\n", diff, CLOCKS_PER_SEC );
return 0;
}
/////
With the small change I indicated above, I suspect you'll see
a dramatic improvement in time performance.
-Mike