寻找一些重构建议

Question

我有一些代码，我不得不写一些代码来代替几千次的函数。这个函数的问题是返回一个指向静态分配缓冲区的指针，这是一个荒谬的问题。我终于能够证明间歇性的高负载错误是由不好的做法造成的。

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

我有三个常量之一

1. 代码必须是可更换的与主叫方没有任何影响。
2. 很少有时间来解决这个问题。
3. 可接受的性能。

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

该系统基于用空格填充的固定宽度字段，并且具有一些架构问题。由于该项目的规模大约为1,000,000行，因此这些地址无法解决。

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

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; 
} 

Answer 1

如果你确实的意思是“对呼叫者没有影响”，你的选择是非常有限的。你不能返回任何需要被调用者释放的东西。

如果冒着将另一个不好的解决方案替换为另一个解决方案的风险，最快最容易的解决方案可能是这样的：不是使用单个静态缓冲区，而是使用它们的池并在每次调用函数时通过它们旋转。确保选择缓冲区的代码是线程安全的。

Answer 2

你发布的代码有一个巨大的问题 - 如果调用者将返回值赋给const char *，编译器将进行无提示转换并销毁临时的CoreString对象。现在你的指针将会失效。

Answer 3

“间歇性高负载错误”是由竞争条件引起的，其中一个线程在另一个线程完成使用之前在静态缓冲区上践踏，对吗？

因此，切换到每个线程使用输出缓冲区，使用您的平台提供的任何线程本地存储机制（Windows，我在想）。

没有同步争用，线程之间没有干扰，并根据您对当前实现旋转缓冲区的说法，几乎可以肯定调用代码根本不需要改变。如果当前的实现使用多个缓冲区，它不能依赖每次使用的相同缓冲区。

我可能不会从头开始设计API，但它实现了您当前的API而不会以显着方式更改它，或者影响性能。

Answer 4

听起来像系统是线程的，对吧？如果仅仅是在您仍然使用之前的输出时再次调用其中一个函数是不安全的问题，则它应该每次都以相同的方式运行。

大多数编译器有办法来标记变量为“线程本地数据”使之具有取决于哪个线程访问它不同的地址。在GCC是__thread，在VC++中的__declspec(thread)。

如果您需要能够从同一个线程多次调用这些功能，而无需重写的结果，我看不到任何完整的解决方案，但迫使调用者释放的结果。您可以使用混合方法，其中每个线程都有固定数量的缓冲区，因此无论其他线程在做什么，呼叫者都可以在不覆盖以前的结果的情况下组成N个调用。

Answer 5

我不知道调用者将如何使用它，但使用new将缓冲区分配到auto_ptr<>可能会起作用。它可能满足标准1（我没有看到使用的代码，我不知道），并可能是一个非常快的修复。最大的问题是它会使用大量的动态内存，这会让速度变慢。有些事情你可以做，使用新的布局等，但这可能不是很快就可以编码。

如果您不能使用动态存储，你只限于非动态存储，而且确实没有什么可以做，不使用缓冲区或线程局部缓冲或类似的东西的旋转池。