Hi All,

BACKGROUND INFO
I need to use a "vector" structure to store a number of objects that
becomes known only at run time. The constructor, at instantiation time
of a new object, increments a static counter. The value of this
counter becomes the ID of the object that has just been instantiated.
I am using Visual C++ 6.0 and, for this project, in the short term I
have no options about this.

PROBLEM
I have done this countless times in the past (90s) with large number
(100+) of objects without using a vector. Now I need to be able to
handle a much higher number (>10000) of objects. I need the use of a
vector because I need to run various loops on all objects. When I do
it, it does not work.

MY CODE
==============
I am showing below:
1) File TestOne.cpp
2) File MyClass.cpp
3) File MyClass.h
4) Screen dump of execution

WHAT I GET
=========
It seems that the static counter is not accessible from within the
vector. See "4) Screen dump of execution". Actually, it seems that the
static counter is accessed once and never again.

QUESTIONS
==========
1) Am I doing something wrong? What?
2) Can anybody be so kind to show me the correct code?
3) If, for whatever reason, it cannot be done using a vector, what can
I do?

Thank you.

Best regards

Bruno

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// TestOne.cpp
//

#include "MyClass.h"
#include <iostream>
#include <iomanip>
#include <vector>

using std::cout;
using std::setw;
using std::endl;

