0

I am extremely new to text based/C++ programming (2 days of exp) and am working on upgrading a DLL originally constructed sometime around 1995. I've found after upgrading the program and fixing some basic errors I am having the issues mentioned in the title.

Specifically 2 types of error - both happen in the .cpp file:

  • Every "i" value below the line "vector& vector::operator +=(vector& u)" returns "explicit type is missing ('int' assumed)"

  • Single character values like "v" (in v.length), "s" and "u" cause "missing type specifier - int assumed"

I've found information regarding circular dependency issues and it seems very similar to the problems I am seeing. However because I am so new, I can't actually find the source of the error. Resolve build errors due to circular dependency amongst classes

I have 1 piece of code and one header file shown below.

Any help would be great. I can always provide further information.

Thanks,

Chris

Header File in 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

Code in Vector.cpp file:

#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;
}
Jarod42
  • 203,559
  • 14
  • 181
  • 302
CAH
  • 3
  • 1
  • 2
    Please copy-paste the *full* and *complete* build output into the question. Also please try to create a [mcve] to show us, with emphasis on the *minimal* part. And also mark out the lines in the code where you get the error, using comments in the code itself. And please take some time to read [ask], as well as [this question checklist](https://codeblog.jonskeet.uk/2012/11/24/stack-overflow-question-checklist/). – Some programmer dude Feb 24 '20 at 16:11

1 Answers1

0

Keyword register is no longer used (since C++17)

Remove it (and add int when type is missing).

register i = u.length();
register double_complex* up = u.data();
register double_complex* tp = data();

->

int i = u.length();
double_complex* up = u.data();
double_complex* tp = data();
Jarod42
  • 203,559
  • 14
  • 181
  • 302