如何避免模板实例化和符号表导致的 C++ 代码膨胀？

Question

几年前我开始了一个裸机 (Cortex-M) 项目。在项目设置中，我们决定使用启用 C++11 / C++14 等的 gcc 工具链，甚至使用 C++ 异常和 rtti。

我们目前正在使用gcc 4.9 from launchpad.net/gcc-arm-embedded（存在一些问题，导致我们目前无法更新到更新的 gcc 版本）。

例如，我写了一个这样的基类和一个派生类（另见运行示例here）：

class OutStream {
public:
    explicit OutStream() {}
    virtual ~OutStream() {}
    OutStream& operator << (const char* s) {
        write(s, strlen(s));
        return *this;
    }
    virtual void write(const void* buffer, size_t size) = 0;    
};

class FixedMemoryStream: public OutStream {
public:
    explicit FixedMemoryStream(void* memBuffer, size_t memBufferSize): memBuffer(memBuffer), memBufferSize(memBufferSize) {}
    virtual ~FixedMemoryStream()       {}
    const void*  getBuffer() const     { return memBuffer; }
    size_t       getBufferSize() const { return memBufferSize; }
    const char*  getText() const       { return reinterpret_cast<const char*>(memBuffer); }  ///< returns content as zero terminated C-string    
    size_t       getSize() const       { return index; }                                     ///< number of bytes really written to the buffer (max = buffersize-1)
    bool         isOverflow() const    { return overflow; }
    virtual void write(const void* buffer, size_t size) override { /* ... */ }
private:
    void*  memBuffer = nullptr;   ///< buffer
    size_t memBufferSize = 0;     ///< buffer size
    size_t index = 0;             ///< current write index
    bool   overflow = false;      ///< flag if we are overflown
};

以便我班的客户现在可以使用例如：

char buffer[10];
FixedMemoryStream ms1(buffer, sizeof(buffer));
ms1 << "Hello World";

现在我想让这个类的使用更舒适一些，并引入了以下模板：

template<size_t bufferSize> class FixedMemoryStreamWithBuffer: public FixedMemoryStream {
public:
    explicit FixedMemoryStreamWithBuffer(): FixedMemoryStream(buffer, bufferSize) {}
private:
    uint8_t buffer[bufferSize];
};

从现在开始，我的客户可以写：

FixedMemoryStreamWithBuffer<10> ms2;
ms2 << "Hello World";

但是从现在开始，我发现我的可执行二进制文件的大小越来越大。似乎 gcc 为 FixedMemoryStreamWithBuffer 的每个不同模板实例添加了符号信息（因为我们出于某种原因使用 rtti）。

有没有办法只为某些特定的类/模板/模板实例化去除符号信息？

可以为此获得一个非便携式 gcc 唯一的解决方案。

出于某种原因，我们决定更喜欢模板而不是预处理器宏，我想避免使用预处理器解决方案。

Answer 1

首先，请记住，编译器还会为每个 FixedMemoryStreamWithBuffer 类型实例以及继承链中的每个类生成单独的 v-table（以及 RTTI 信息）。

为了解决这个问题，我建议使用包含而不是继承，其中包含一些转换函数和/或运算符：

    template<size_t bufferSize> 
    class FixedMemoryStreamWithBuffer
    {
         uint8_t buffer[bufferSize];
         FixedMemoryStream m_stream;
    public:
        explicit FixedMemoryStreamWithBuffer() : m_stream(m_buffer, bufferSize) {}
        operator FixedMemoryStream&() { return m_stream; }
        FixedMemoryStream& toStream() { return m_stream; }
   };

Answer 2

是的，有一种方法可以将必要的符号几乎降低到0：使用标准库。您的OutStream 类是std::basic_ostream 的简化版本。你的OutStream::write 真的只是std::basic_ostream::write 等等。看看here。溢出处理得非常密切，但为了完整起见，它也处理underflow，即需要数据检索；您可以将其保留为未定义（它也是 virtual）。

同样，您的FixedMemoryStream 是std::basic_streambuf<T>，具有固定大小（std::array<T>）的获取/放置区域。

所以，只要让你的类继承自标准类，你就会切断二进制大小，因为你正在重用已经声明的符号。

---

现在，关于template<size_t bufferSize> class FixedMemoryStreamWithBuffer。此类在指定和获取内存的方式方面与std::array<std::uint8_t, bufferSize> 非常相似。您无法对此进行太多优化：每个实例化都是一个不同类型，包含所有含义。编译器不能“合并”或对它们做任何魔术：每个实例化都必须有自己的类型。 因此，要么退回到std::vector，要么使用一些固定大小的专用块，如 32、128 等，对于介于两者之间的任何值，都会选择正确的块；这可以完全在编译时实现，因此没有运行时成本。