Question

在提出这个问题之前，我查看了this similar question并尝试使用其代码来解决我的问题，但它没有用。

我正在尝试编写一个扩展给定静态对象数组的函数。这是目前的功能，基于上述相关问题的代码：

void MyClass::expand_array(MyClass *&old_array, int &old_array_size,
    int new_slots)
{
    MyClass *transfer_array = new MyClass[old_array_size + new_slots];

    for (int i = 0; i < old_array_size; i++) {
        transfer_array[i] = old_array[i];
    }

    delete[] old_array;
    old_array = transfer_array;
    transfer_array = NULL;
}

这甚至都没有编译。这是编译器的输出：

program.cpp:110:54: error: no matching function for call to ‘MyClass::expand_array(MyClass [10], int&, int)’
program.cpp:110:54: note: candidate is:
program.cpp:41:6: note: static void MyClass::expand_array(MyClass*&, int&, int)
program.cpp:41:6: note:   no known conversion for argument 1 from ‘MyClass [10]’ to ‘MyClass*&’
program.cpp:122:54: error: no matching function for call to ‘MyClass::expand_array(MyClass [10], int&, int)’
program.cpp:122:54: note: candidate is:
program.cpp:41:6: note: static void MyClass::expand_array(MyClass*&, int&, int)
program.cpp:41:6: note:   no known conversion for argument 1 from ‘MyClass [10]’ to ‘MyClass*&’
program.cpp:143:11: warning: deleting array ‘MyClass tmp_cards [10]’ [enabled by default]

（输出的最后一行来自于尝试删除数组的最后一次迭代。）

Answer 1

扩展数组的第一个参数定义为myclass *＆amp;，查看我认为你需要使用myclass * *的代码并调整调用代码。我猜你正在声明myclass [10]并试图传递它，这永远不会起作用 - 你必须传递一个你用new分配的数组，如果你要删除它。

Answer 2

您似乎与数组指针等效运行相冲突。在此上下文中，array我指的是一个C数组，例如

MyClass a[10];

在C等C ++中，数组可以衰减为指针。

void f(int input[]);

该语言没有提供此函数的机制来告知它接收的数量，因此为了函数调用，上面的数组衰减为指针。也就是说，在上述函数的主体内，input的类型为int*。

这也发生在其他地方，以允许我们在数组上做指针数学没有数组和指针式操作：

char a[10];
sizeof(a); // understands a is really an array and evaluates to 10
sizeof(*a); // decays a to a pointer and returns sizeof(char)
char* b = a + 1; // equivalent to b = &a[1];
b[1] = 0; // equivalent to *(b + 1) = 0;

但是，您正在尝试引用指针。在这种情况下，数组不衰减，请考虑：

void f(int*& ptr)
{
    ptr = nullptr;
}

void x()
{
    int a[16];
    f(a);
}

a不是16个整数的指针，它在堆栈上的是 16个整数。我们从根本上无法重新定位a。

如果您需要可调整大小的数组，则需要使用分配：

MyClass* array = new MyClass[10];
MyClass::expand_array(array, 10, 20);
delete [] array;

这就是说，我想指出这种方法很糟糕，因为它暴露了指向消费者的指针。相反，您应该将大小跟踪和数组当前存储的位置移动到 MyClass类中。也许看看std::vector

但总的来说，更像是这样：http://ideone.com/4hgri4

#include <functional>
#include <cstdint>
#include <iostream>

// CAVEAT EMPTOR: This is a partial, naive implementation,
// it lacks copy/move constructor, operator=, iterators and
// many other things. It is solely intended to demonstrate
// internalizing the paired-state components of size and data
// to provide a discrete encapsulation of the concept of a
// dynamically sized array-like allocation.

class MyArray
{
    // create an alias for the type we're using,
    // this will come in handy when you learn templates.
    typedef int value_type;

    value_type* m_data;
    size_t m_size;

public:
    MyArray() : m_data(nullptr), m_size(0) {}
    MyArray(size_t defaultSize) : m_data(nullptr), m_size(0)
    {
        resize(defaultSize);
    }

    void resize(size_t newSize)
    {
        if (newSize > size()) {
            value_type* newData = new value_type[newSize];
            if (m_data) {
                std::copy(m_data, m_data + size(), newData);
                delete [] m_data;
            }
            m_data = newData;
        }
        m_size = newSize;
        if (m_size == 0 && m_data) {
            delete [] m_data;
            m_data = nullptr;
        }
    } 

    value_type operator[](size_t index) const { return m_data[index]; }
    value_type& operator[](size_t index) { return m_data[index]; }

    size_t size() const { return m_size; }

    void push_back(value_type newValue)
    {
        resize(m_size + 1);
        m_data[size() - 1] = newValue;
    }
};

int main()
{
    MyArray a;
    a.resize(4);
    for (size_t i = 0; i < a.size(); ++i) {
        a[i] = i;
    }

    a.push_back(10);

    std::cout << "Values:\n";
    for (size_t i = 0; i < a.size(); ++i) {
        std::cout << i << ": " << a[i] << '\n';
    }

    return 0;
}

有关数组指针等效性的更多信息，请参阅C++ FAQ section on it。

C ++：扩展数组的函数

2 个答案: