Re: C++ is Slow?
nw <new@soton.ac.uk> wrote:
I'm constantly confronted with the following two techniques, which I
believe often produce less readable code, but I am told are faster
therefore better. Can anyone help me out with counter examples and
arguments?
1. The STL is slow.
More specifically vector. The argument goes like this:
Vector is no slower than manual dynamic array allocation. As for the
other containers, I once challenged a office mate (a C programmer who
had extensive knowledge of assembler) to write a double link list class
that was faster than the std::list implementation that came with the
compiler. He claimed he could do it because he was able to optimize his
list to work specifically with the data we were storing. He insisted
that the std::list couldn't possibly be as fast because it was "too
general". Despite his best efforts, std::list was a full 5% faster than
his code... using his own test suite!
"Multidimensional arrays should be allocated as large contiguous
blocks. This is so that when you are accessing the array and reach the
end of a row, the next row will already be in the cache. You also
don't need to spend time navigating pointers when accessing the array.
So a 2 dimensional array of size 100x100 should be created like this:
const int xdim=100;
const int ydim=100;
int *myarray = malloc(xdim*ydim*sizeof(int));
and accessed like this:
myarray[xdim*ypos+xpos] = avalue;
Is this argument reasonable? (Sounds reasonable to me, though the
small tests I've performed don't usually show any significant
difference).
To me this syntax looks horrible, am I wrong? Is vector the wrong
container to use? (My usual solution would be a vector<vector<int> >).
I wouldn't use a vector<vector<int> > unless I needed a ragged array.
Even then, I would likely burry it in a class so I can change the
container without having to edit the entire code base.
Look at the Matrix class in the FAQ. Something like this:
template < typename T >
class?Matrix?{
public:
???Matrix(unsigned?rows,?unsigned?cols) :
cols_( cols ),
data_( rows * cols )
{ }
???T&?operator()?(unsigned?row,?unsigned?col)
{
// might want to consider error checking.
??? return?data_[cols_*row?+?col];
}
const T& operator()?(unsigned?row,?unsigned?col)?const;
{
// might want to consider error checking.
??? return?data_[cols_*row?+?col];
}
// other methods to taste
private:
???unsigned?cols_;
???vector<T>?data_;
};
It's very simple to use:
Matrix<int> myarray( xdim, ydim);
accessed like:
myarray( xpos, ypos ) = avalue;
?
2. iostream is slow.
I've encountered this is work recently. I'd not considered it before,
I like the syntax and don't do so much IO generally... I'm just now
starting to process terabytes of data, so it'll become an issue. Is
iostream slow?
This I don't know about. I don't deal with the iostream library much.