Errors compile patterns(singleton + fabric methods + visitor)

so I encounter with problem of linking but I already have reivewed it and have read about realizing the pattern visitor and I have not understand this errors( above 100)

patterns singleton + fabric method is worked, but after visitor's everything collapses.

error C2664: "void CVisitor::visit(CCircle &)": cannot convert argument 1 from "CTriangle" in "CRectangle &"
triangle.cpp(22)

When implementing the visitor pattern relied on such sources:

http://ift.tt/UTeqjL

This project(Compilator: Microsoft Visual Studio 2015 Ultimate)

-> Download: http://ift.tt/1Yqb45Q

idea of programme is realise the classes of figures such as: the triangle, the rectangle and the circle , using the patterns which is given above

I wil not upload all the cods because a lot o them. But I will apload realisation one of the figure because all figures are equally implemented.

Figure.h - base class for circle, triangle and rectangle

#pragma once
#include "stdafx.h"
#include "Visitor.h"

class CFigure
{
public:
    virtual void accept(CVisitor &visit/*, std::ofstream &outputFile*/) = 0;
};


class CFabricCreator
{
public:
    virtual CFigure* FabricCreateFigure() = 0;
    virtual ~CFabricCreator() {}
    virtual bool DeleteInstace() = 0;
};
```

  Triangle.h - triangle class

#pragma once
#include "Figure.h"
#include "Visitor.h"

class CTriangle : public CFigure
{
public:
    CTriangle(Point point1, Point point2, Point point3);
    ~CTriangle();
    void accept(CVisitor &v/*, std::ofstream &outputFile*/);

    std::string GetArea() ;
    std::string GetPerimeter();
    void PrintInFileInfo(/*std::ofstream &file*/);
private:
    Point m_point1, m_point2, m_point3;
    std::string Dlina(std::string a1, std::string b1, std::string a2, std::string b2);
};

class TriangleCreator : public CFabricCreator
{
public:
    static TriangleCreator *GetInstance(Point point1, Point point2, Point point3)
    {
        if (!m_instance)
        {
            m_instance = new TriangleCreator(point1, point2, point3);
        }
        return m_instance;
    }

    bool DeleteInstace()
    {
        if (m_instance)
        {
            delete m_instance;
            m_instance = 0;
            return true;
        }
        return false;
    }

    CFigure *FabricCreateFigure()
    {
        return new CTriangle(m_point1, m_point2, m_point3);
    }

    ~TriangleCreator()
    {
    }

protected:
    TriangleCreator(Point point1, Point point2, Point point3) :
        m_point1(point1), m_point2(point2), m_point3(point3) {}

    TriangleCreator(const TriangleCreator& triangleCreator);

    static TriangleCreator *m_instance;

private:
    Point m_point1;
    Point m_point2;
    Point m_point3;
};

  Visitor.h - class visitor

#pragma once
#include "Rectangle.h"
#include "Circle.h"
#include "Triangle.h"

class CVisitor
{
public:
    virtual void visit(CRectangle&rec/*, std::ofstream &outputFile*/) = 0;
    virtual void visit(CTriangle&triag/*, std::ofstream &outputFile*/) = 0;
    virtual void visit(CCircle&circ/*, std::ofstream &outputFile*/) = 0;
};


class CPrintVisitor : public CVisitor
{
public:
    void visit(CRectangle &rec/*, std::ofstream &outputFile*/);
    void visit(CTriangle &triag/*, std::ofstream &outputFile*/);
    void visit(CCircle &circ/*, std::ofstream &outputFile*/);
};

Triangle.cpp

#include "stdafx.h"
#include "Triangle.h"


TriangleCreator *TriangleCreator::m_instance = 0;

CTriangle::CTriangle(Point point1,Point point2, Point point3)
:
m_point1(point1),
m_point2(point2),
m_point3(point3)
{
}


CTriangle::~CTriangle()
{
}

void CTriangle::accept(CVisitor &v/*, std::ofstream &outputFile*/)
{
    v.visit(*this/*, outputFile*/);
}

std::string CTriangle::GetArea()
{
    CLongArithmetic point1Minus3x = (CLongArithmetic(m_point1.x) - CLongArithmetic(m_point3.x));
    CLongArithmetic point2Minus3y = (CLongArithmetic(m_point2.y) - CLongArithmetic(m_point3.y));
    CLongArithmetic point2Minus3x = (CLongArithmetic(m_point2.x) - CLongArithmetic(m_point3.x));
    CLongArithmetic point1Minus3y = (CLongArithmetic(m_point1.y) - CLongArithmetic(m_point3.y));
    CLongArithmetic multiply1With2 = point1Minus3x * point2Minus3y;
    CLongArithmetic multiply3With4 = point2Minus3x * point1Minus3y;
    CLongArithmetic divide = multiply3With4 - multiply1With2;
    CLongArithmetic result = divide / 2;

    return result.ToString();

//  return ((m_point1.x - m_point3.x) * (m_point2.y - m_point3.y) \
//  - (m_point2.x - m_point3.x) * (m_point1.y - m_point3.y)) / 2;
}

std::string CTriangle::GetPerimeter() 
{
    CLongArithmetic AB(Dlina(m_point1.x, m_point1.y, m_point2.x, m_point2.y));
    CLongArithmetic AC(Dlina(m_point1.x, m_point1.y, m_point3.x, m_point3.y));
    CLongArithmetic BC(Dlina(m_point2.x, m_point2.y, m_point3.x, m_point3.y));
    CLongArithmetic result = AB + AC + BC;
    return result.ToString();
}

std::string CTriangle::Dlina(std::string a1, std::string b1, std::string a2, std::string b2)
{
    CLongArithmetic local_a1(a1);
    CLongArithmetic local_b1(b1);
    CLongArithmetic local_a2(a2);
    CLongArithmetic local_b2(b2);
    CLongArithmetic a1a2 = (local_a1 - local_a2) * (local_a1 - local_a2);
    CLongArithmetic b1b2 = (local_b1 - local_b2) * (local_b1 - local_b2);
    CLongArithmetic summ = a1a2 + b1b2;
    CLongArithmetic sqrtNumber = summ.bigSqrt();

    return sqrtNumber.ToString();
}

void CTriangle::PrintInFileInfo(/*std::ofstream &file*/)
{
    ofstream file("output.txt");
    file << "CIRCLE: P = " << GetArea() << "; S = " << GetPerimeter();
    file << std::endl;
}

Visitor.cpp

#include "stdafx.h"
#include "Visitor.h"

void CPrintVisitor::visit(CRectangle &rec/*, std::ofstream &outputFile*/)
{
    rec.PrintInFileInfo(/*outputFile*/);
}

void CPrintVisitor::visit(CTriangle &triag/*,std::ofstream &outputFile*/)
{
    triag.PrintInFileInfo(/*outputFile*/);
}

void CPrintVisitor::visit(CCircle &circ/*, std::ofstream &outputFile*/)
{
    circ.PrintInFileInfo(/*outputFile*/);
}

Main

#include "stdafx.h"
#include "Figure.h"
#include "Circle.h"
#include "Rectangle.h"
#include "Triangle.h"
#include "Visitor.h"

using namespace std;




size_t SwitchFunc(string buf, string* protoCommands)
{
    for (size_t i = 0; i < 3; ++i)
    {
        if (buf == protoCommands[i])
        {
            return i;
        }
    }
    return -1;
}

string GetNumber(string &line, int &count)
{
    string tempNumber;
    count++;
    if (!isdigit(line[count]))
    {
        while (!isdigit(line[count]) || count > line.length())
        {
            count++;
        }
    }
    while (isdigit(line[count]))
    {
        tempNumber += line[count];
        count++;
    }
    return tempNumber;
}

void GetData(string line, vector<Point> &points)
{
    int count = 0;
    int index = 0;
    string tempNumber;
    while (/*line[count] != '\n' || */count < line.length())
    {
        if (line[count] == 'P')
        {
            count += 2;
        }
        if (line[count] == '=')
        {
            tempNumber = GetNumber(line, count);
            points[index].x = tempNumber.c_str();
        }
        if (line[count] == ',')
        {
            tempNumber = GetNumber(line, count);
            points[index].y = tempNumber.c_str();
            index++;
        }
        count++;
    }

}


void ApplyCommands(ifstream &file, ofstream &outputFile, CFabricCreator *figure)
{
    string line;

    vector<CFigure*> figures;
    //TODO: паттерн посетитель
    CPrintVisitor printVisitor;

    while (getline(file, line, '\n'))
    {
        string commands[3]
        {
            "TRIANGLE:",
            "RECTANGLE:",
            "CIRCLE:",
        };
        stringstream stringStream;
        stringStream << line;

        string commandInLine;

        stringStream >> commandInLine;
        if (line.find('\n') == std::string::npos)
        {
            try
            {
            switch (SwitchFunc(commandInLine, commands))
            {
            case 0:
            {
                //TRIANGLE
                if (stringStream >> commands[0])
                {
                    Point triagPoint1 = Point();
                    Point triagPoint2 = Point();
                    Point triagPoint3 = Point();
                    vector<Point> points = { triagPoint1, triagPoint2, triagPoint3 };
                    GetData(line, points);
                    figure = TriangleCreator::GetInstance(points[0], points[1], points[2]);
                    figures.push_back(figure->FabricCreateFigure());
                    figure->DeleteInstace();
                    points.clear();
                    break;
                }
            }
            case 1:
            {
                //RECTANGLE
                if (stringStream >> commands[1])
                {
                    Point recPoint1 = Point();
                    Point recPoint2 = Point();
                    vector<Point> points = { recPoint1, recPoint2 };
                    GetData(line, points);
                    figure = RectangleCreator::GetInstance(points[0], points[1]);
                    figures.push_back(figure->FabricCreateFigure());
                    figure->DeleteInstace();
                    points.clear();
                    break;
                }
            }
            case 2:
            {
                //Circle
                if (stringStream >> commands[2])
                {
                    Point cirCernter = Point();
                    Point cirRadius = Point();
                    vector<Point> points = { cirCernter, cirRadius };
                    GetData(line, points);
                    figure = CircleCreator::GetInstance(points[0], points[1].x);
                    figures.push_back(figure->FabricCreateFigure());
                    figure->DeleteInstace();
                    points.clear();
                    break;
                }

            }
            default:
                outputFile << "Неправильная команда" << endl;

            }
            }
            catch ( std::exception &ex)
            {
                cout << ex.what() << endl;
            }
        }
    }
    for (int i = 0; i < figures.size(); i++)
    {
        figures[i]->accept(printVisitor);
        //figures[i]->PrintInFileInfo(outputFile);
        //PrintInFileInfo(figures[i].accept(areaOperation), figures[i].accept(perimetrOperation));
    }
}


int _tmain(int argc, _TCHAR* argv[])
{
     int PARAMS_COUNT = 2;
//  if (argc != PARAMS_COUNT)
//  {
//      cout << "Error of number arguments!" << endl;
//      return 0;
//  }
    CFabricCreator *figure = nullptr;
//  ifstream inputFile(argv[1]);
//  ofstream outputFile(argv[2]);
    ifstream inputFile("input.txt");
    ofstream outputFile("output.txt");
    if (!(inputFile.is_open()))
    {
        cout << "Error of read file" << endl;
        return 0;
    }
    if (!(outputFile.is_open()))
    {
        cout << "Error of write output file" << endl;
        return 0;
    }
    ApplyCommands(inputFile, outputFile, figure);
    outputFile.close();
    inputFile.close();
    if (figure != nullptr)
        delete figure;
    getchar();
    return 0;
}