Stuctures of variable length

[steflhermitte]

Dear cpp-ians,

I am working with a structure:

struct meta_segment
{
long double id;
long double num;
long double mean;
bool done;
};

but I want to store multiple elements for some of the elements of my
structure. I was thinking of using arrays in my structure. E.g., when I
have 5 elements for 'num' and 'mean':

struct meta_segment
{
long double id;
long double num[5];
long double mean[5];
bool done;
};

The problem is that only at run-time the program knows how long my
'num' and 'mean' will be. So what I want to do is make a structure,
where I can incorporate the length into the structure and use that
length as an argument.

struct meta_segment
{
long double id;
long double num[NbElements];
long double mean[NbElements];
bool done;
};

I something like this possible? Or should I look for other solutions to
solve this problem?

Thank you very much in advance,
Stef

[Rolf Magnus]

steflhermitte wrote:

Thanks folks, you helped me a lot!

I'm am not an experienced c++-user, so things that are evident are not
so evident for me.
Then this is just another reason for using std::vector instead of fiddling
around with raw arrays. std::vector is a class that encapsulates the nasty
details about arrays, especially the dynamic memory handling.
I opted for making a class. I made:

TEST.H
------------------------------------------------
#ifndef TEST_H_
#define TEST_H_

using namespace std;
namespace test
{
class metasegment
{
public:
// constructor
metasegment(uns igned int NbLayers);
// porperties
int id;
int *num;
int *mean;
bool done;
};
};
#endif
------------------------------------------------

TEST.CPP
------------------------------------------------
#include "test.h"
#include <iostream>
#include <stdlib.h>

namespace test
{
// constructor and destructor
No, this is just a constructor.
metasegment::me tasegment(unsig ned int NbLayers)
{
id=0;
num = new int[NbLayers];
mean = new int[NbLayers];
done=0;
}
If you do the dynamic memory yourself, you must provide a destructor that
properly destroys the dynamic arrays. Futher, you need to provide a
user-defined copy constructor and assignment operator. The compiler
generates those if you don't write you own, but in this case, the
compiler-generated ones don't do what you want.
Again, std::vector would handle this for you.
};
------------------------------------------------

Now I want to make a vector based on this class:

vector <metasegment(10 )> testvector;

but is does not work.
Between the < and > has to be a class. metasegment(10) is not a class.
I assume I have to work with typedef, but I don't know how to solve this
problem. Any advice?

Just do:

vector<metasegm ent> testvector; //define the vector
testvector.push _back(metasegme nt(10)); //append an instance of your class
//to it, initialized with 10.

[Karl Heinz Buchegger]

steflhermitte wrote:

Thanks folks, you helped me a lot!

I'm am not an experienced c++-user, so things that are evident are not
so evident for me.

I opted for making a class.
You opted for the worst version you could do.
namespace test
{
class metasegment
{
public:
// constructor
metasegment(uns igned int NbLayers);
// porperties
int id;
int *num;
int *mean;
bool done;
};
};
That class is incomplete.
You are missing:
* a destructor
* a copy constructor
* an assignment operator

thus ...
Now I want to make a vector based on this class:

vector <metasegment(10 )> testvector;

but is does not work.
.... this does not work.
I assume I have to work with typedef, but I don't
know how to solve this problem. Any advice?

Look up the 'Rule of three'.
Then implement
* a destructor
* a copy constructor
* an assignment operator

if you implement them correctly, it will work.

Or save yourself all the hassle and use a std::vector as was
suggested by lots of replies.

--
Karl Heinz Buchegger
kb******@gascad .at

[Peter Koch Larsen]

"steflhermi tte" <st************ ***@agr.kuleuve n.ac.be> skrev i en meddelelse
news:11******** *************@g 14g2000cwa.goog legroups.com...

Dear cpp-ians,

I am working with a structure:

struct meta_segment
{
long double id;
long double num;
long double mean;
bool done;
};

but I want to store multiple elements for some of the elements of my
structure. I was thinking of using arrays in my structure. E.g., when I
have 5 elements for 'num' and 'mean':

struct meta_segment
{
long double id;
long double num[5];
long double mean[5];
bool done;
};

The problem is that only at run-time the program knows how long my
'num' and 'mean' will be. So what I want to do is make a structure,
where I can incorporate the length into the structure and use that
length as an argument.

struct meta_segment
{
long double id;
long double num[NbElements];
long double mean[NbElements];
bool done;
};

I something like this possible? Or should I look for other solutions to
solve this problem?

Thank you very much in advance,
Stef

You should definitely use a std::vector.

/Peter

[Robbie Hatley]

John Carson wrote:

Robbie Hatley wrote:

Arrays in structs or classes are a poor idea.
(No copy constructor, fixed size, etc.)

What do you mean by no copy constructor?
The array itself doesn't have one of course,
but array members are successfully copied when one struct
containing an array is used to initialise another

My mistake. I was confusing arrays in classes with arrays in
std::containers (which isn't allowed, because assignment isn't
defined for arrays).

On studying the standard, I see in 12.8, clause 8, paragraph 3,
regarding requirments for class implicit copy constructors:

"if the subobject is an array, each element is copied,
in the manner appropriate to the element type"

I find this sort of amusing, because that means if type
Type1 is a class with an array member, I can say:

Type1 t1;
Type1 t2(t1);

However, I'm not allowed to do any of THESE things:

typedef int ArrayOfFiveInts[5];
ArrayOfFiveInts t1 = {9, 1, 1, 17, 4};

// Error, assignment not allowed:
ArrayOfFiveInts t2 = t1;

// Error, cast not allowed:
ArrayOfFiveInts t3 = ArrayOfFiveInts (t1);

// Error, initialization not allowed:
ArrayOfFiveInts t4(t1);

Which I think is dumb. Why not allow those things?

The following works, of course, but is very ugly:

ArrayOfFiveInts t5;for(int i=0;i<5;++i)t5[i]=t1[i];

--
Cheers,
Robbie Hatley
Tustin, CA, USA
email: lonewolfintj at pacbell dot net
web: home dot pacbell dot net slant earnur slant

----== Posted via Newsfeeds.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----

[Robbie Hatley]

John Carson wrote:

Robbie Hatley wrote:

Arrays in structs or classes are a poor idea.
(No copy constructor, fixed size, etc.)

What do you mean by no copy constructor?
The array itself doesn't have one of course,
but array members are successfully copied when one struct
containing an array is used to initialise another

My mistake. I was confusing arrays in classes with arrays in
std::containers (which isn't allowed, because assignment isn't
defined for arrays).

On studying the standard, I see in 12.8, clause 8, paragraph 3,
regarding requirments for class implicit copy constructors:

"if the subobject is an array, each element is copied,
in the manner appropriate to the element type"

I find this sort of amusing, because that means if type
Type1 is a class with an array member, I can say:

Type1 t1;
Type1 t2(t1);

However, I'm not allowed to do any of THESE things:

typedef int ArrayOfFiveInts[5];
ArrayOfFiveInts t1 = {9, 1, 1, 17, 4};

// Error, assignment not allowed:
ArrayOfFiveInts t2 = t1;

// Error, cast not allowed:
ArrayOfFiveInts t3 = ArrayOfFiveInts (t1);

// Error, initialization not allowed:
ArrayOfFiveInts t4(t1);

Which I think is dumb. Why not allow those things?

The following works, of course, but is very ugly:

ArrayOfFiveInts t5;for(int i=0;i<5;++i)t5[i]=t1[i];

--
Cheers,
Robbie Hatley
Tustin, CA, USA
email: lonewolfintj at pacbell dot net
web: home dot pacbell dot net slant earnur slant

----== Posted via Newsfeeds.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----

[Rolf Magnus]

"Robbie Hatley" <lonewolfintj at pacbell dot net> wrote:

On studying the standard, I see in 12.8, clause 8, paragraph 3,
regarding requirments for class implicit copy constructors:

"if the subobject is an array, each element is copied,
in the manner appropriate to the element type"

I find this sort of amusing, because that means if type
Type1 is a class with an array member, I can say:

Type1 t1;
Type1 t2(t1);

However, I'm not allowed to do any of THESE things:

typedef int ArrayOfFiveInts[5];
ArrayOfFiveInts t1 = {9, 1, 1, 17, 4};

// Error, assignment not allowed:
ArrayOfFiveInts t2 = t1;
This is not an assignment.
// Error, cast not allowed:
ArrayOfFiveInts t3 = ArrayOfFiveInts (t1);
This would be the same as the one before, just with an additional copy.
// Error, initialization not allowed:
ArrayOfFiveInts t4(t1);
One reason why typedefs for arrays are usually avoided.
Which I think is dumb. Why not allow those things?
Good question.
The following works, of course, but is very ugly:

ArrayOfFiveInts t5;for(int i=0;i<5;++i)t5[i]=t1[i];

Or:
ArrayOfFiveInts t6 = { t1[0], t1[1], t1[2], t1[3], t1[4] };

[Old Wolf]

Robbie Hatley wrote:

I find this sort of amusing, because that means if type
Type1 is a class with an array member, I can say:

Type1 t1;
Type1 t2(t1);

However, I'm not allowed to do any of THESE things:

typedef int ArrayOfFiveInts[5];
ArrayOfFiveInts t1 = {9, 1, 1, 17, 4};

// Error, assignment not allowed:
ArrayOfFiveInts t2 = t1;

// Error, cast not allowed:
ArrayOfFiveInts t3 = ArrayOfFiveInts (t1);

// Error, initialization not allowed:
ArrayOfFiveInts t4(t1);

Which I think is dumb. Why not allow those things?

Because of The Rule. In the above expressions, 't1' is
converted to a pointer to int, before the '=' is processed.

To allow your code, you would either have to revoke The Rule
(which I think would cause too much incompatibility with
existing code), or allow this:

int *ptr = foo();
ArrayOfFiveInts t2 = ptr;

which seems possible but I think it is dangerous.