int main(int argc, char * argv[])
{
        int i=0;

        MyClass m1, m2, m3;

        cout << endl <<endl;

        std::vector<MyClass> m;
        m.resize(5);
        for(i=0; i<5;i++)
        {
                m.at(i);
                cout << endl << "LOOP"<<'\t';
                m[i].DisplayMyClassObject();
        }
        cout << endl << endl;
        return (0); // this should not be always 0
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//
// MyClass.cpp
//

#include "MyClass.h"

#include <iostream>
#include <iomanip>

using std::cout;
using std::setw;
using std::endl;

int MyClass::MyClassCounter=0;

MyClass::MyClass()
{
        this->MyClassCounter++;
        this->ID = this->MyClassCounter;
        cout << endl <<"CONSTRUCTOR"<<'\t';
        this->DisplayMyClassObject();

}

MyClass::~MyClass()
{
        this->MyClassCounter--;
        cout << endl <<"DESTRUCTOR"<<'\t';
        this->DisplayMyClassObject();

}

void MyClass::DisplayMyClassObject()
{
        cout <<"ID"<<setw(2)<<this->ID<<"  Cn"<< setw(2)<< this-
>MyClassCounter <<endl;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// MyClass.h: interface for the MyClass class.
//

#if !
defined(AFX_MYCLASS_H__CE1FCBB5_0FEC_4C67_97D2_8DF6E2694182__INCLUDED_)
#define AFX_MYCLASS_H__CE1FCBB5_0FEC_4C67_97D2_8DF6E2694182__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class MyClass
{
public:
        void DisplayMyClassObject(void);
        MyClass();
        virtual ~MyClass();

private:
        int ID;
        static int MyClassCounter;

};

#endif // !
defined(AFX_MYCLASS_H__CE1FCBB5_0FEC_4C67_97D2_8DF6E2694182__INCLUDED_)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

CONSTRUCTOR     ID 1  Cn 1

CONSTRUCTOR     ID 2  Cn 2

CONSTRUCTOR     ID 3  Cn 3

CONSTRUCTOR     ID 4  Cn 4

DESTRUCTOR      ID 4  Cn 3

LOOP    ID 4  Cn 3

LOOP    ID 4  Cn 3

LOOP    ID 4  Cn 3

LOOP    ID 4  Cn 3

LOOP    ID 4  Cn 3

DESTRUCTOR      ID 4  Cn 2

DESTRUCTOR      ID 4  Cn 1

DESTRUCTOR      ID 4  Cn 0

DESTRUCTOR      ID 4  Cn-1

DESTRUCTOR      ID 4  Cn-2

DESTRUCTOR      ID 3  Cn-3

DESTRUCTOR      ID 2  Cn-4

DESTRUCTOR      ID 1  Cn-5
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-

On Sep 3, 10:47=A0am, "Bruno.DiStefano" <Bruno.DiStef...@gmail.com>
wrote:
> Hi All,
>
> BACKGROUND INFO
> I need to use a "vector" structure to store a number of objects that
> becomes known only at run time. The constructor, at instantiation time
> of a new object, increments a static counter. The value of this
> counter becomes the ID of the object that has just been instantiated.
> I am using Visual C++ 6.0 and, for this project, in the short term I
> have no options about this.
>
> PROBLEM
> I have done this countless times in the past (90s) with large number
> (100+) of objects without using a vector. Now I need to be able to
> handle a much higher number (>10000) of objects. I need the use of a
> vector because I need to run various loops on all objects. When I do
> it, it does not work.
>
> MY CODE
> =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
> I am showing below:
> 1) File TestOne.cpp
> 2) File MyClass.cpp
> 3) File MyClass.h
> 4) Screen dump of execution
>
> WHAT I GET
> =3D=3D=3D=3D=3D=3D=3D=3D=3D
> It seems that the static counter is not accessible from within the
> vector. See "4) Screen dump of execution". Actually, it seems that the
> static counter is accessed once and never again.
>
> QUESTIONS
> =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
> 1) Am I doing something wrong? What?
> 2) Can anybody be so kind to show me the correct code?
> 3) If, for whatever reason, it cannot be done using a vector, what can
> I do?
>
> Thank you.
>
> Best regards
>
> Bruno
>
> /////////////////////////////////////////////////////////////////////////=
///////////////////////////////////////////////////////////////////////////=
/
> //
> // TestOne.cpp
> //
>
> #include "MyClass.h"
> #include <iostream>
> #include <iomanip>
> #include <vector>
>
> using std::cout;
> using std::setw;
> using std::endl;
>
> int main(int argc, char * argv[])
> {
> =A0 =A0 =A0 =A0 int i=3D0;
>
> =A0 =A0 =A0 =A0 MyClass m1, m2, m3;
>
> =A0 =A0 =A0 =A0 cout << endl <<endl;
>
> =A0 =A0 =A0 =A0 std::vector<MyClass> m;
> =A0 =A0 =A0 =A0 m.resize(5);
> =A0 =A0 =A0 =A0 for(i=3D0; i<5;i++)
> =A0 =A0 =A0 =A0 {
> =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 m.at(i);
> =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 cout << endl << "LOOP"<<'\t';
> =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 m[i].DisplayMyClassObject();
> =A0 =A0 =A0 =A0 }
> =A0 =A0 =A0 =A0 cout << endl << endl;
> =A0 =A0 =A0 =A0 return (0); // this should not be always 0
>
> }
>
> /////////////////////////////////////////////////////////////////////////=
///////////////////////////////////////////////////////////////////////////=
/
>
> //
> // MyClass.cpp
> //
>
> #include "MyClass.h"
>
> #include <iostream>
> #include <iomanip>
>
> using std::cout;
> using std::setw;
> using std::endl;
>
> int MyClass::MyClassCounter=3D0;
>
> MyClass::MyClass()
> {
> =A0 =A0 =A0 =A0 this->MyClassCounter++;
> =A0 =A0 =A0 =A0 this->ID =3D this->MyClassCounter;
> =A0 =A0 =A0 =A0 cout << endl <<"CONSTRUCTOR"<<'\t';
> =A0 =A0 =A0 =A0 this->DisplayMyClassObject();
>
> }
>
> MyClass::~MyClass()
> {
> =A0 =A0 =A0 =A0 this->MyClassCounter--;
> =A0 =A0 =A0 =A0 cout << endl <<"DESTRUCTOR"<<'\t';
> =A0 =A0 =A0 =A0 this->DisplayMyClassObject();
>
> }
>
> void MyClass::DisplayMyClassObject()
> {
> =A0 =A0 =A0 =A0 cout <<"ID"<<setw(2)<<this->ID<<" =A0Cn"<< setw(2)<< this=
-
>
> >MyClassCounter <<endl;
> }
>
> /////////////////////////////////////////////////////////////////////////=
///////////////////////////////////////////////////////////////////////////=
/
> //
> // MyClass.h: interface for the MyClass class.
> //
>
> #if !
> defined(AFX_MYCLASS_H__CE1FCBB5_0FEC_4C67_97D2_8DF6E2694182__INCLUDED_)
> #define AFX_MYCLASS_H__CE1FCBB5_0FEC_4C67_97D2_8DF6E2694182__INCLUDED_
>
> #if _MSC_VER > 1000
> #pragma once
> #endif // _MSC_VER > 1000
>
> class MyClass
> {
> public:
> =A0 =A0 =A0 =A0 void DisplayMyClassObject(void);
> =A0 =A0 =A0 =A0 MyClass();
> =A0 =A0 =A0 =A0 virtual ~MyClass();
>
> private:
> =A0 =A0 =A0 =A0 int ID;
> =A0 =A0 =A0 =A0 static int MyClassCounter;
>
> };
>
> #endif // !
> defined(AFX_MYCLASS_H__CE1FCBB5_0FEC_4C67_97D2_8DF6E2694182__INCLUDED_)
> /////////////////////////////////////////////////////////////////////////=
///////////////////////////////////////////////////////////////////////////=
/
>
> CONSTRUCTOR =A0 =A0 ID 1 =A0Cn 1
>
> CONSTRUCTOR =A0 =A0 ID 2 =A0Cn 2
>
> CONSTRUCTOR =A0 =A0 ID 3 =A0Cn 3
>
> CONSTRUCTOR =A0 =A0 ID 4 =A0Cn 4
>
> DESTRUCTOR =A0 =A0 =A0ID 4 =A0Cn 3
>
> LOOP =A0 =A0ID 4 =A0Cn 3
>
> LOOP =A0 =A0ID 4 =A0Cn 3
>
> LOOP =A0 =A0ID 4 =A0Cn 3
>
> LOOP =A0 =A0ID 4 =A0Cn 3
>
> LOOP =A0 =A0ID 4 =A0Cn 3
>
> DESTRUCTOR =A0 =A0 =A0ID 4 =A0Cn 2
>
> DESTRUCTOR =A0 =A0 =A0ID 4 =A0Cn 1
>
> DESTRUCTOR =A0 =A0 =A0ID 4 =A0Cn 0
>
> DESTRUCTOR =A0 =A0 =A0ID 4 =A0Cn-1
>
> DESTRUCTOR =A0 =A0 =A0ID 4 =A0Cn-2
>
> DESTRUCTOR =A0 =A0 =A0ID 3 =A0Cn-3
>
> DESTRUCTOR =A0 =A0 =A0ID 2 =A0Cn-4
>
> DESTRUCTOR =A0 =A0 =A0ID 1 =A0Cn-5
> /////////////////////////////////////////////////////////////////////////=
///////////////////////////////////////////////////////////////////////////=
/
>
> -

