Отсутствует спецификатор типа, а явный тип отсутствует - PullRequest
Новая
       0

Отсутствует спецификатор типа, а явный тип отсутствует

0 голосов
/ 24 февраля 2020

Я чрезвычайно новичок в текстовом / C ++ программировании (2 дня опыта) и работаю над обновлением DLL, изначально созданной где-то в 1995 году. Я нашел после обновления программы и исправления некоторых базовых c ошибок. имея проблемы, упомянутые в названии.

В частности, 2 типа ошибок - оба происходят в файле. cpp:

  • Каждое значение "i" ниже строки "vector& vector::operator +=(vector& u)" возвращает "явный тип отсутствует (предполагается, что 'int))"

  • Значения из одного символа, такие как "v" (в v.length), "s "и" u "вызывают " отсутствует спецификатор типа - предполагается, что int "

Я нашел информацию о проблемах циклической зависимости, и она кажется очень похожей на проблемы, которые я вижу Однако, поскольку я такой новый, я не могу найти источник ошибки. Устранение ошибок сборки из-за циклической зависимости между классами

У меня есть 1 фрагмент кода и один заголовочный файл, показанный ниже.

Любая помощь будет полезна. Я всегда могу предоставить дополнительную информацию.

Спасибо,

Крис

Заголовочный файл в 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

Код в векторе. 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;
}

1 Ответ

0 голосов
/ 24 февраля 2020

Ключевое слово register больше не используется (начиная с C ++ 17)

Удалите его (и добавьте int, если тип отсутствует). 

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();
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Нет похожих вопросов

...