template vector, incomplete type error

[imutate]

Hi,
I am migrating some std::vectors to use a template instead, but I get
an incomplete type error in a struct declaration.

#include <vector>

template < typename T >
class Vec : public std::vector< T {
public:
Vec():Vec<T>() { }
Vec( int s ) : std::vector<T>( s) { }
T& operator[](int i) { return at(i); }
const T& operator[](int i ) const { return at(i); }
};
typedef Vec<doublevecdb l;
typedef Vec<vecdblmatdb l;
#include "matvec.h"
// that is it above

typedef vecdbl memvec;

struct felt
{
...
memvec m; // <- incomplete type error

[Greg Comeau]

In article <11************ **********@c28g 2000cwb.googleg roups.com>,
<im*****@hotmai l.co.ukwrote:

>Hi,
I am migrating some std::vectors to use a template instead, but I get
an incomplete type error in a struct declaration.

#include <vector>

template < typename T >
class Vec : public std::vector< T {
public:
Vec():Vec<T>() { }
Vec( int s ) : std::vector<T>( s) { }
T& operator[](int i) { return at(i); }
const T& operator[](int i ) const { return at(i); }
};
typedef Vec<doublevecdb l;
typedef Vec<vecdblmatdb l;
#include "matvec.h"
// that is it above

typedef vecdbl memvec;

struct felt
{
..
memvec m; // <- incomplete type error

I don't understand Vec():Vec<T>() and probably you're compiler
doesn't either eventually makeing Vec<Tincomplete classes
because of that problem.
--
Greg Comeau / 20 years of Comeauity! Intel Mac Port now in alpha!
Comeau C/C++ ONLINE == http://www.comeaucomputing.com/tryitout
World Class Compilers: Breathtaking C++, Amazing C99, Fabulous C90.
Comeau C/C++ with Dinkumware's Libraries... Have you tried it?

[Greg Comeau]

In article <ef**********@p anix1.panix.com >,
Greg Comeau <co****@comeauc omputing.comwro te:

>In article <11************ **********@c28g 2000cwb.googleg roups.com>,
<im*****@hotmai l.co.ukwrote:

>>Hi,
I am migrating some std::vectors to use a template instead, but I get
an incomplete type error in a struct declaration.

#include <vector>

template < typename T >
class Vec : public std::vector< T {
public:
Vec():Vec<T>() { }
Vec( int s ) : std::vector<T>( s) { }
T& operator[](int i) { return at(i); }
const T& operator[](int i ) const { return at(i); }
};
typedef Vec<doublevecdb l;
typedef Vec<vecdblmatdb l;
#include "matvec.h"
// that is it above

typedef vecdbl memvec;

struct felt
{
..
memvec m; // <- incomplete type error

I don't understand Vec():Vec<T>() and probably you're compiler
doesn't either eventually makeing Vec<Tincomplete classes
because of that problem.

Also on a different aspect: std::vector was not written to be
derived from.
--
Greg Comeau / 20 years of Comeauity! Intel Mac Port now in alpha!
Comeau C/C++ ONLINE == http://www.comeaucomputing.com/tryitout
World Class Compilers: Breathtaking C++, Amazing C99, Fabulous C90.
Comeau C/C++ with Dinkumware's Libraries... Have you tried it?

[Kai-Uwe Bux]

im*****@hotmail .co.uk wrote:

#include <vector>

template < typename T >
class Vec : public std::vector< T {
public:
Vec():Vec<T>() { }

Vec() : std::vector<T>( ) {}

Vec( int s ) : std::vector<T>( s) { }
T& operator[](int i) { return at(i); }

& operator[](int i) { return this->at(i); }

const T& operator[](int i ) const { return at(i); }

const T& operator[](int i ) const { return this->at(i); }

};
typedef Vec<doublevecdb l;
typedef Vec<vecdblmatdb l;
#include "matvec.h"
// that is it above

typedef vecdbl memvec;

struct felt
{
..
memvec m; *// <- incomplete type error

Best

Kai-Uwe Bux

[imutate]

I don't understand Vec():Vec<T>() and probably you're compiler
doesn't either eventually makeing Vec<Tincomplete classes
because of that problem.

I tried these but it gives same error

template < typename T >
class Vec : public std::vector< T {
public:
Vec(): std::vector<T>( ) { }
Vec( int s ) : std::vector<T>( s) { }
T& operator[](int i) { return at(i); }
const T& operator[](int i ) const { return at(i); }
};

and

template < typename T >
class Vec : public std::vector< T {
public:
T& operator[](int i) { return at(i); }
const T& operator[](int i ) const { return at(i); }
};

Do I need std:: infront of anything else ? What is the "(s)" about ?

[Kai-Uwe Bux]

Greg Comeau wrote:

In article <ef**********@p anix1.panix.com >,
Greg Comeau <co****@comeauc omputing.comwro te:

>>In article <11************ **********@c28g 2000cwb.googleg roups.com>,
<im*****@hotma il.co.ukwrote:

>>>Hi,
I am migrating some std::vectors to use a template instead, but I get
an incomplete type error in a struct declaration.

#include <vector>

template < typename T >
class Vec : public std::vector< T {
public:
Vec():Vec<T>() { }
Vec( int s ) : std::vector<T>( s) { }
T& operator[](int i) { return at(i); }
const T& operator[](int i ) const { return at(i); }
};
typedef Vec<doublevecdb l;
typedef Vec<vecdblmatdb l;
#include "matvec.h"
// that is it above

typedef vecdbl memvec;

struct felt
{
..
memvec m; // <- incomplete type error

I don't understand Vec():Vec<T>() and probably you're compiler
doesn't either eventually makeing Vec<Tincomplete classes
because of that problem.

Also on a different aspect: std::vector was not written to be
derived from.

If you look at the OP's code, the template class Vec<Tis clearly a
debugging tool: I would bet that the intended use is to redefine some
typedefs that currently go to std::vector to hunt down some out of bounds
errors. Once those are fixed, the typedef will hopefully be changed back to
std::vector in production code. I cannot see any harm in this little trick.

Of course, a full-fledged debugging vector (e.g., whose iterators would
guard against invalidation) would be even better.
Best

Kai-Uwe Bux

[imutate]

Greg Comeau wrote:

Also on a different aspect: std::vector was not written to be
derived from.
--

Why was I recommended to wrap this in a template in the first place ?

[Kai-Uwe Bux]

im*****@hotmail .co.uk wrote:

Greg Comeau wrote:

>Also on a different aspect: std::vector was not written to be
derived from.
--

Why was I recommended to wrap this in a template in the first place ?

To cut a long story short: std::vector does not have a virtual destructor.
That implies that you get undefined behavior if you use a std::vector<T>*
polymorphically and you delete an object of a derived class through this
pointer. Another source of surprises is that references to derived objects
will silently convert to references of type std::vector<T>.

Certain people think that it is therefore a BadIdea(tm) to ever inherit
publicly from std::vector<T>. Others think it's ok as long as you know
about the possible traps. In your case, it looks as though you use this
inheritance just as a temporary debugging tool and there is probably no
harm. Also, you could go back to std::vector<Tin production code once
the out of bounds errors have been found. In principle, you should be able
to do the switch with a simple typedef in your code.

Inheriting from std::vector<Tca n be tricky. That does not imply it is
always bad. But you have to be aware of the difficulties that can arise.
Best

Kai-Uwe Bux

[imutate]

Kai-Uwe Bux wrote:

Inheriting from std::vector<Tca n be tricky. That does not imply it is
always bad. But you have to be aware of the difficulties that can arise.
Best

Kai-Uwe Bux

Thanks, I'll check this out. Does this count as inheriting ?

class myc
{
std::vector<dou blex;
...

[Kai-Uwe Bux]

im*****@hotmail .co.uk wrote:

>
Kai-Uwe Bux wrote:

>Inheriting from std::vector<Tca n be tricky. That does not imply it is
always bad. But you have to be aware of the difficulties that can arise.
Best

Kai-Uwe Bux

Thanks, I'll check this out. Does this count as inheriting ?

class myc
{
std::vector<dou blex;
..

Nope, that is usually called composition. The drawback is that you have to
write tons of boilerplate code to forward all the member functions.

Also, I did not intend to scare you away from public inheritance in this
particular case. If you do not use pointers to std::vector polymorphically
(and you don't have a reason to do that anyhow), you will almost certainly
be fine.

To complete the picture, you might want to read up on private inheritance:

class my_vector : private std::vector<dou ble{

using iterator;
using ...
// tons of using declarations forwarding all members that we want.

};

This avoids the pitfalls of public inheritance and is less boilerplate code
than composition.
Best

Kai-Uwe Bux