VC++中按特定标志字符实现字符串到字符串数组的分割(CString -> Cstring[])

 以前用VC++ 做过一个关于数值计算方面的小软件，实现了大多数数值算法的GUI演示，在这个小软件中，有两个重要方面：1.数值计算的相关算法；2.将从用户界面中获取的字符串转化为相应的double类型数据，第一个方面的问题由我们大家共同完成，我主要解决第二个问题，这里谈下解决第二个问题的过程。
我的思路如下：CString ->CString[ ] ->double[ ]


为了调用方便，将所有问题封装到一个类里面：
class CStringConvert
{
public:
    //默认构造函数
    CStringConvert();
    CStringConvert(CString _str);
    CStringConvert(CString _str,int _n);

    //设置要转换的字符串
    void setString(CString _str);

    //获取转换后的字符串
    CString getString();

    //返回分割后的字符串数组
    CString* StringConvert();

    //返回分割并转换后的 double数组
    double* StringConvert(CString _str);

    //返回分割后的字符串D数组
    //CString* DStringConvert();

    //返回分割后的double D数组
    //double* DStringConvert(CString _str);

    //设置数组元素个数
    void setNumber(int _n);

    //获取数组元素个数
    int getNumber();

    //转换后获取double[]型数组
    double* getdArray();

    //转换后获取CString[]型数组
    CString* getsArray();

    //转换后获取CString[][]型数组
    //CString* getsDArray();

    //转换后获取double[][]型数组
    //double* getdDArray();

    //检查字符串的合法性
    bool StringCheck();
    bool StringCheck(CString _str);

    //将CString转换为double
    double ParseDouble(CString _str);

    //将/r/n转换为空格
    CString ParseSpace(CString _str);
   
       

private:

    double m_dx[10000];
    CString m_sx[10000];

    //double m_dDx[200][200];
    //CString m_sDx[200][200];

    //分割后元素行数
    int rows;

    //分割后元素个数
    int n;

    CString str;

    CString cr;
    CString cl ;//根据cl进行分割
};

#include "stdafx.h"

#include "StringConvert.h"

#include "math.h"
#include "ctype.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

//系统初始化
CStringConvert::CStringConvert()
{
    this->n = 10000;

    this->cl = " ";
    this->cr = "/n";

    this->str = CString("1 2 3 11 22 33");

    for(int i = 0;i<10000;i++)
    {
        this->m_dx[i] = 0.0;
        this->m_sx[i] = "0.0";
    }

}
CStringConvert::CStringConvert(CString _str)
{
    n = 10000;

    this->cl = " ";
    this->cr = "/n";

    str = _str;

    for(int i = 0;i<10000;i++)
    {
        m_dx[i] = 0.0;
        this->m_sx[i] = "0.0";
    }

}
CStringConvert::CStringConvert(CString _str, int _n)
{
    n = _n;

    this->cl = " ";
    this->cr = "/n";

    str = _str;

    for(int i = 0;i<10000;i++)
    {
        m_dx[i] = 0.0;
        this->m_sx[i] = "0.0";
    }

}

//设置要转换的字符串
void CStringConvert::setString(CString _str)
{
    this->str = _str;
}

//获取转换后的字符串
CString CStringConvert::getString()
{
    return this->str;
}

//设置数组元素个数
void CStringConvert::setNumber(int _n)
{
    this->n = _n;
}

//获取数组元素个数
int CStringConvert::getNumber()
{
    return this->n;
}

//转换后获取CString型数组
CString* CStringConvert::getsArray()
{
    return this->m_sx;
}

//转换后获取double型数组
double* CStringConvert::getdArray()
{
    return this->m_dx;
}

//检查字符串的合法性,合法返回true
bool CStringConvert::StringCheck()
{

    if(this->str.IsEmpty()) return false;

    for(int i = 0;i<this->str.Trim().GetLength();i++)
    {
        char tmp = (char)this->str.Trim().GetAt(i);
        if((tmp>='0' && tmp<='9') || tmp == '.' || tmp == ' ' || tmp == '/n' || isspace(tmp) || tmp == '-') continue;
        else return false;
    }
    return true;
}

bool CStringConvert::StringCheck(CString _str)
{

    if(_str.IsEmpty()) return false;

    for(int i = 0;i<_str.Trim().GetLength();i++)
    {
        char tmp = (char)_str.Trim().GetAt(i);
        if((tmp>='0' && tmp<='9') || tmp == '.' || tmp == ' ' || tmp == '/r/n' || isspace(tmp) || tmp == '-') continue;
        else return false;
    }
    return true;
}


//将CString转换为double
double CStringConvert::ParseDouble(CString _str)
{
    return atof(CT2A(_str));
}

//将/r/n转换为空格
CString CStringConvert::ParseSpace(CString _str)
{
    _str.Replace(';',' ');
    return _str;

}

//返回分割后的字符串数组
CString* CStringConvert::StringConvert()
{
    CString sa[1000];
    int i = 0;

    while(1){
        int pos = str.Trim().Find(this->cl);
        if(pos>=0){
            sa[i] = str.Left(pos).Trim();
            str = str.Mid(pos+1).Trim();
        } else {
            sa[i] = str.Trim();
            break;
        }
        i++;
    }

    this->n = i+1;
    for(i = 0;i<this->n;i++)
    {
        m_sx[i] = sa[i];
    }
    return m_sx;
}

//返回分割并转换后的 double数组
double* CStringConvert::StringConvert(CString _str)
{
    this->str = _str;

    CString* sa = this->StringConvert();

    for(int i = 0;i<this->n;i++)
    {
        m_dx[i] = atof(CT2A(sa[i]));
    }
    return m_dx;

}