缺少类型说明符，显式类型为"缺少错误"

我对基于文本的/C++编程非常陌生(2天的exp(，正在升级一个最初在1995年左右构建的DLL。我发现在升级程序并修复了一些基本错误后，我遇到了标题中提到的问题。

特别是两种类型的错误-都发生在.cpp文件中：

• 行"vector& vector::operator +=(vector& u)">下的每个"i"值都返回显式类型丢失(假定为"t"(

• 像"v"(在v.length中(、"s"answers"u"这样的单字符值导致"缺少类型说明符-假定为int">

我发现了有关循环依赖性问题的信息，它似乎与我看到的问题非常相似。然而，因为我是一个新手，我实际上找不到错误的来源。解决由于类之间的循环依赖而导致的构建错误

我有一段代码和一个头文件如下所示。

任何帮助都会很棒。我随时可以提供进一步的信息。

谢谢，

Chris

vector.h 中的头文件

#ifndef VECTOR_H
#define VECTOR_H
#include "complex.h"
class vector
{     
private:
unsigned    npts;
double_complex      *array;
protected:
vector      slice(int start, unsigned n, int step = 1);
public:
vector();
vector(unsigned n);
vector(unsigned n, double_complex& val);
vector(double_complex* dat, unsigned n);
vector(vector& v);
~vector();
int             length()    {return npts;} 
double_complex*     data()      {return array;}
// Indexing:
double_complex&     operator ()(int i);
// Assignment:
vector&         operator =(vector& v);
vector&         operator =(double_complex& c);
// Arithmetic operators:
vector&         operator +=(vector& v);
vector&         operator +=(double_complex& c);
vector&         operator -=(vector& v);
vector&         operator -=(double_complex& c);
vector&         operator *=(vector& v);
vector&         operator *=(double_complex& c);
vector&         operator /=(vector& v);
vector&         operator /=(double_complex& c);
// Friendly arithmetic operators:
friend inline vector    operator +(vector& a);
friend vector   operator -(vector& v);
friend vector   operator +(vector& u, vector& v);
friend vector   operator -(vector& u, vector& v);
friend vector   operator *(vector& u, vector& v);
friend vector   operator /(vector& u, vector& v);
friend vector   operator +(vector& v, double_complex& c);
friend inline vector    operator +(double_complex& a, vector& b);
friend vector   operator -(vector& v, double_complex& c);
friend vector   operator -(double_complex& c, vector& v);
friend vector   operator *(vector& v, double_complex& c);
friend inline vector    operator *(double_complex& a, vector& b);
friend vector   operator /(vector& v, double_complex& c);
friend vector   operator /(double_complex& c, vector& v);
// Math functions:
friend  double_complex  dot(vector& u, vector& v);
friend  inline double_complex   mean(vector& v);
friend  double_complex  prod(vector& v);
friend  vector  reverse(vector& v);
friend  double_complex  sum(vector& v);
};

// Inlines:
inline double_complex&  vector::operator ()(int i) {return array[i];}   // no bounds checking
inline vector   operator +(vector& a)               {return a;}
inline vector   operator +(double_complex& a, vector& b)    {return b + a;}
inline vector   operator *(double_complex& a, vector& b)    {return b * a;}
inline double_complex mean(vector& v)   { return sum(v) / (double)v.length(); }

#endif     

Vector.cpp文件中的代码：

#include "vector.h"
inline void copy(register const double_complex* src, register double_complex* dst, register int n)
{
while (n--) *dst++ = *src++;
}

vector::vector()
{
npts = 0;
}

vector::vector(unsigned n)
{
npts = n;
array = (double_complex *) new char[sizeof(double_complex) * n];
}

vector::vector(unsigned n, double_complex& val)
{
register unsigned int i = npts = n;
array = (double_complex *) new char[sizeof(double_complex) * n];
register double_complex* tp = array;
while (i--) *tp++ = val;
}

vector::vector(double_complex* dat, unsigned n)
{
npts = n;
array = (double_complex *) new char[sizeof(double_complex) * n];
copy(dat, array, n);
}

vector::vector(vector& v)
{
npts = v.length();
array = (double_complex *) new char[sizeof(double_complex) * npts];
copy(v.data(), array, v.length());
}

vector::~vector()
{
delete array;
}

vector vector::slice(int start, unsigned n, int step)
{
vector temp(n);
register int i = n;
register double_complex* tp = temp.data();
register double_complex* up = data() + start;
while(i--) { *tp++ = *up; up += step;}
return temp;
}

vector& vector::operator =(vector& a)
{
copy(a.data(), array, a.length());
npts = a.length();
return *this;
}

vector& vector::operator =(double_complex& d)
{
register unsigned n = length();
register double_complex* tp = data();
while (n--) *tp++ = d;
return *this;
}

vector& vector::operator +=(vector& u)
{
register i = u.length();
register double_complex* up = u.data();
register double_complex* tp = data();
while (i--) *tp++ += *up++;
return *this;
}

vector& vector::operator +=(double_complex& scalar)
{
register i = length();
register double_complex* tp = data();
while (i--) *tp++ += scalar;
return *this;
}

vector& vector::operator -=(vector& u)
{
register i = u.length();
register double_complex* up = u.data();
register double_complex* tp = data();
while (i--) *tp++ -= *up++;
return *this;
}

vector& vector::operator -=(double_complex& scalar)
{
register i = length();
register double_complex* tp = data();
while (i--) *tp++ -= scalar;
return *this;
}

vector& vector::operator *=(vector& u)
{
register i = u.length();
register double_complex* up = u.data();
register double_complex* tp = data();
while (i--) *tp++ *= *up++;
return *this;
}

vector& vector::operator *=(double_complex& scalar)
{
register i = length();
register double_complex* tp = data();
while (i--) *tp++ *= scalar;
return *this;
}

vector& vector::operator /=(vector& u)
{
register i = u.length();
register double_complex* up = u.data();
register double_complex* tp = data();
while (i--) *tp++ /= *up++;
return *this;
}

vector& vector::operator /=(double_complex& scalar)
{
register i = length();
register double_complex* tp = data();
while (i--) *tp++ /= scalar;
return *this;
}

vector operator -(vector& s)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = -(*sp++);
return temp;
}

vector operator +(vector& u, vector& v)
{
register i = v.length();
vector temp(i);
register double_complex* up = u.data();
register double_complex* vp = v.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *up++ + *vp++;
return temp;
}

vector operator -(vector& u, vector& v)
{
register i = v.length();
vector temp(i);
register double_complex* up = u.data();
register double_complex* vp = v.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *up++ - *vp++;
return temp;
}

vector operator *(vector& u, vector& v)
{
register i = v.length();
vector temp(i);
register double_complex* up = u.data();
register double_complex* vp = v.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *up++ * *vp++;
return temp;
}

vector operator /(vector& u, vector& v)
{
register i = v.length();
vector temp(i);
register double_complex* up = u.data();
register double_complex* vp = v.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *up++ / *vp++;
return temp;
}

vector operator +(vector& s, double_complex& scalar)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *sp++ + scalar;
return temp;
}

vector operator -(vector& s, double_complex& scalar)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *sp++ - scalar;
return temp;
}

vector operator -(double_complex& scalar, vector& s)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = scalar - *sp++;
return temp;
}

vector operator *(vector& s, double_complex& scalar)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *sp++ * scalar;
return temp;
}

vector operator /(vector& s, double_complex& scalar)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = *sp++ / scalar;
return temp;
}

vector operator /(double_complex& scalar, vector& s)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = temp.data();
while (i--) *dp++ = scalar / *sp++;
return temp;
}

double_complex dot(vector& u, vector& v)
{
register i = v.length();
double_complex t(0,0);
register double_complex* up = u.data();
register double_complex* vp = v.data();
while (i--) t += *up++ * *vp++;
return t;
}

double_complex prod(vector& s)
{
register i = s.length();
register double_complex* sp = s.data();
double_complex t(1,0);
while (i--) t *= *sp++;
return t;
}

vector reverse(vector& s)
{
register i = s.length();
vector temp(i);
register double_complex* sp = s.data();
register double_complex* dp = &temp(i-1);
while (i--) *(dp--) = *sp++;
return temp;
}

double_complex sum(vector& s)
{
register i = s.length();
register double_complex* sp = s.data();
double_complex t(0,0);
while (i--) t += *sp++;
return t;
}