Question

我想知道如果在动态分配的对象中调整成员变量（例如vector）会发生什么。例如：

class A
{
public:
    vector<int> x;

    void expand()
    {
        vector<int> y = { 1, 2, 3 };
        x = y;
    }
};

int main()
{
    A* a = new A;
    cout << sizeof(*a) << endl;
    a->expand();
    for (auto v : a->x)
        cout << v << endl;
    return 0;
}

由于已分配对象A的大小已由new的时间决定，此操作是否会导致未定义的行为？由于编译器在分配发生时不知道x的实际大小，因此expand()不起作用。如果是的话，我应该如何解决这个问题呢？感谢您的帮助。

Answer 1

很难推断std::vector实现，因为它是特定于编译器的。这是一个非常简单的类，它允许在编译时存储编号未知的元素。

#include <iostream>

class TrivialExtendableArray
{
public:
    TrivialExtendableArray()
       : internalStorage(nullptr),
         size(0)
    {

    }

    ~TrivialExtendableArray()
    {
        if(internalStorage != nullptr)
        {
            delete []internalStorage;
        }
    }

    TrivialExtendableArray(const TrivialExtendableArray&) = delete;
    TrivialExtendableArray& operator=(const TrivialExtendableArray&) = delete;

     int* getPointer()
     {
         return internalStorage;
     }
     size_t getSize()
     {
         return size;
     }

     void addElement(int newElementValue)
     {
         int* newStorage = new int[size+1];

         std::copy(internalStorage, internalStorage + size, newStorage);

         if(internalStorage != nullptr)
         {
              delete []internalStorage;
         }
         newStorage[size] = newElementValue;

         size++;
         internalStorage = newStorage;
    }

    const int* begin() const
    {
         return internalStorage;
    }
    const int* end() const
    {
         return internalStorage + size;
    }

 private:
    int* internalStorage;
    size_t size;
 };

 std::ostream& operator<<(std::ostream& out, const TrivialExtendableArray& array)
 {
     out << "{ ";
     for(const int* i = array.begin(); i != array.end(); i++)
     {
         out << *i << " "; 
     }
     return out << "}";
 }

 int main()
 {
     TrivialExtendableArray array;

     std::cout << "Empty TrivialExtendableArray on stack sizeof: " << sizeof(array) << ": " << array << std::endl;

     array.addElement(5);

     std::cout << "TrivialExtendable with one element on stack sizeof: " << sizeof(array) << ": " << array << std::endl;

     array.addElement(3);

     std::cout << "TrivialExtendable with two elements on stack sizeof: " << sizeof(array) << ": " << array << std::endl;

     array.addElement(3);

     std::cout << "TrivialExtendable with three elements on stack sizeof: " << sizeof(array) << ": " << array << std::endl;

 }

此程序的结果可能会有所不同，具体取决于您使用的编译器和体系结构我已收到类似的内容：

$ ./a.out 
Empty TrivialExtendableArray on stack sizeof: 16: { }
TrivialExtendable with one element on stack sizeof: 16: { 5 }
TrivialExtendable with two elements on stack sizeof: 16: { 5 3 }
TrivialExtendable with three elements on stack sizeof: 16: { 5 3 3 }

每次类的大小都是相同的，因为TrivialExtendableArray的对象只需要存储指向已分配内存的指针和该内存的大小。元素的数量不会改变这个类的大小。字段。

std::vector使用非常相似的方法。因此，当您对它们进行任何操作时，std::vector个对象的大小不会改变。

在C ++中调整动态分配对象内的成员变量

1 个答案: