Smart pointer for arrays of structs?

[Henrik Goldman]

Hi,

I have some data which is stored as plain old C structures. Until now I've
had arrays of these structs on stack but due to stack overrun I need to move
these to heap.
I've been trying out some smart pointers to help but so far the
implementation I've been dealing with has had problems with [] operator
since it could conflict when using the same class with "unsigned char".

Do you have any recommendations for smart pointers able to work with arrays?

I would need something like:

ptr = (new or malloc) MY_STRUCT [16];

ptr[i].member

Thanks.

-- Henrik

[Gianni Mariani]

Henrik Goldman wrote:

Hi,

I have some data which is stored as plain old C structures. Until now I've
had arrays of these structs on stack but due to stack overrun I need to move
these to heap.
I've been trying out some smart pointers to help but so far the
implementation I've been dealing with has had problems with [] operator
since it could conflict when using the same class with "unsigned char".

Do you have any recommendations for smart pointers able to work with arrays?

I would need something like:

ptr = (new or malloc) MY_STRUCT [16];

ptr[i].member

What is wrong with std::vector ?

[Henrik Goldman]

>

What is wrong with std::vector ?

I forgot to mention that it's a requirement that the data needs to be
accessible from external C functions. For this reason it needs to be
serialized just like an ordinary array.

-- Henrik

[Jim Langston]

"Henrik Goldman" <he************ @mail.tele.dkwr ote in message
news:45******** *************@d read11.news.tel e.dk...

What is wrong with std::vector ?

I forgot to mention that it's a requirement that the data needs to be
accessible from external C functions. For this reason it needs to be
serialized just like an ordinary array.

-- Henrik

std::vector fits the bill for that.
http://www.parashift.com/c++-faq-lit....html#faq-34.3
vector stores it's memory contiguous

[Salt_Peter]

Henrik Goldman wrote:

What is wrong with std::vector ?

I forgot to mention that it's a requirement that the data needs to be
accessible from external C functions. For this reason it needs to be
serialized just like an ordinary array.

-- Henrik

The std::vector is then perfect for the job. Not only are its elements
organized in contiguous memory and dynamic, its also much easier to
overload a global op<< to stream/serialize the data.

Show me code with a primitive array, and i'll show you a std::vector
that does the same but better, and then some. And that includes
performance.

[Henrik Goldman]

Thank you Gianni, Jim, Peter, for your answers.

It seems to be a good choice. It certainly saved me from a day of work
trying to get a smart pointer class working to do the same job.

The way I use it is:

vector <mytypev;

v.resize(nEleme nts);
and then
memset(&v[0], 0, sizeof(mytype) * v.size());

It's too bad I cannot do all the initialization at once. However the data
needs to be zero initialized and have a certain size. All in all it does
save me from some work so it's a cheap price to pay.

-- Henrik

[BobR]

Henrik Goldman wrote in message
<45************ *********@dread 11.news.tele.dk >...

>Thank you Gianni, Jim, Peter, for your answers.

It seems to be a good choice. It certainly saved me from a day of work
trying to get a smart pointer class working to do the same job.
The way I use it is:

vector <mytypev;

v.resize(nElem ents);
and then
memset(&v[0], 0, sizeof(mytype) * v.size());

It's too bad I cannot do all the initialization at once. However the data
needs to be zero initialized and have a certain size. All in all it does
save me from some work so it's a cheap price to pay.
--- Henrik

std::size_t nElements( 100 );
std::vector <mytypev( nElements, mytype(0) );

--
Bob R
POVrookie

[Salt_Peter]

Henrik Goldman wrote:

Thank you Gianni, Jim, Peter, for your answers.

It seems to be a good choice. It certainly saved me from a day of work
trying to get a smart pointer class working to do the same job.

The way I use it is:

vector <mytypev;

v.resize(nEleme nts);
and then
memset(&v[0], 0, sizeof(mytype) * v.size());

It's too bad I cannot do all the initialization at once. However the data
needs to be zero initialized and have a certain size. All in all it does
save me from some work so it's a cheap price to pay.

-- Henrik

Oh yes you can. In more ways than one.
There is no need to use memset, let a ctor and copy-ctor do the work
for you.

#include <vector>

template< typename T >
class mytype
{
T t;
public:
mytype() : t() { }
mytype(const T& r_t) : t(r_t) { }
};

int main()
{
std::vector< mytype< double instance(1000); // same as
instance(1000, 0.0);
std::vector< mytype< double another(1000, 11.1);
std::vector< std::string vstrings(1000, "default string");
std::vector< int vn(1000, 99);
}

The first creates an instance of a std::vector with 1000 elements all
initialized to 0.0 (by def ctor)
The second initializes 1000 elements with a value of 11.1 (using
parametized ctor)
The third initializes 1000 std::strings with the same default.
The fourth has 1000 integers set to 99.

The only requirement is that the element-type be copyable and
assignable (op=). In the case involving the class above, mytype's
compiler-generated copy ctor and assignment operator fits the bill. In
the event your class doesn't have a compiler-generated ctor or op=,
make them.

[Clark S. Cox III]

Henrik Goldman wrote:

>What is wrong with std::vector ?

I forgot to mention that it's a requirement that the data needs to be
accessible from external C functions. For this reason it needs to be
serialized just like an ordinary array.

Again, what's wrong with std::vector? :)

std::vector<Tve c = ...;

extern "C" T *GetCArray()
{
return &vec.front() ;
}

--
Clark S. Cox III
cl*******@gmail .com

[Earl Purple]

Henrik Goldman wrote:

>
vector <mytypev;

v.resize(nEleme nts);
and then
memset(&v[0], 0, sizeof(mytype) * v.size());

It's too bad I cannot do all the initialization at once. However the data
needs to be zero initialized and have a certain size. All in all it does
save me from some work so it's a cheap price to pay.

If mytype is a class then its constructor will automatically be called.

If mytype is a C struct that needs to be used with C headers too (thus
you can't give it any constructors), then you can still do it using a
0-initialised element to constructor your vector or call resize. You
just have to create one such struct and use it to initialise all the
other members.

Note that you could use a "static" instance of one.

Beware, by the way, that &v[0] or &v.front() is undefined behaviour if
v is an empty vector, so you should check for this and probably return
a NULL pointer when that is the case.