Thread: Reinventing the Wheel

>> I just don't like relying too much on other people's code.
That may work in some specific cases, but there are tons of reasons to rely on existing libraries over creating your own.

This is especially true of the standard library (part of which in C++ is referred to as the STL). The interface is standardized, so you can be reasonably sure your code will work for a long time on any platform. This also means that most other developers familiar with the language can understand what the code is doing because the library is part of the language. For your own library, it is almost assured that a developer new to the code will have to learn your API from scratch.

The standard library implementations are thoroughly tested because so many people use them. This contrasts with your own library that gets far less testing and will almost always have far more bugs. In some cases you can optimize library functionality for specific tasks you need, but the standard library implementations have all been highly optimized as well, and in many cases this will still be better than your own.

It seems to be a natural tendency to want to write your own solution rather than search for an existing one, but in the end the effort is much greater and the reward is smaller if you do. This is true even for non-standard libraries. In some cases you will find that there are no widely available and tested libraries for a specific task, and in those cases writing your own makes sense.

Your line probably stops at the C standard library. If you are programming in C++, though, that line should at least extend to the C++ standard library, and probably a lot further.

Just had a quick look at some STL docs.

Vectors? WTF's wrong with an array? I mean, seriously, it's built into the language. Oh, it says it 'eliminates the chore of dynamic memory allocation'.

I've never had a problem with new and delete - they take about 4 seconds to type. Hardly a 'chore'.

I imagine there's a string one too, when strings are already about as simple as it gets.

Ironic, really, as this seems like the textbook definition of reinventing the wheel for the sake of it.

That same attitude can be applied to strcpy. How hard is it to write a loop? That's about 8 seconds. But that is also part of the standard library because it is a commonly used task, it is encapsulated in a function so there is no chance for the user to make a mistake and cause a bug by doing it themselves, and it can be optimized by the library implementors to do better than a simple loop.

Have you ever had memory leaks? Have you ever had an error where you deleted something twice? Have you ever tried to resize a dynamic array? Finding and fixing memory leaks is a chore. Finding memory related bugs in general is a chore. Resizing a dynamic array is a chore. The vector class eliminates those chores.

Why would you ever need a nail gun when a hammer will do just fine? Perhaps if you're building a house and hammering in thousands of nails, you'll think differently.

If you prefer C, that's fine, but I think your attitude about C++ is coming from a lack of experience with it.

I suppose you have to draw the line somewhere. But arrays are built in. It'd be like writing your own add () function, instead of using the + operator (or something). And a string is just an array anyway, so that's equally as futile IMO.

Don't get me wrong, I can see the point of stuff like linked lists but why replace strings and arrays?

And I do tend to pick and choose what elements of C++ I use, but I'm perfectly comfortable with that.

>> why replace arrays?
The vector is not a replacement for arrays, it is a replacement for dynamic arrays.

>> why replace strings?
Let's say you are creating a string that holds a bunch of formatted data that you plan to either write out to a file or use directly from the string. You build that string from the data in your app by adding to it (e.g. in a csv or xml format). You don't know how much data there will be, there could be only a little, there could be a lot.

How do you handle that with a C style string? You'd have to use dynamic memory allocation since the string could be huge. But you don't want to over allocate in case there isn't much data to handle. So you allocate something small to start off, and use strcat to append to the string as you go. But then what if the array fills up, you have to create a new array with a larger size and copy the contents from the old array to the new one, then continue concatenating. Just writing this code is a chore, let alone getting it right.

For the string class it would be as simple as:

Code:

std::string my_string;
while (more_data())
{
  my_string += get_data();
}

All that other stuff is handled automatically.

I'd use a linked list in that case.

Of course, I'd code it myself, too...

A linked list of chars?

Originally Posted by samGwilliam

I'd use a linked list in that case.

Of course, I'd code it myself, too...

