C++ 从wxString转换为double时，小数位数解释为零

我正在使用wxWidgets for GUI，我需要将文本框中的字符串转换为双精度字符串，以便正确处理它们并将其用于计算，但该程序似乎将所有小数点替换为0。这是我将它从wxString转换为double的时候。我评论了错误发生的地方。我想你可能会看到整个代码。就在下面。代码如下：

C++代码：

#include <wx/wx.h>
#include "determinantsFrame.h"
#include "starter.h"
#include <cmath>
#include <ctype.h>

using namespace std;

BEGIN_EVENT_TABLE(determinantsFrame, wxFrame)
    EVT_MENU(wxID_ABOUT, determinantsFrame::OnAbout)
    EVT_MENU(wxID_EXIT, determinantsFrame::OnQuit)
    EVT_CLOSE(determinantsFrame::OnClose)
    EVT_BUTTON(ID_Calculate, determinantsFrame::OnCalculateClick)
    EVT_BUTTON(ID_Reset, determinantsFrame::OnResetClick)
    EVT_BUTTON(ID_Fill, determinantsFrame::OnFillEmptyCellsWithZeroClick)
END_EVENT_TABLE()

int n;
wxTextCtrl *numbers[100][100];
const long determinantsFrame::ID_Calculate = wxNewId();
const long determinantsFrame::ID_Reset = wxNewId();
const long determinantsFrame::ID_Fill = wxNewId();

void determinantsFrame::OnClose(wxCloseEvent &event)
{
    exit(1);
}

void determinantsFrame::OnAbout(wxCommandEvent &event)
{
    wxString msg;
    msg.Printf(wxT("Toolkit used: %s"), wxVERSION_STRING);
    wxMessageBox(msg, wxT("About Determinants Calculator"));
}

void determinantsFrame::OnQuit(wxCommandEvent &event)
{
    Close();
}

determinantsFrame::~determinantsFrame()
{
    Destroy();
}

