derived class (vector): is this a bad idea?

Question

I am about to "create" my own vector class for a library I am writing. I won't really create a vector class from scratch, but just use std::vector as a parent class and add some stuff to my derived vector class.

Now, that said, I need a bit of advice. My questions are:

1) Is it a bad idea to call my derived class vector (inside of another namespace, of course)? What kind of conflicts will I have in this case?

2) I want to overload the math operators to be able to add vectors, multiply vectors by constants etc. This is actually the reason why I decided to build a vector class on top of std::vector. I could, however, overload the math operators for std::vector directly and save myself the trouble of creating (yet another...) vector class -- but is this a bad idea?

3) I would very much like to inherit the constructors from std::vector, but I am having lots of trouble getting this done without compiler errors. Could someone please provide me with a concrete example showing me how can this be done?

Thank you!

Answer 1

I would discourage you from doing that. If you need a new container, just embed (or inherit privately from) std::vector<> rather than inheriting publicly from it.

Concerning your questions:

1) Is it a bad idea to call my derived class vector (inside of another namespace, of course)? What kind of conflicts will I have in this case?

As long as neither you nor any of your clients will import both the std namespace and your namespace through using directives, I do not see particular problems with this.

2) I want to overload the math operators to be able to add vectors, multiply vectors by constants etc. This is actually the reason why I decided to build a vector class on top of std::vector. I could, however, overload the math operators for std::vector directly and save myself the trouble of creating (yet another...) vector class -- but is this a bad idea?

Yes, this is a bad idea. If you created overloads of the math operators for std::vector, you could not create them in the namespace where std::vector belongs. By ADL, a global operator + is likely to be found in that namespace, even if not suitable. If that's the case, your operator + won't even be looked up, and you will get a compiler error.

3) I would very much like to inherit the constructors from std::vector, but I am having lots of trouble getting this done without compiler errors. Could someone please provide me with a concrete example showing me how can this be done?

In C++11, you could use inherited constructors. For instance:

#include <vector>

template<typename T, typename Allocator = std::allocator<T>>
class myvector : public std::vector<T, Allocator>
{
    using typename std::vector<T, Allocator>::vector;
};

#include <iostream>

int main()
{
   std::vector<int> vi { 1, 2, 3, 4, 5};

   // Uses inherited constructor
   myvector<int> v(vi.begin(), vi.end());

   for (auto i : v) { std::cout << i << " "; };
}

Here is a live example of this working with GCC 4.8.0 (beta), which supports inherited constructors.

Answer 2

First, be aware that you can obfuscate your inheritance if you like. Use private inheritance, and then make all the functions of vector available with using statements. It's still a fair amount to type, since vector has a lot in it, but it's nothing like as much as explicitly delegating every function and it prevents the usual objections to inheritance, that people will accidentally slice your derived class and/or delete it using the wrong type when there's no virtual destructor. Not that anyone should be deleting vector anyway.

1) using the same name from namespace std is not inherently a problem (that's what namespaces are for, after all), but it might be confusing for readers sometimes. They might just assume you've done using std::vector; somewhere. This is their own fault, but if you can think of another suitable name then there's nothing to be gained from punishing your readers for their mistakes.

2) You can overload operators for standard classes, but not in the std namespace. This leaves a question what scope you should overload them in. Generally you don't want to put stuff into the global scope in a header file, but you could for example put them in a namespace called vector_arithmetic and then put using namespace vector_arithmetic; into each scope from which you want to use them. Just because you can do it doesn't mean it's wise -- readers expect to know what operators are available for common classes like vector, and changing the set of available operators might frighten and disturb them.

3) If you don't have C++11 constructor inheritance, you cannot inherit constructors. Instead you need to laboriously write out your own constructors that take the right parameters and call the appropriate base class constructor in the initializer list. The standard (or other documentation) will tell you all the constructor signatures you need. Take especial care with the templated constructor and note that the constructors aren't the same in C++03 and C++11.

Finally, consider just writing some free functions:

template <typename T>
T sequence_add(const T &lhs, const T &rhs) {
    if (rhs.size() != lhs.size()) throw std::logic_error("size mismatch");
    T result(lhs.size());
    std::transform(lhs.begin(), lhs.end(), rhs.begin(), result.begin(),
        std::plus<typename T::value_type>()
    );
    return result;
}

std::vector<int> i,j;
std::vector<int> k = sequence_add(i,j);

and so on. If operator overloads are going to cause confusion then they're generally not worth it.

Answer 3

1) Write your own vector under your namespace. But, try to not derive from STLs.

2,3) Forget std::vector, write your own methods and operators.

Also, you can wrap std::vector in your new class and write interfaces to manipulate it.