Erstellen der Konvertier-Routinen zwischen den beiden Typen double und CString

Die privaten Member-Funktionen DoubleToString, CStringToDouble und StripEndingZero dienen der Umwandlung von m_dValue in m_strValue und umgekehrt. Die Routinen führen die Konvertierung eleganterweise nicht selber aus, sondern delegieren diese Arbeit an die Klassen std::istringstream bzw. std::ostringstream weiter, allerdings unter Berücksichtigung der Einheit.

double CHertzEdit::CStringToDouble(CString &str)
{
        double d;

        if (((m_bNegativAllowed==FALSE) && (str.FindOneOf("-") != -1)) ||
                (str.CompareNoCase("invalid") == 0))
        {
                d=-1.0;
        }
        else
        {
                // String in Stream kopieren
                int i=str.GetLength();
                std::istringstream ist(str.GetBuffer(i));
                str.ReleaseBuffer();

                double d1;
                char c[3];

                // Wert und Einheit trennen
                ist >> d1 >> c;
                CString strEinheit(c);

                // Wert anhand der Einheit anpassen
                if (!strEinheit.CompareNoCase("Hz"))
                {
                        d=d1;
                }
                else if (!strEinheit.CompareNoCase("kHz"))
                {
                        d=d1*1000.0;
                }
                else if (!strEinheit.CompareNoCase("MHz"))
                {
                        d=d1*1000000.0;
                }
        }
        return(d);
}

std::string CHertzEdit::DoubleToString(double d)
{
        double d1, d2;

        std::ostringstream ost;
        ost.setf(std::ios_base::fixed, std::ios_base::floatfield);

        d2=fabs(d);

        if (d < 0.0 && !m_bNegativAllowed)
        {
                ost << "Invalid" << std::ends;
        }
        else if (d2 < 1000.0) // Hz-Bereich
        {
                d1 = d;
                ost << std::setprecision(1);
                ost << d1;
                StripEndingZero(ost);
                ost << " Hz" << std::ends;
        }
        else if (d2 < 1000000.0) // Khz-Bereich
        {
                d1 = d / 1000.0;
                ost << std::setprecision(4);
                ost << d1;
                StripEndingZero(ost);
                ost << " KHz" << std::ends;
        }
        else if (d2 > 10.0e9) // zu gro? fuer format::fixed
        {
                ost << "Invalid" << std::ends;
        }
        else // MHz-Bereich
        {
                d1 = d / 1000000.0;
                ost << std::setprecision(7);
                ost << d1;
                StripEndingZero(ost);
                ost << " MHz" << std::ends;
        }
        return(ost.str());

}

void CHertzEdit::StripEndingZero(std::ostringstream &oststr)
{
        std::string strString= oststr.str();
        std::string::iterator it = strString.end();
        --it;

         // Letztes Zeichen == '0' ?
         while ( *(it) == '0' && it != strString.begin())
        {
                // ja
                // ist davor der '.' ?
                if ( *(it-1) != '.')
                {
                        // nein => weg damit
                        strString.erase(it);
                        it = strString.end();
                        --it;
                }
                else
                {
                        // ja => '0' dranlassen (z.B. 1.0)
                        break;
                }
        }
        // nein => nichts machen
        // oststr neu initialisieren
        oststr.seekp(0);
        oststr << strString;
}