std::vector question

[Hamish]

I havea program which on execution gives unpredictable behaviour (it
shouldn't). In trying to track down the problem, I'm wondering if there is a
difference between these two ways of filling a std::vector with data:

Method 1:

std::vector<int> v;
int k;

for(i=0;i<n;i++){
k = i + 3;
v.push_back(k);
}

Method 2:

std::vector<int> v;

for(i=0;i<n;i++){
int k = i + 3;
v.push_back(k);
}

 

[Victor Bazarov]

I havea program which on execution gives unpredictable behaviour (it
shouldn't). In trying to track down the problem, I'm wondering if there is
a
difference between these two ways of filling a std::vector with data:

Method 1:

std::vector<int> v;
int k;

for(i=0;i<n;i++){
k = i + 3;
v.push_back(k);
}

Method 2:

std::vector<int> v;

for(i=0;i<n;i++){
int k = i + 3;
v.push_back(k);
}

No, in this particular case there is no difference. However, something
tells me that your real code, the code that gives you trouble, is a bit
more complicated than that.

It is often important to follow certain rules in your programming. For
example, the famous "Rule of Three" (look it up). If your class has
some kind of dynamic memory management, you simply _must_ follow it.

V

 

[Chris Theis]

I havea program which on execution gives unpredictable behaviour (it
shouldn't). In trying to track down the problem, I'm wondering if there is a
difference between these two ways of filling a std::vector with data:

Method 1:

std::vector<int> v;
int k;

for(i=0;i<n;i++){
k = i + 3;
v.push_back(k);
}

Method 2:

std::vector<int> v;

for(i=0;i<n;i++){
int k = i + 3;
v.push_back(k);
}

The only difference with these two methods is the scope of k but this
doesn´t affect the behavior in this case. Please post your real code which
gives you trouble.

Cheers
Chris

 

[KPB]

It is often important to follow certain rules in your programming. For
example, the famous "Rule of Three" (look it up).

I'm actually interested in what this "rule of three" says but I'm
getting lots of irrelevant hits on google. It seems that everybody has
some "rule of three".

Any hints?

Thanks,
KPB

 

[Jeff Flinn]

I'm actually interested in what this "rule of three" says but I'm
getting lots of irrelevant hits on google. It seems that everybody has
some "rule of three".

Any hints?

Googling 101: What language are you discussing? Add that to your search
string.

Jeff

 

[KPB]

Googling 101: What language are you discussing? Add that to your search
string.

Please don't treat me like I'm an idiot. I'm not.

Thanks,
KPB

 

[KPB]

I'm actually interested in what this "rule of three" says but I'm
getting lots of irrelevant hits on google. It seems that everybody has
some "rule of three".

Any hints?

Thanks,
KPB

Nevermind Victor. I found them. I alredy know them. I don't think Scott
Meyers refered to this as the "rule of three" but he did stress this
nonetheless in his Effective C++ books.

KPB

 

[Hamish]

I havea program which on execution gives unpredictable behaviour (it

is

The only difference with these two methods is the scope of k but this
doesn´t affect the behavior in this case. Please post your real code which
gives you trouble.

I haven't been able to track down the problem yet. However, the only
difference between an older version which worked, adn this version is the
following data structures:

std::vector<PolyTypeClass*> PolyTypes;

class PolyTypeClass{
public:
PolyTypeClass();
virtual ~PolyTypeClass();

const PolyTypeClass& operator= (const PolyTypeClass& poly);
void Copy(PolyTypeClass * pCopy);

int ID;
std::vector<BasePolygonClass> Rot;
};

class BasePolygonClass{
public:
BasePolygonClass();
BasePolygonClass(int Size);
virtual ~BasePolygonClass();

const BasePolygonClass& operator= (const BasePolygonClass& poly);
void Copy(BasePolygonClass * pCopy);

std::vector<PointPropClass> Points;
double Area;
double Length;
double Height;
BOOL IsConvex;
double Angle;
BOOL XFlip;
BOOL YFlip;
};

class PointPropClass
{
public:
PointPropClass();
virtual ~PointPropClass();
const PointPropClass& operator= (const PointPropClass& poly);
void Copy(PointPropClass * pCopy);

BOOL TP;
double Angle;
int Num;
int CavNum;
int St;
int Fin;
int Type;
BOOL Neg;
BOOL IsGhosh;
double x;
double y;
};

 

[Chris Theis]

there

I haven't been able to track down the problem yet. However, the only
difference between an older version which worked, adn this version is the
following data structures:

std::vector<PolyTypeClass*> PolyTypes;

class PolyTypeClass{
public:
PolyTypeClass();
virtual ~PolyTypeClass();

const PolyTypeClass& operator= (const PolyTypeClass& poly);
void Copy(PolyTypeClass * pCopy);

int ID;
std::vector<BasePolygonClass> Rot;
};

class BasePolygonClass{
public:
BasePolygonClass();
BasePolygonClass(int Size);
virtual ~BasePolygonClass();

const BasePolygonClass& operator= (const BasePolygonClass& poly);
void Copy(BasePolygonClass * pCopy);

std::vector<PointPropClass> Points;
double Area;
double Length;
double Height;
BOOL IsConvex;
double Angle;
BOOL XFlip;
BOOL YFlip;
};

class PointPropClass
{
public:
PointPropClass();
virtual ~PointPropClass();
const PointPropClass& operator= (const PointPropClass& poly);
void Copy(PointPropClass * pCopy);

BOOL TP;
double Angle;
int Num;
int CavNum;
int St;
int Fin;
int Type;
BOOL Neg;
BOOL IsGhosh;
double x;
double y;
};

What strikes me (although in this case it should not pose a problem after a
quick glance at your code) is that you do supply a dtor and an assignment op
but not a copy ctor. If you really need a dtor & an assignment op it´s good
practice to supply a copy ctor too.

If you could please post the actual code of "Method 1" & "Method 2" which
works with your data structures and also the implementation of the Copy()
method would be interesting.

Cheers
Chris