紧凑向量 一个小的内存 脚印向量

Question

我维护一个旧的 C++ 应用程序，它有很多类，如下所示：

    class ClassWithALotOfVectors
    {
        std::vector<int> _vector1;
        std::vector<int> _vector2;

        // a lot of other vector datamembers go here

        std::vector<double> _vectorN;
    };

即 - 一种数据类型，其中成员为 double 或 int 向量。 问题是 - 这些向量永远不会同时填充 - 因此 当我们创建 100000 个 ClassWithALotOfVectors 实例时 - 内存使用量增加 尽管这些向量中只有 10% 正在使用中，但这个数字令人印象深刻。

所以我决定写一个小的“按需分配”向量类。

它是 std::vector 的包装器 - 内部向量仅在何时创建 第一次访问（使用两个 getter - ref() 和 const_ref() 方法）

当我用 compact_vector 替换 ClassWithALotOfVectors 类中的 std::vector 时 如下：

    class ClassWithALotOfVectors2
    {
    compact_vector<int> _vector1;
    compact_vector<int> _vector2;

    compact_vector<double> _vectorN;
    };

做了一些测试，结果很有希望 - 内存使用量下降了 戏剧性地，但突然发现应用程序没有释放内存 最后 - 内存消耗的增长速度比它慢得多 曾经是 - 但应用程序似乎没有释放内存 最后。

你能看看我对 compact_vector 的实现吗 看看你是否能发现内存管理有问题。

    template <class T> class compact_vector 
    { 
    public: 
            compact_vector<T>()
            :_data(NULL) 
            { 
            } 

            ~compact_vector<T>() 
            { 
                    clear(); 
            } 

            compact_vector<T>(const compact_vector<T> & rhs) 
            :_data(NULL) 
            { 
                    if (NULL != rhs._data) 
                    { 
                            _data = new std::vector<T>(*(rhs._data)); 
                    } 
                    else 
                    { 
                            clear(); 
                    } 
            } 

            //      assignment 
            // 
            compact_vector<T> & operator=(const compact_vector<T> & rhs) 
            { 
                    if (this != &rhs) 
                    { 
                            clear(); 
                            if (NULL != rhs._data) 
                            { 
                                    _data = new std::vector<T>(*rhs._data); 
                            } 
                    } 
                    return *this; 
            } 
            compact_vector<T> & operator=(const std::vector<T> & rhs) 
            { 
                    clear(); 
                    if (!rhs.empty()) 
                    { 
                            _data = new std::vector<T>(rhs); 
                    } 
                    return *this; 
            } 

            const std::vector<T> & const_ref() 
            { 
                    createInternal(); 
                    return *_data; 
            } 
            std::vector<T> & ref() 
            { 
                    createInternal(); 
                    return *_data; 
            } 
            void    clear() 
            { 
                    if (NULL != _data) 
                    { 
                            _data->clear(); 
                            delete _data; 
                            _data = NULL; 
                    } 
            } 
    private: 
            void    createInternal() 
            { 
                    if (NULL == _data) 
                    { 
                            _data = new std::vector<T>(); 
                    } 
            } 

    private: 
            compact_vector<T>(const std::vector<T> & rhs) 
            { 
            } 
            compact_vector<T>(std::vector<T> & rhs) 
            { 
            } 
            compact_vector<T>(std::vector<T> rhs) 
            { 
            } 

            std::vector<T> * _data; 
    }; 

Answer 1

std::vector 的大多数实现在您需要之前不会获取内存，并且向量的大小通常只是几个（3 + 可能是额外的调试信息）指针。也就是说，std::vector<int>() 不会为任何对象分配空间。我相信你在这里对着错误的树吠叫。

为什么您的原始代码的内存使用量要高得多？你期待clear() 释放内存吗？

如果是这样，那你就错了。 clear() 函数会破坏包含的元素，但不会释放分配的内存。考虑添加一个包装器来清除使用以下习语的内存：

std::vector<int>().swap( _data );

上一行所做的是创建一个新的 empty 向量（通常不附加内存，不是强制的，但常见的实现）并交换两个向量的内容。在表达式的末尾，临时包含最初由_data 向量保存的数据，而_data 为空且没有内存（已定义实现）。临时在完整表达式结束时被破坏并释放内存。

或者，如果您的编译器支持 C++11，您可以在调用 clear() 后使用 shrink_to_fit()。该标准不要求 shrink_to_fit() 实际上缩小以适应，但对于空向量，我希望实现能够做到这一点。调用后调用capacity() 进行测试，看看它是否已降至 0。

Answer 2

Use smart pointers。 In this case, std::unique_ptr 带有手工复制 ctor / 赋值运算符。突然间，你所有的问题都解决了。就像魔术一样！

_{很抱歉听起来很刺耳，但内存泄漏总是有相同的答案：智能指针。}

Answer 3

既然你说它是一个旧应用程序，不能用它做很多事情。在构造过程中保留所有大小为零的向量怎么样。
这很乏味，但是由于旧应用程序并且预计不会进行太多修改。可能值得一试。

class ClassWithALotOfVectors    
{    
   std::vector<int> _vector1;     
   std::vector<int> _vector2;        
   // a lot of other vector datamembers go here         
   std::vector<double> _vectorN;

  public:
     ClassWithALotOfVectors() : Init() { }   
     void Init()   
     {   
         vector1.reserve(0);   
         /// Like wise other vectors.   
     }  
};

Answer 4

一次只使用一个向量的想法听起来像union 概念。果然，C++ 有一个名为anonymous union 的元素正是这样做的。

class ClassWithALotOfVectors {
    public:
    union  {
        std::vector<double> _vector1;
        std::vector<double> _vector2;
    };
    ClassWithALotOfVectors() { new(&_vector1) std::vector<double>; };
    ~ClassWithALotOfVectors() { _vector1.~vector<double>(); };
};

因为联合不知道要调用哪个元素的构造函数，所以联合中禁用了默认构造函数，您必须手动构造和解构联合的元素，但我认为这将完成您正在寻找的，别名@987654325 @ 和 _vector2 到同一个元素，但都放在 ClassWithALotOfVectors 命名空间中，然后在调用 ClassWithALotOfVectors 的析构函数时释放向量。

有关匿名工会的更多信息，请参阅： CPP reference: Anonymous Unions