# VC6 -> VC2005 conversion problem

From:
Philippe <pasdemail@a.com>
Newsgroups:
microsoft.public.vc.mfc
Date:
Fri, 11 Jan 2008 09:19:42 +0100
Message-ID:
<4787269c$0$11369$426a74cc@news.free.fr> Hello, I'm converting my project from VC++6 to VC++2005. among many compilation errors now solved, that one is stucking me : I have that template : template <class T> class TLineApproximator { public: //! \name Structures and typedefs //@{ //! 2D homogenous point struct SHomog { public: SHomog(T _x=0, T _y=0, T _w=1) { x=_x; y=_y; w=_w;}; T x; T y; T w; }; //! 2D point struct SPoint { public: SPoint(T _x=0, T _y=0) { x=_x; y=_y;}; static void CrossProduct( const SPoint& p, const SPoint& q, SHomog& r) { r.w = p.x * q.y - p.y * q.x; r.x = - q.y + p.y; r.y = q.x - p.x; }; static T DotProduct( const SPoint& p, const SHomog& q) { return q.w + p.x*q.x + p.y*q.y; }; static T DotProduct( const SPoint& p, const SPoint& q) { return p.x*q.x + p.y*q.y; }; static void LinComb( T a, const SPoint& p, T b, const SPoint& q, SPoint& r) { r.x = a * p.x + b * q.x; r.y = a * p.y + b * q.y; }; T x; T y; }; //! Internal limit structure struct SLimits { T dMinX; T dMaxX; T dMinY; T dMaxY; T GetCenterX() { return (dMaxX+dMinX)/2.0;}; T GetCenterY() { return (dMaxX+dMinX)/2.0;}; T GetWidth() { return dMaxX-dMinX;}; T GetHeight() { return dMaxY-dMinY;}; }; //! points container typedef typename std::vector<SPoint> PointContainer; //! Key containers typedef typename std::list<PointContainer> KeyContainer; //@} //! \name Constructor //@{ TLineApproximator(): m_dTol(0), m_bNormalization(true) {m_limits.dMinX=m_limits.dMinY=0;m_limits.dMaxX=m_limits.dMaxY=1;}; ~TLineApproximator(){}; //@} //! \name Point handling //@{ //! returns number of points UINT GetPointSize() const { return m_cPoints.size();}; //! sets the points as copy of the vectors void SetPoints( const std::vector<T>& vX, const std::vector<T>& vY); //! return vector of points PointContainer& GetPoints() { return m_cPoints;}; //! return vector of points, const const PointContainer& GetPoints() const { return m_cPoints;}; //@} //! \name Key handling //@{ //! returns number of keys UINT GetKeySize() const { return m_cKeys.size();}; //! return keys KeyContainer& GetKeys() { return m_cKeys;}; //! return keys, const const KeyContainer& GetKeys() const { return m_cKeys;}; //! fill vectors with keys void GetKeys( std::vector<T>& vX, std::vector<T>& vY); //@} //! \name Tolerance //@{ //! sets the tolerance void SetTol( double dTol) { m_dTol = __max( dTol, 0);}; //! return current tolerance double GetTol() const { return m_dTol;}; //@} //! \name Normalization //@{ //! enabled, disable normalization void SetNormalization( bool bEnabled = true) { m_bNormalization = true;}; //! returns true if normalizing bool IsNormalization() const { return m_bNormalization;}; //@} //! \name Simplification functions //@{ //! Initialize simplification void ClearKeys() { m_cKeys.clear();}; //! Compute the keys void Simplify(); /*! Shrink to compression level \param dScale scaling to apply [0...1] \param dScaleTol [optional] tolerance with respect to dScale, default is 0.05 \param nMaxIter [optional] maximum number of iterations, default is 250 \return number of estimations */ UINT ShrinkNorm( double dScale, double dScaleTol = 0.05, UINT nMaxIter = 250); /*! Shrink to a specified number of points \param n desired number of points in the approximate curve \param nTol [optional] tolerance with respect to n, default is 10 \param nMaxIter [optional] maximum number of iterations, default is 250 \return number of estimations */ UINT Shrink( UINT nDesiredPoints, UINT nTol = 10, UINT nMaxIter = 250); //@} //! \name Helper functions //@{ //! compute the bounding box void ComputeBoundingBox(); //! return the point bounding box const SLimits& GetBoundingBox() const { return m_limits;}; /*! Point normalization Let$(x_i,y_i)$, the original points and$(\hat x_x, \hat y_i)$the normalized points: $\hat x_i = \frac{x_i - \bar x]}{\max_i (x_i-x_j)}$ where$\bar x, \bar y$denote respectively the mean value of the$x_i$and$y_i\$.

\sa DeNormalizePoints
*/
void NormalizePoints();

/*! \brief Roll back normalization

\sa NormalizePoints
*/
void DeNormalizePoints();
//@}

protected:
//! \name Virtual functions
//@{
virtual void ComputeKeys() { ClearKeys();};
//@}

private:
double m_dTol;
bool m_bNormalization;
PointContainer m_cPoints;
KeyContainer m_cKeys;
SLimits m_limits;
};

inside, you can see the SPoint structure and its x and y members.

the faulty code is :

void CPGLLine2DLOD::PlotLineStripGfx(gfxinterface::CGfxInterface& gfx)
{
const LODLine::KeyContainer& kc= m_hull.GetKeys();
LODLine::KeyContainer::const_iterator it;
UINT i;
double* pX=new double[kc.size()];
double* pY=new double[kc.size()];
for (it=kc.begin(), i=0; it!=kc.end();it++, i++)
{
// line (174) in error
pX[i] = (*it)->x;
// idem
pY[i] = (*it)->y;
}

}

I get that compilation error :

c:\program files\microsoft visual studio
2005\vc\pgl\pglline2dlod.cpp(174) : error C2819: type 'std::vector<_Ty>'
does not have an overloaded member 'operator ->'
with
[
_Ty=hull::TLineApproximator<double>::SPoint
]
did you intend to use '.' instead?
c:\program files\microsoft visual studio
2005\vc\pgl\pglline2dlod.cpp(174) : error C2039: 'x' : is not a member
of 'std::vector<_Ty>'
with
[
_Ty=hull::TLineApproximator<double>::SPoint
]

Strange, it compiled perfectly under VC6 and it's now faulty under VC2005
What norm change is responsible with that error and how to correct it ?

Any idea ?