Ошибка С2061 по непонятным причинам

В моей программе (лабораторная работа на тему наследования по Павловской) возникает ряд ошибок указывающих на то, что я сделал синтаксическую ошибку. Такое поведение появилось когда я стал писать методы для класса Triangle.h наследного от Factory.h. Пробовал убрать подключение классов Triangle и Tetragon из Tetragon.h и Rectangle.h соответственно - не помогло. Ошибку показывает в хедерах классов. Как её можно исправить и каковы в принципе причины возникновения подобных ошибок?

UPD: Сделал предварительное объявление классов дабы устранить перекрёстный инклуд, в итоге к старым ошибкам добавилось ещё 147 ошибок. До того, как я описал в Triangle методы Move и PointIsIncluded - всё работало.

Прилагаю коды хедеров и выхлоп окна ошибок ошибки:

Ошибка 1 error C2061: синтаксическая ошибка: идентификатор "Triangle" 26 1 (В хедере Tetragon.h по одному разу в строке 25 и 26, я их пометил комментариями)

Ошибка 5 error C2061: синтаксическая ошибка: идентификатор "Tetragon" 32 1 (В хедере Triangle.h по 2 раза в строке 32 и 33(почему в одной строке она встретилась 2 раза?) тоже помечены)

    /*Triangle.h*/
    #pragma once
    #include "Factory.h"
    #include <iostream>
    #include "pre_tetragon.h"
    using namespace std;
    class Triangle: protected Factory
    {
    private:
        const int size = 3; //размер массива    
    public:
        float K[3]; //коэффициенты равенства уравнений
        float coordx[3]; // координаты Х точек фигуры
        float coordy[3]; // координаты y точек фигуры
        bool IntersectLine[3]; // сколько точек находится в другой фигуре
        float minx, miny, maxx, maxy; // проекции на оси
        float interPointX[3]; //Х точки пересечения
        /*МЕТОДЫ*/
    private:
        void WriteFormation()
        {
            cout << "formation     0" << endl;
            cout << "           2     1" << endl;
        }
    public:
        Triangle();
        Triangle(float x1, float y1, float x2, float y2, float x3, float y3);
        ~Triangle();
        void CalcBorders(); // высчитываем границы полигона
        void Move(float onX, float onY);
        bool IsInclude(Tetragon Tet);//ошибка тут
        bool PointIsInclude(Tetragon Tet, int L);//и тут
    };

    /*Tetragon.h*/
    #pragma once
    #include "Factory.h"
    #include <iostream>
    #include "pre_triangle.h"
    using namespace std;
    class Tetragon :protected Factory
    {
        //ПЕРЕМЕННЫЕ
    private:
        const int size = 4; //размер массива    
    public:
        float K[4]; //коэффициенты равенства уравнений
        float coordx[4]; // координаты Х точек фигуры
        float coordy[4]; // координаты y точек фигуры
        bool IntersectLine[4];//существует ли пересечение некоторой данной линии.
        float minx, miny, maxx, maxy; // Крайние точки полигона - мысы
        float interPointX[4]; //Х точки пересечения
        //МЕТОДЫ
    public:
        Tetragon(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);
        Tetragon();
        ~Tetragon();
        void CalcBorders(); // высчитываем границы полигона
        void Move(float onX, float onY); 
        bool IsInclude(Triangle Tri);//ошибка встречается тут
        bool PointIsInclude(Triangle Tri, int L);//и тут
    private:
        void WriteFormation()
        {
            cout << "formation    0   1" << endl;
            cout << "             3   2" << endl;
        }
    };
    /*Код Factory.h*/
    #pragma once
    class Factory
    {
    protected: 
        float RetMaxX(float *x, int size); // Методы получения мысов фигуры
        float RetMinX(float *x, int size);
        float RetMaxY(float *y, int size);
        float RetMinY(float *y, int size);
        float CalcK(float *y, float y0, int i, int j);
        float CalcPointX(float *x, float K, int i, int j);
    //  bool Factory::CalcEqu(float px, float *x, int i, int j, float K);
    public:
        Factory();
        void ShowFig(float *x, float *y, int size);
        void setCoordinates(float *x, float *y, int size);
        void virtual  WriteFormation();
        ~Factory();
    };
    /*код pre_triangle.h и pre_tetragon.h*/
    #pragma once
    class Triangle;