Excellent idea. Now instead of using 1 byte per character, you use several times as much. Four bytes or so for the link pointer. One byte for the character itself. And potentially eight or more bytes for memory allocator bookkeeping for each allocated node.

Congrats, your method of increasing memory usage by a factor of 13x has truly impressed me.

Not of chars. Clearly I wasn't reading the posts properly. I'd just use a bog-standard array, obviously.

But if a flexible, dynamic method of storage was really that important then I'd use a linked list.

What of it?

Originally Posted by ChaosEngine

Really? let's have a look at a piece of code then.

Code:

void SomeFunc(void)
{
    int *x = new int[100];

    SomeOtherFunc(x);


    delete[] x;
}

we've allocated some memory, called a function, deleted our memory like a responsible programmer and all is happy in the valleys, right?

but let's have a look at SomeOtherFunc()

Code:

struct big
{
    double d[100000];
}

void SomeOtherFunc(int *p)
{
    for (int i = 0; i < 200; i++)
    {
         p[i] = i;
    }

    big *reallyBig = new big[100000];

    // some code

    delete[] big;    
}

ok this code has 2 problem (apart from not doing anything useful). The first is that we've overwritten the bounds of our array. Not such a big deal, we should've passed in the size of the array, but it wouldn't necessary with a vector (which knows it's size).

The second is a bit trickier. You see, there's a very good chance that we don't have enough memory to allocate reallyBig. On a standards-compliant compiler, that means an std::bad_alloc exception will be thrown. Now we're in really big trouble since x will not be deleted.

ok, but we can catch the exception! so let's rewrite SomeFunc

Code:

void SomeFunc(void)
{
    int *x;
    try
    {
         x = new int[100];

         SomeOtherFunc(x);

         delete[] x;
     }
     catch (std::bad_alloc &)
     {
         delete[] x;
     }
}

ahh, much better. except, we've swallowed the exception so the caller of SomeFunc doesn't know it failed. No problem, let's rethrow the exception.

Code:

void SomeFunc(void)
{
    int *x;
    try
    {
         x = new int[100];

         SomeOtherFunc(x);

         delete[] x;
     }
     catch (std::bad_alloc &)
     {
         delete[] x;
         throw;
     }
}

phew! dodged that bullet. except now another coder has changed SomeOtherFunc()!

Code:

struct big
{
    double d[100000];
}

void SomeOtherFunc(int *p)
{
    for (int i = 0; i < 200; i++)
    {
         p[i] = i;
    }

    big *reallyBig = new big[100000];

    if (!ConnectToInternet())
    {
         throw Unconnected();
    }

    delete[] big;    
}

ahh crap, now we have to add another catch clause. That sucks. To hell with that, let's just catch all exceptions.

Code:

void SomeFunc(void)
{
    int *x;
    try
    {
         x = new int[100];

         SomeOtherFunc(x);

         delete[] x;
     }
     catch (...)
     {
         delete[] x;
         throw;
     }
}

or instead we could just write

Code:

void SomeFunc(void)
{
    std::vector<int> x(100);

    SomeOtherFunc(x);

}

struct big
{
    double d[100000];
}

void SomeOtherFunc(std::vector<int> & p)
{
    for (int i = 0; i < p.size(); i++)
    {
         p[i] = i;
    }

    std::vector<big> reallyBig(100000);

    if (!ConnectToInternet())
    {
         throw Unconnected();
    }

}

I know which one is safer. I know which one is cleaner. I know which one is more extensible and I know which I'd prefer.

Feel free to keep using dynamic arrays.

and while I'm at it...

That statement is completely backwards. I don't like relying on my own code. I much prefer to use some existing code that's been tested and documented.

did it take you long to write your own os? your own compiler? browser? ok maybe that's pushing it, but have you written your own versions of cout/printf? ever written a gui library?

I didn't read a single line of that (and I'm not going to), but it's entertaining to see just how much I've gotten under your skin!!