Re: Covariant vectors
* Al:
I've been looking for a way to simulate covariant, const, vectors for
some time. From another thread, it seems as though vectors are supposed
to be allocated contiguously.
A std::vector's buffer is guaranteed to be contiguous.
So I wonder if the technique below is safe and legal in the general
case. In particular, I'm not sure if given virtual or multiple
inheritance, the pointers would be adjusted properly.
// Foo.hpp
struct Base { int a; };
void Foo(Base*, size_t);
// Foo.cpp
#include <iostream>
#include "Foo.hpp"
void Foo(Base* array, size_t size)
{
for (size_t i = 0; i < size; ++i)
std::cout << array[i].a << std::endl;
}
// Bar.cpp
#include <vector>
#include "Foo.hpp"
struct Derived : public Base {};
template <class VectorT>
void ApplyFoo(VectorT& v)
{
Foo(v.empty() ? NULL : &v[0], v.size());
};
void Bar()
{
std::vector<Base> bases;
std::vector<Derived> deriveds;
ApplyFoo(bases);
ApplyFoo(deriveds);
}
If unsafe,
You have undefined behavior by treating an array of Derived as an array
of Base. Derived may be larger than Base, even if it doesn't introduce
any new data members. More formally, sizeof(Derived) may be different
from sizeof(Base), which means that the offset of second (and third, and
fourth...) array element from the start of the array, can in general be
different for array of Derived than for an array of Base, so that the
indexing in Foo will end up with invalid addresses.
is there a way to make it safe?
The simplest is to make Foo a templated function taking a std::vector
argument, and let the compiler take care of avoid code duplication.
Remember, premature optimization is Evil.
But if what you absolutely want is traditional OO with virtual
functions, you can alternatively create an interface like
struct IBaseVectorRef
{
virtual ~IBaseVectorRef() {}
virtual Base const& at( size_t i ) const = 0;
virtual size_t size() const = 0;
};
template< typename T >
class BaseVectorRef: public IBaseVectorRef
{
private:
std::vector<T>* myVec;
public:
BaseVectorRef( std::vector<T>& v ): myVec( &v ) {}
virtual Base const& at( size_t i ) const
{ return myVec->at( i ); }
virtual size_t size() const { return myVec->size(); }
};
Then your Foo function would take an IBaseVector const& argument.
Also, are there other (simpler?) ways to create and use covariant
*const* containers? By const I mean that the container is not changed,
only its items are read.
In general, by creating appropriate interfaces and wrappers, as
illustrated above.
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]