/*____________________________*/
    #pragma once
    class Tetragon;
/*CPP файлы*/
    /*Triangle.cpp*/
    #pragma once
    #include "stdafx.h"
    #include "Triangle.h"
    #include <iostream>
    #include "Tetragon.h"
    using namespace std;
    void Triangle::Move(float onX = 0, float onY = 0)
    {
        for (int i = 0; i < size; i++)
        {
            coordx[i] = coordx[i] + onX;
            coordx[i] = coordy[i] + onY;
        }
    }
    void Triangle::CalcBorders()
    {
        minx = RetMinX(coordx, 3);
        miny = RetMinY(coordy, 3);
        maxx = RetMaxX(coordx, 3);
        maxy = RetMaxY(coordy, 3);
    }
    bool Triangle::PointIsInclude(Tetragon Tet, int L)
    {
        for (int P = 0; P < 3; P++)
            IntersectLine[P] = false;
        //находит коэффициент равенства уравнений
        K[0] = CalcK(coordy, Tet.coordy[L], 0, 1);
        K[1] = CalcK(coordy, Tet.coordy[L], 1, 2);
        K[2] = CalcK(coordy, Tet.coordy[L], 2, 0);
        //ищем мысы
        CalcBorders();
        /*Словесный алгоритм
        Изначально у нас есть только У = b это у нас луч параллельный Ох и исходя из У мы должны найти Х точки пересечения.
        Если он лежит в границах полигона то засчитываем пересечение, важно проверить, чтобы Х точки пересечения луча с ребром полигона был больше чем значение Х самой точки которую мы проверяем. */
        if (!std::isinf(K[0]))
            interPointX[0] = CalcPointX(coordx, K[0], 0, 1);
        else interPointX[0] = NAN;
        if (!std::isinf(K[1]))
            interPointX[1] = CalcPointX(coordx, K[1], 1, 2);
        else interPointX[1] = NAN;
        if (!std::isinf(K[2]))
            interPointX[2] = CalcPointX(coordx, K[2], 2, 0);
        else interPointX[2] = NAN;
        //проходим финальные условия - если точка в мысу И точки удовлетворяют уравнению - возвращаем TRUE
        //здесь отображены пересечения линий. Дальше нужно подсчитать количество этих пересечений
        for (int ID = 0; ID < 3; ID++)
        {
            if (interPointX[ID] == interPointX[ID])
            {
                if (interPointX[ID] > Tet.coordx[L])
                {
                    if ((interPointX[ID] <= maxx) && (interPointX[ID] >= minx) && (Tet.coordy[L] <= maxy) && (Tet.coordy[L] >= miny))
                    {
                        IntersectLine[ID] = true;
                    }
                }
            }
        }
        float *mast = new float[4];
        for (int i = 0; i < 3; i++)
        {
            mast[i] = interPointX[i];
        }
        mast[3] = interPointX[0];
        for (int i = 0; i < 4; i++)
        {
            if (mast[i] == mast[i + 1])
            {
                IntersectLine[i] = false;
            }
        }
        delete mast;
        int Intersects = 0;
        for (int ID = 0; ID < 4; ID++)
        {
            if (IntersectLine[ID] == true) Intersects++;
        }
        if (Intersects % 2 == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    Triangle::Triangle(float x1, float y1, float x2, float y2, float x3, float y3)
    {
        coordx[0] = x1;
        coordx[1] = x2;
        coordx[2] = x3;
        coordy[0] = y1;
        coordy[1] = y2;
        coordy[2] = y3;
    }
    Triangle::Triangle()
    {
        WriteFormation();
        for (int i = 0; i < size; i++)
        {
            coordx[i] = 0;
            coordy[i] = 0;
        }
    }

    Triangle::~Triangle()
    {
    }

    /*Tetragon.cpp*/
    #include "stdafx.h"
    #include "Tetragon.h"
    #include "Triangle.h"
    /*Да гори оно уже синим пламенем*/
    /*переписать isInclude

    */
    Tetragon::Tetragon()
    {
        setCoordinates(coordx, coordy, 4);
    }

    void Tetragon::Move(float onX = 0, float onY = 0)
    {
        for (int i = 0; i < size; i++)
        {
            coordx[i] = coordx[i] + onX;
            coordy[i] = coordy[i] + onY;
        }
    }
    void Tetragon::CalcBorders()
    {
        minx = RetMinX(coordx, 4);
        miny = RetMinY(coordy, 4);
        maxx = RetMaxX(coordx, 4);
        maxy = RetMaxY(coordy, 4);
    }
    /*void Tetragon::CalculateK_s(Triangle Tri)
    {
        K[0] = CalcK(coordy, Tri.y[0], 0, 1);
        K[1] = CalcK(coordy, Tri.y[1], 1, 2);
        K[2] = CalcK(coordy, Tri.y[2], 2, 3);
        K[3] = CalcK(coordy, Tri.y[3], 3, 0);
    }*/
    bool Tetragon::PointIsInclude(Triangle Tri, int L)
    {
        for (int P = 0; P < 4; P++)
            IntersectLine[P] = false;
        //находит коэффициент равенства уравнений
        K[0] = CalcK(coordy,Tri.coordy[L], 0, 1);
        K[1] = CalcK(coordy, Tri.coordy[L], 1, 2);
        K[2] = CalcK(coordy, Tri.coordy[L], 2, 3);
        K[3] = CalcK(coordy, Tri.coordy[L], 3, 0);
        //ищем мысы
        CalcBorders();
        /*Словесный алгоритм
        Изначально у нас есть только У = b это у нас луч параллельный Ох и исходя из У мы должны найти Х точки пересечения.
        Если он лежит в границах полигона то засчитываем пересечение, важно проверить, чтобы Х точки пересечения луча с ребром полигона был больше чем значение Х самой точки которую мы проверяем. */
        if (!std::isinf(K[0]))
        interPointX[0] = CalcPointX(coordx, K[0], 0, 1);
        else interPointX[0] = NAN;
        if (!std::isinf(K[1]))
        interPointX[1] = CalcPointX(coordx, K[1], 1, 2);
        else interPointX[1] = NAN;
        if (!std::isinf(K[2]))
        interPointX[2] = CalcPointX(coordx, K[2], 2, 3);
        else interPointX[2] = NAN;
        if (!std::isinf(K[3]))
        interPointX[3] = CalcPointX(coordx, K[3], 3, 0);
        else interPointX[3] = NAN;
        //проходим финальные условия - если точка в мысу И точки удовлетворяют уравнению - возвращаем TRUE
        //здесь отображены пересечения линий. Дальше нужно подсчитать количество этих пересечений
        for (int ID = 0; ID < 4; ID++)
        {
            if (interPointX[ID] == interPointX[ID])
            {
                if (interPointX[ID] > Tri.coordx[L])
                {
                    if ((interPointX[ID] <= maxx) && (interPointX[ID] >= minx) && (Tri.coordy[L] <= maxy) && (Tri.coordy[L] >= miny))
                    {
                        IntersectLine[ID] = true;
                    }
                }
            }
        }
        float *mast = new float[5];
        for (int i = 0; i < 4; i++)
        {
            mast[i] = interPointX[i];
        }
        mast[4] = interPointX[0];
        for (int i = 0; i < 4; i++)
        {
            if (mast[i] == mast[i + 1])
            {
                IntersectLine[i] = false;
            }
        }
        delete mast;
        int Intersects = 0;
        for (int ID = 0; ID < 4; ID++)
        {
            if (IntersectLine[ID] == true) Intersects++;
        }
        if (Intersects % 2 == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    bool Tetragon::IsInclude(Triangle Tri)
    {
        bool IsInclude = false;
        int Includes = 0;
        for (int ID = 0; ID < 3; ID++)
        {
            if (PointIsInclude(Tri, ID))
            {
                Includes++;
            }
        }
        if (Includes == 3) IsInclude = true;
        return IsInclude;
    }
    Tetragon::Tetragon(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
    {
        coordx[0] = x1; coordy[0] = y1; 
        coordx[1] = x2; coordy[1] = y2;
        coordx[2] = x3; coordy[2] = y3;
        coordx[3] = x4; coordy[3] = y4; 
    }
    Tetragon::~Tetragon()
    {
    }
    /*Tetragon.cpp*/
    #include "stdafx.h"
    #include "Tetragon.h"
    #include "Triangle.h"
    Tetragon::Tetragon()
    {
        setCoordinates(coordx, coordy, 4);
    }
    void Tetragon::Move(float onX = 0, float onY = 0)
    {
        for (int i = 0; i < size; i++)
        {
            coordx[i] = coordx[i] + onX;
            coordy[i] = coordy[i] + onY;
        }
    }
    void Tetragon::CalcBorders()
    {
        minx = RetMinX(coordx, 4);
        miny = RetMinY(coordy, 4);
        maxx = RetMaxX(coordx, 4);
        maxy = RetMaxY(coordy, 4);
    }
    /*void Tetragon::CalculateK_s(Triangle Tri)
    {
        K[0] = CalcK(coordy, Tri.y[0], 0, 1);
        K[1] = CalcK(coordy, Tri.y[1], 1, 2);
        K[2] = CalcK(coordy, Tri.y[2], 2, 3);
        K[3] = CalcK(coordy, Tri.y[3], 3, 0);
    }*/
    bool Tetragon::PointIsInclude(Triangle Tri, int L)
    {
        for (int P = 0; P < 4; P++)
            IntersectLine[P] = false;
        //находит коэффициент равенства уравнений
        K[0] = CalcK(coordy,Tri.coordy[L], 0, 1);
        K[1] = CalcK(coordy, Tri.coordy[L], 1, 2);
        K[2] = CalcK(coordy, Tri.coordy[L], 2, 3);
        K[3] = CalcK(coordy, Tri.coordy[L], 3, 0);
        //ищем мысы
        CalcBorders();
        /*Словесный алгоритм
        Изначально у нас есть только У = b это у нас луч параллельный Ох и исходя из У мы должны найти Х точки пересечения.
        Если он лежит в границах полигона то засчитываем пересечение, важно проверить, чтобы Х точки пересечения луча с ребром полигона был больше чем значение Х самой точки которую мы проверяем. */
        if (!std::isinf(K[0]))
        interPointX[0] = CalcPointX(coordx, K[0], 0, 1);
        else interPointX[0] = NAN;
        if (!std::isinf(K[1]))
        interPointX[1] = CalcPointX(coordx, K[1], 1, 2);
        else interPointX[1] = NAN;
        if (!std::isinf(K[2]))
        interPointX[2] = CalcPointX(coordx, K[2], 2, 3);
        else interPointX[2] = NAN;
        if (!std::isinf(K[3]))
        interPointX[3] = CalcPointX(coordx, K[3], 3, 0);
        else interPointX[3] = NAN;
        //проходим финальные условия - если точка в мысу И точки удовлетворяют уравнению - возвращаем TRUE
        //здесь отображены пересечения линий. Дальше нужно подсчитать количество этих пересечений
        for (int ID = 0; ID < 4; ID++)
        {
            if (interPointX[ID] == interPointX[ID])
            {
                if (interPointX[ID] > Tri.coordx[L])
                {
                    if ((interPointX[ID] <= maxx) && (interPointX[ID] >= minx) && (Tri.coordy[L] <= maxy) && (Tri.coordy[L] >= miny))
                    {
                        IntersectLine[ID] = true;
                    }
                }
            }
        }
        float *mast = new float[5];
        for (int i = 0; i < 4; i++)
        {
            mast[i] = interPointX[i];
        }
        mast[4] = interPointX[0];
        for (int i = 0; i < 4; i++)
        {
            if (mast[i] == mast[i + 1])
            {
                IntersectLine[i] = false;
            }
        }
        delete mast;
        int Intersects = 0;
        for (int ID = 0; ID < 4; ID++)
        {
            if (IntersectLine[ID] == true) Intersects++;
        }
        if (Intersects % 2 == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    bool Tetragon::IsInclude(Triangle Tri)
    {
        bool IsInclude = false;
        int Includes = 0;
        for (int ID = 0; ID < 3; ID++)
        {
            if (PointIsInclude(Tri, ID))
            {
                Includes++;
            }
        }
        if (Includes == 3) IsInclude = true;
        return IsInclude;
    }
    Tetragon::Tetragon(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
    {
        coordx[0] = x1; coordy[0] = y1; 
        coordx[1] = x2; coordy[1] = y2;
        coordx[2] = x3; coordy[2] = y3;
        coordx[3] = x4; coordy[3] = y4; 
    }
    Tetragon::~Tetragon()
    {
    }
    /*Factory.cpp*/
    #include "stdafx.h"
    #include "Factory.h"
    #include <iostream>
    using namespace std;
    void Factory::ShowFig(float *x, float *y ,int size)
    {
        for (int i = 0; i < size; i++)
        {
            cout << "x = " << x[i] << ",    y = " << y[i] << ";" << endl;
        }
    }
    void Factory::WriteFormation()
    {}
    void Factory::setCoordinates(float *x, float *y, int size)
    {
        cout << "input coordinates of points" << endl;
        WriteFormation();
        for (int i = 0; i < size; i++)
        {
            cin >> x[i] >> y[i];
        }
    }
    float Factory::RetMaxX(float *x, int size)
    {
        float xMax = FLT_MIN;
        for (int i = 0; i < size; i++){
            if (x[i] > xMax) xMax = x[i];
        }
        return xMax;
    }
    float Factory::RetMinX(float *x, int size)
    {
        float xMin = FLT_MAX;
        for (int i = 0; i < size; i++){
            if (x[i] < xMin) xMin = x[i];
        }
        return xMin;
    }
    float Factory::RetMaxY(float *y, int size)
    {
        float yMax = FLT_MIN;
        for (int i = 0; i < size; i++){
            if (y[i] > yMax) yMax = y[i];
        }
        return yMax;
    }
    float Factory::RetMinY(float *y, int size)
    {
        float yMin = FLT_MAX;
        for (int i = 0; i < size; i++){
            if (y[i] < yMin) yMin = y[i];
        }
        return yMin;
    }
    float Factory::CalcK(float *y, float y0, int i, int j)
    {
        //i - первый
        //j - второй
        float k = 0;
        k = (y0 - y[i]) / (y[j] - y[i]);
        return k;
    }
    float Factory::CalcPointX(float *x, float K, int i, int j)
    {
        float x0 = 0;
        x0 = K * (x[j] - x[i]) + x[i];//X[j] - x2, x[i] - x1, x0 - искомый х
        return x0;
    }
    /*bool Factory::CalcEqu(float px, float *x, int i, int j, float K)
    {
        if ((px - x[i]) / (x[j] - x[i]) == K)
            return true;
    }*/
    Factory::Factory()
    {
    }

    Factory::~Factory()
    {
    }