[bcc32c Error]: no matching function for call to 'strcpy'

#ifdef _WIN32
#include <tchar.h>
#include <vcl.h>
#include <math.h>
#include <stdio.h>
#include <cstring>
#include <string>
#include <iostream>
#include "_str.h"
using namespace std;
#endif
 
class TComplex : public TObject // Реализация комплексного числа вида Re +i* Im
{
    double cRe; // Действительная часть
    double cIm; // Мнимая часть
    String Get(void) const;
    String GetRe(void) const;
    String GetIm(void) const;
public:
    TComplex(double reTemp = 0, double imTemp = 0) : cRe(reTemp), cIm(imTemp) {}; // Конструктор
    TComplex(char str[]); // Конструктор
    TComplex(const TComplex& P); // Конструктор копирования
    TComplex*  operator + (const TComplex& T); // Сложение
    TComplex*  operator - (const TComplex& T); // Вычитание
    TComplex*  operator * (const TComplex& B); // Умножение
    TComplex*  operator / (const TComplex& B); // Деление
    TComplex*  operator - (void); // Минус
    TComplex*   Square(void); // Квадрат
    TComplex*   Invert(void); // Обратное
    double      Magnitude(void); // Модуль
    double      AngleRad(void); // УголРад
    double      AngleDeg(void); // УголГрад
    TComplex*   Power(int n); // Степень
    TComplex*   Root(int n, int i); // Корень n - степень; i - i-й корень
    bool    operator == (const TComplex& T); // Равно
    __property double Re = { read = cRe, write = cRe }; // Чтение и запись Re
    __property double Im = { read = cIm, write = cIm }; // Чтение и запись Im
    __property String ReStr = { read = GetRe }; // Чтение Re (строка)
    __property String ImStr = { read = GetIm }; // Чтение Im (строка)
    __property String Complex = { read = Get }; // Чтение объекта в формате строки
};
 
String TComplex::GetRe(void) const
{
    String reTemp;
    char Res[10];
    reTemp = FloatToStr(cRe);
    [COLOR="red"]strcpy(Res, reTemp.c_str());[/COLOR]
    return Res;
};
 
String TComplex::GetIm(void) const
{
    String imTemp;
    char Res[10];
    imTemp = FloatToStr(cIm);
    [COLOR="Red"]strcpy(Res, imTemp.c_str());[/COLOR]
    return Res;
};
 
String TComplex::Get(void) const
{
    String reTemp, imTemp;
    char Res[23];
    reTemp = FloatToStr(cRe);
    strcpy(Res, reTemp.c_str());
    strcat(Res, "+i*");
    imTemp = FloatToStr(cIm);
    [COLOR="red"]strcat(Res, imTemp.c_str());[/COLOR]
    return Res;
};
 
TComplex::TComplex(char str[]) // Конструктор
{
    cRe = StrToFloat(strtok(str, "+i*"));
    cIm = StrToFloat(strtok(NULL, "+i*"));
};
 
TComplex::TComplex(const TComplex& P) // Конструктор копирования
{
    Re = P.Re;
    Im = P.Im;
};
 
TComplex* TComplex::operator + (const TComplex& T) // Сложение
{
    double reTemp = Re + T.Re;
    double imTemp = Im + T.Im;
    TComplex* Res = new TComplex(reTemp, imTemp);
    return Res;
};
 
TComplex* TComplex::operator - (const TComplex& T) // Вычитание
{
    double reTemp = Re - T.Re;
    double imTemp = Im - T.Im;
    TComplex* Res = new TComplex(reTemp, imTemp);
    return Res;
};
 
TComplex* TComplex::operator * (const TComplex& B) // Умножение
{
    double reTemp = Re * B.Re - Im * B.Im;
    double imTemp = Re * B.Im + Im * B.Re;
    TComplex* Res = new TComplex(reTemp, imTemp);
    return Res;
};
 
TComplex* TComplex::operator / (const TComplex& B) // Деление
{
    if ((B.Re != 0) && (B.Im != 0))
    {
        double reTemp = ((Re * B.Re + Im * B.Im) / (B.Re * B.Re + B.Im * B.Im));
        double imTemp = ((Im * B.Re - Re * B.Im) / (B.Re * B.Re + B.Im * B.Im));
        TComplex* Res = new TComplex(reTemp, imTemp);
        return Res;
    }
    else
    {
        TComplex* Res = new TComplex(0, 0);
        return Res;
    }
};
 
TComplex* TComplex::operator - (void) // Минус
{
    double reTemp = 0 - Re;
    double imTemp = 0 - Im;
    TComplex* Res = new TComplex(reTemp, imTemp);
    return Res;
};
 
TComplex* TComplex::Square(void) // Квадрат
{
    double reTemp = Re * Re - Im * Im;
    double imTemp = Re * Im + Im * Re;
    TComplex* Res = new TComplex(reTemp, imTemp);
    return Res;
};
 
TComplex* TComplex::Invert(void) // Обратное
{
    if ((Re != 0) && (Im != 0))
    {
        double reTemp = Re / (Re * Re + Im * Im);
        double imTemp = Im / (Re * Re + Im * Im);
        TComplex* Res = new TComplex(reTemp, imTemp);
        return Res;
    }
    else
    {
        TComplex* Res = new TComplex(0, 0);
        return Res;
    }
};
 
double TComplex::Magnitude(void) // Модуль
{
    double Res = sqrt(Re * Re + Im * Im);
    return Res;
};
 
double TComplex::AngleRad(void) // УголРад
{
    double Res;
    if (Re > 0) Res = atan(Im / Re);
    else
        if ((Re == 0) && (Im > 0)) Res = M_PI_2;
        else
            if (Re < 0) Res = atan(Im / Re) + M_PI;
            else
                if ((Re == 0) && (Im < 0)) Res = -M_PI_2;
                else
                    Res = 0;
    return Res;
};
 
double TComplex::AngleDeg(void) // УголГрад
{
    double Res;
    if (Re > 0) Res = (atan(Im / Re) * 360) / (2 * M_PI);
    else
        if ((Re == 0) && (Im > 0)) Res = 90;
        else
            if (Re < 0) Res = ((atan(Im / Re) + M_PI) * 360) / (2 * M_PI);
            else
                if ((Re == 0) && (Im < 0)) Res = -90;
                else
                    Res = 0;
    return Res;
};
 
TComplex* TComplex::Power(int n) // Степень
{
    double reTemp, imTemp, fi, magn;
    fi = (*this).AngleRad();
    magn = (*this).Magnitude();
    reTemp = pow(magn, n) * (cos(n * fi));
    imTemp = pow(magn, n) * (sin(n * fi));
    TComplex* Res = new TComplex(reTemp, imTemp);
    return Res;
};
 
TComplex* TComplex::Root(int n, int i) // Корень n - степень, i - i-й корень
{
    double reTemp, imTemp, fi, magn;
    fi = (*this).AngleRad();
    magn = (*this).Magnitude();
    reTemp = pow(magn, 1 / n) * (cos((fi + 2 * (i - 1) * M_PI) / n));
    imTemp = pow(magn, 1 / n) * (sin((fi + 2 * (i - 1) * M_PI) / n));
    TComplex* Res = new TComplex(reTemp, imTemp);
    return Res;
};
 
bool TComplex::operator == (const TComplex& T) // Равно
{
    if ((Re == T.Re) && (Im == T.Im))
        return true;
    else
        return false;
};