determinantsFrame::determinantsFrame() : wxFrame(NULL, wxID_ANY, wxT("Determinants Calculator"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE)
{
    fileMenu = new wxMenu;
    helpMenu = new wxMenu;
    menuBar = new wxMenuBar();

    helpMenu->Append(wxID_ABOUT, wxT("&About"), wxT("Show about dialog"));
    fileMenu->Append(wxID_EXIT, wxT("&Exit"), wxT("Quit this program"));

    menuBar->Append(fileMenu, wxT("&File"));
    menuBar->Append(helpMenu, wxT("&Help"));
    SetMenuBar(menuBar);

    while(true)
    {
        td = new wxTextEntryDialog(this, wxT("Enter the number of dimensions: "), wxGetTextFromUserPromptStr, wxT("2"));
        td->ShowModal();

        str = td->GetValue();
        n = wxAtoi(str);
        if (n != 0)
            break;
        else
            wxMessageBox(wxT("The dimension is n x n. You may have entered zero or an invalid character. Only an integer will be accepted such that n \nrepresents the dimension."));
    }

    mainBox = new wxBoxSizer(wxVERTICAL);
    MainPanel = new wxPanel(this, wxID_ANY);
    matrix = new wxStaticBoxSizer(wxVERTICAL, MainPanel, "Matrix: ");
    cells = new wxFlexGridSizer(0, n, 0, 0);
    subBox = new wxBoxSizer(wxVERTICAL);

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
        {
            numbers[i][j] = new wxTextCtrl(MainPanel, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(50,20), 0, wxDefaultValidator, _T("ID_TextCtrl"));
            cells->Add(numbers[i][j], 0, wxALL | wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
        }

    matrix->Add(cells, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 2);
    subBox->Add(matrix, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);

    wxBoxSizer *enb = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *rnb = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *bc = new wxBoxSizer(wxHORIZONTAL);

    Enter = new wxButton(MainPanel, ID_Calculate, _("Calculate"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_Calculate"));
    Reset = new wxButton(MainPanel, ID_Reset, _("Reset"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_Reset"));
    enb->Add(Enter, 1, wxALL |wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    rnb->Add(Reset, 1, wxALL |wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    bc->Add(enb, 0, wxALL | wxEXPAND);
    bc->Add(rnb, 0, wxALL | wxEXPAND);
    Enter->Bind(wxEVT_BUTTON, &determinantsFrame::OnCalculateClick, this);
    Reset->Bind(wxEVT_BUTTON, &determinantsFrame::OnResetClick, this);
    subBox->Add(bc, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL);
    FillEmptyCells = new wxButton(MainPanel, ID_Fill, _("Fill Empty Cells With Zero"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, _T("ID_Fill"));
    subBox->Add(FillEmptyCells, 0, wxALL|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
    FillEmptyCells->Bind(wxEVT_BUTTON, &determinantsFrame::OnFillEmptyCellsWithZeroClick, this);
    MainPanel->SetSizer(subBox);
    mainBox->Add(MainPanel);
    mainBox->Fit(this);
    this->SetSizer(mainBox);
    CentreOnScreen();
}

void determinantsFrame::OnResetClick(wxCommandEvent &event)
{
    determinantsFrame *df;
    this->Show(false);
    df = new determinantsFrame();
    df->Show(true);
}

void determinantsFrame::OnFillEmptyCellsWithZeroClick(wxCommandEvent &event)
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (numbers[i][j]->GetValue() == wxEmptyString)
                numbers[i][j]->SetValue(wxT("0"));
}

void determinantsFrame::OnCalculateClick(wxCommandEvent &event)
{
    double elem[MAX][MAX]; double det; string test; bool doIt = true;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            test = (numbers[i][j]->GetValue()).mb_str();
            if (test == "")
            {
                doIt = false;
                break;
            }

            for (int k = 0; k < test.length(); k++)
                if (isalpha(test[k]) || test[k] == ' ')
                {
                    doIt = false;
                    break;
                }

            if (doIt == false)
                break;
        }
        if (doIt == false)
            break;
    }

    if (doIt)
    {
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
            {
                elem[i][j] = static_cast<double>(wxAtoi(numbers[i][j]->GetValue())); //here's where the problem occurs
                wxMessageBox(wxString::Format(wxT("The determinant is: %.2lf"), elem[i][j])); // here's what I use to test the values inside.
            }
        det = determinant(elem, n);
        wxMessageBox(wxString::Format(wxT("The determinant is: %.2lf"),det));
    }
    else
        wxMessageBox(wxT("You may have entered an invalid character. Please try again"));
}

double determinantsFrame::determinant(double matrix[MAX][MAX], int order)
{
    double det = 0; double temp[MAX][MAX]; int row, col;

    if (order == 1)
        return matrix[0][0];
    else if (order == 2)
        return ((matrix[0][0] * matrix[1][1]) - (matrix[0][1] * matrix[1][0]));
    else
    {
        for (int r = 0; r < order; r++)
        {
            col = 0; row = 0;
            for (int i = 1; i < order; i++)
            {
                for (int j = 0; j < order; j++)
                {
                    if (j == r)
                        continue;

                    temp[row][col] = matrix[i][j];
                    col++;

                    if (col == order - 1)
                        col = 0;
                }
                row++;
            }
            det = det + (matrix[0][r] * pow(-1, r) * determinant(temp, order - 1));
        }
        wxMessageBox(wxString::Format(wxT("The determinant is: %.2lf"),matrix[0][0]));
        return det;
    }
}

#包括
#包括“行列式框架.h”
#包括“starter.h”
#包括
#包括
使用名称空间std；
开始事件表（行列式框架，WX框架）
EVT_菜单（wxID_关于，行列式框架：：OnAbout）
EVT_菜单（wxID_退出，行列式框架：：OnQuit）
EVT_关闭（行列式框架：：关闭）
EVT_按钮（ID_计算，行列式框架：：OnCalculateClick）
EVT_按钮（ID_重置，行列式框架：：OnResetClick）
EVT_按钮（ID_填充，行列式框架：：onFileTycellSwithZeroClick）
结束事件表（）
int n；
wxTextCtrl*数字[100][100]；
常量长行列式frame:：ID_Calculate=wxNewId（）；
常量长行列式frame:：ID_Reset=wxNewId（）；
常量长行列式框架：：ID_Fill=wxNewId（）；
void determinesframe:：OnClose（wxCloseEvent和event）
{
出口（1）；
}
无效行列式框架：：OnAbout（wxCommandEvent和event）
{
wxString味精；
msg.Printf（wxT（“使用的工具包：%s”），wxVERSION\u字符串）；
wxMessageBox（msg，wxT（“关于行列式计算器”）；
}
无效行列式框架：：OnQuit（wxCommandEvent&event）
{
Close（）；
}
行列式框架：：~行列式框架（）
{
破坏（）；
}
行列式框架：：行列式框架（）：wxFrame（NULL，wxID_ANY，wxT（“行列式计算器”），wxDefaultPosition，wxDefaultSize，wxDEFAULT_框架样式）
{
fileMenu=newwxmenu；
帮助菜单=新的wxMenu；
菜单栏=新的wxMenuBar（）；
帮助菜单->附加（wxID_ABOUT，wxT（“&ABOUT”），wxT（“显示关于对话框”）；
fileMenu->Append（wxID_EXIT，wxT（&EXIT），wxT（“退出此程序”）；
菜单栏->附加（文件菜单，wxT（“&File”）；
菜单栏->附加（帮助菜单，wxT（“&Help”）；
设置菜单栏（菜单栏）；
while（true）
{
td=newwxtentrydialog（this，wxT（“输入维度数”）、wxGetTextFromUserPromptStr，wxT（“2”）；
td->ShowModal（）；
str=td->GetValue（）；
n=wxAtoi（str）；
如果（n！=0）
打破
其他的
wxMessageBox（wxT（“维度为n x n。您可能输入了零或无效字符。只接受整数，以便n\n表示维度。”）；
}
mainBox=新的wxBoxSizer（Wx垂直）；
主面板=新的wxPanel（此，wxID_ANY）；
矩阵=新wxStaticBoxSizer（wxVERTICAL，主面板，“矩阵：”）；
单元格=新的wxFlexGridSizer（0，n，0，0）；
子框=新的wxBoxSizer（wxVERTICAL）；
对于（int i=0；i添加（数字[i][j]，0，wxALL | wxALIGN_中心| wxALIGN_中心|水平| wxALIGN_中心|垂直，5）；
}
矩阵->添加（单元格，1，wxALL | wxEXPAND | wxALIGN |中心|水平| wxALIGN |中心|垂直，2）；
子框->添加（矩阵，1，wxALL | wxEXPAND | wxALIGN_中心|水平| wxALIGN_中心|垂直，5）；
wxBoxSizer*enb=新的wxBoxSizer（wxHORIZONTAL）；
wxBoxSizer*rnb=新的wxBoxSizer（wxHORIZONTAL）；
wxBoxSizer*bc=新的wxBoxSizer（wxHORIZONTAL）；
Enter=newwxButton（主面板，ID_计算，u（“计算”），wxDefaultPosition，wxDefaultSize，0，wxDefaultValidator，_T（“ID_计算”）；
重置=新的wxButton（主面板，ID重置，重置），wxDefaultPosition，wxDefaultSize，0，wxDefaultValidator，重置ID）；
enb->Add（输入，1，wxALL | wxEXPAND | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL，5）；
rnb->添加（重置，1，wxALL | wxEXPAND | wxALIGN |中心|水平| wxALIGN |中心|垂直，5）；
bc->Add（enb，0，wxALL | wxEXPAND）；
bc->Add（rnb，0，wxALL | wxEXPAND）；
进入->绑定（wxEVT_按钮，&deterministesframe:：OnCalculateClick，此按钮）；
重置->绑定（wxEVT_按钮和行列式框架：：onreset单击此按钮）；
子框->添加（bc，0，wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL）；
FillEmptyCells=新的wxButton（主面板，ID_Fill，u（“用零填充空单元格”）、wxDefaultPosition、wxDefaultSize、0、wxDefaultValidator，_T（“ID_Fill”）；
子框->添加（填充空单元格，0，wxALL | wxALIGN | wxALIGN |中心|水平| wxALIGN |中心|垂直，5）；
FillEmptyCells->Bind（wxEVT_按钮和行列式框架：：OnFillEmptyCellsWithZeroClick，这）；
主面板->设置器（子框）；
主框->添加（主面板）；
mainBox->Fit（这个）；
此->设置器（主框）；
中心屏幕（）；
}
无效行列式框架：：OnResetClick（wxCommandEvent&event）
{
行列式框架*df；
此->显示（错误）；
df=新的行列式框架（）；
df->Show（真）；
}
无效行列式框架：：OnFillEmptyCellsWithZeroClick（wxCommandEvent&event）
{
对于（int i=0；iGetValue（）==wxEmptyString）
数字[i][j]->设定值（wxT（“0”）；
}
无效行列式框架：：OnCalculateClick（wxCommandEvent&event）
{
双元素[MAX][MAX]；双数据；字符串测试；bool doIt=true；
对于（int i=0；iGetValue（））.mb_str（）；
如果（测试==“”）
{
doIt=false；
打破
}
对于（int k=0；kelem[i][j] = static_cast<double>(wxAtoi(numbers[i][j]->GetValue()));

elem[i][j] = wxAtof(numbers[i][j]->GetValue());