寻找一些重构建议

我需要编写一些代码来替换一个被无数次使用的函数。函数的问题是返回指向静态分配缓冲区的指针,这是一个荒谬的问题。我终于能够证明间歇性高负载错误是由不良实践造成的。

我正在替换的函数有一个签名 char * paddandtruncate(char *,int) char * paddandtruncate(float,int) 或 char * paddandtruncat(int,int) . 每个函数都返回一个指向静态分配缓冲区的指针,该缓冲区在后续调用中被覆盖。

我有三个常数,一个是

2. 几乎没有时间解决这个问题。

我想要一些关于风格和可能的重构想法的意见。

该系统基于填充有空间的固定宽度字段,并且存在一些架构问题。由于该项目的规模约为1000000行,因此无法解决这些问题。

起初,我计划允许数据在创建后更改,但认为不可变对象提供了更安全的解决方案。

    using namespace std;
class SYSTEM_DECLSPEC CoreString
{
private:
     friend ostream & operator<<(ostream &os,CoreString &cs);

     stringstream   m_SS          ;
     float          m_FltData     ;
     long           m_lngData     ;
     long           m_Width       ;
     string         m_strData     ;
     string                  m_FormatedData;
     bool           m_Formated    ;
     stringstream    SS            ;


public:

     CoreString(const string &InStr,long Width):
             m_Formated(false),
             m_Width(Width),
             m_strData(InStr)
             {
                     long OldFlags = SS.flags();
                     SS.fill(' ');
                     SS.width(Width);
                     SS.flags(ios::left);
                     SS<<InStr;
                     m_FormatedData = SS.str();
             }

     CoreString(long longData , long Width):
             m_Formated(false),
             m_Width(Width),
             m_lngData(longData)
             {
                     long OldFlags = SS.flags();
                     SS.fill('0');
                     SS.precision(0);
                     SS.width(Width);
                     SS.flags(ios::right);
                     SS<<longData;
                     m_FormatedData = SS.str();
             }

     CoreString(float FltData, long width,long lPerprecision):
             m_Formated(false),
             m_Width(width),
             m_FltData(FltData)
             {
                     long OldFlags = SS.flags();
                     SS.fill('0');
                     SS.precision(lPerprecision);
                     SS.width(width);
                     SS.flags(ios::right);
                     SS<<FltData;
                     m_FormatedData = SS.str();
             }

     CoreString(const string &InStr):
             m_Formated(false),
             m_strData(InStr)
             {
                     long OldFlags = SS.flags();
                     SS.fill(' ');
                     SS.width(32);
                     SS.flags(ios::left);
                     SS<<InStr;
                     m_FormatedData = SS.str();
             }
 public:
     operator const char   *() {return m_FormatedData.c_str();}
     operator const string& () const {return m_FormatedData;}
     const string& str() const ; 

};

const string& CoreString::str() const
{
     return m_FormatedData;
}

ostream & operator<<(ostream &os,CoreString &cs)
{
     os<< cs.m_Formated;
     return os;
 }