Make sure you also implement a copy constructor and assignment
operator that increments the static count and assigns correct id to
the object.

Thank you to all who responded, i.e. Klaudiusz Baran on comp.lang.c++
& Chris Morley, Alberto Ganesh Barbati, Erik Wikstr�m, Thomas Richter,
Ulrich Eckhardt, Hyman Rosen, and Maciej Sobczak on comp.lang.c+
+.moderated. All of you were right. Two comments in particular were
right:

//////
You should probably also consider getting a more recent compiler. VC
6.0 is ancient, and has a lot of defects - rather obsolete.
//////
First of all, there is absolutely no reason to write "this->" in the
member
function. Then, the copy constructor could be:
//////

As about the ancient compiler, you are very right. I have been saying
this for long time, but I inherited the code and I have to abide by
the rules of those who set the agenda. As about the this-> in a member
function, again, you are right, but I have to abide by the coding
standard set by others.

As about this-> being misleading with a static member variable you are
right. I should replace it with MyClass::

Thank you again.

Best regards

Bruno


-- 
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated.    First time posters: Do this! ]

On Sep 4, 1:23 pm, "Bruno.DiStefano" <Bruno.DiStef...@gmail.com>
wrote:

[...]

> //////
> First of all, there is absolutely no reason to write "this->" in the
> member
> function. Then, the copy constructor could be:
> //////
>
> As about the this-> in a member
> function, again, you are right, but I have to abide by the coding
> standard set by others.
>


Well, take the above words as general advice please,
special treatment needed, depends on what are you
actually doing.

If you write template code, sometimes you need to write
"this->" to deal with the name lookup issues for dependent
base classes. It is also true that for heavy templated code,
using "this->" for all possible situations, was recommended
by some template experts.

Regards,

Jiang


-- 
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated.    First time posters: Do this! ]