Làm thế nào để bạn 'phân bổ lại' trong C ++?

Làm cách nào tôi có thể sử dụng reallocC ++? Nó dường như bị thiếu trong ngôn ngữ - có newvà deletenhưng không resize!

Tôi cần nó vì khi chương trình của tôi đọc nhiều dữ liệu hơn, tôi cần phân bổ lại bộ đệm để giữ nó. Tôi không nghĩ rằng deletenhập con trỏ cũ và nhập newmột con trỏ mới, lớn hơn, là lựa chọn phù hợp.

Sử dụng :: std :: vector!

Type* t = (Type*)malloc(sizeof(Type)*n) 
memset(t, 0, sizeof(Type)*m)

trở thành

::std::vector<Type> t(n, 0);

Sau đó

t = (Type*)realloc(t, sizeof(Type) * n2);

trở thành

t.resize(n2);

Nếu bạn muốn chuyển con trỏ vào hàm, thay vì

Foo(t)

sử dụng

Foo(&t[0])

Đây hoàn toàn là mã C ++ chính xác, vì vector là một mảng C thông minh.

Tùy chọn phù hợp có thể là sử dụng một vùng chứa phù hợp với bạn, chẳng hạn như std::vector.

newvà deletekhông thể thay đổi kích thước, bởi vì chúng chỉ cấp đủ bộ nhớ để chứa một đối tượng của kiểu đã cho. Kích thước của một loại nhất định sẽ không bao giờ thay đổi. Có new[]và delete[]nhưng hiếm khi có lý do để sử dụng chúng.

Những gì realloctrong C có thể chỉ là một malloc, memcpyvà freedù sao, mặc dù các trình quản lý bộ nhớ được phép làm điều gì đó thông minh nếu có đủ bộ nhớ trống liền kề.

Thay đổi kích thước trong C ++ là một điều khó khăn vì có thể cần gọi các hàm tạo và hàm hủy.

Tôi không nghĩ rằng có lý do cơ bản tại sao trong C ++ bạn không thể có một resize[]toán tử để đi cùng new[]và delete[], điều đó đã làm một cái gì đó tương tự như thế này:

newbuf = new Type[newsize];
std::copy_n(oldbuf, std::min(oldsize, newsize), newbuf);
delete[] oldbuf;
return newbuf;

Rõ ràng là oldsizesẽ được truy xuất từ ​​một vị trí bí mật, giống như nó ở trong đó delete[], và Typesẽ đến từ loại toán hạng. resize[]sẽ không thành công khi Kiểu không thể sao chép - điều này đúng, vì các đối tượng như vậy chỉ đơn giản là không thể di dời được. Cuối cùng, đoạn mã trên mặc định xây dựng các đối tượng trước khi gán chúng, điều mà bạn không muốn là hành vi thực tế.

Có thể có một cách tối ưu hóa, trong đó newsize <= oldsize, gọi các hàm hủy cho các đối tượng "quá cuối" của mảng mới được tạo và không làm gì khác. Tiêu chuẩn sẽ phải xác định xem liệu tối ưu hóa này là bắt buộc (như khi bạn resize()là vectơ), được phép nhưng không xác định, được phép nhưng phụ thuộc vào triển khai hoặc bị cấm.

Sau đó, câu hỏi mà bạn nên tự hỏi là, "việc cung cấp điều này có thực sự hữu ích không, vì nó vectorcũng làm được điều đó và được thiết kế đặc biệt để cung cấp một vùng chứa có thể thay đổi kích thước (của bộ nhớ liền kề - yêu cầu đó bị bỏ qua trong C ++ 98 cố định trong C ++ 03) phù hợp hơn mảng với các cách hoạt động của C ++? "

Tôi nghĩ câu trả lời được nhiều người cho là "không". Nếu bạn muốn thực hiện các bộ đệm có thể thay đổi kích thước theo cách C, hãy sử dụng bộ đệm malloc / free / realloccó sẵn trong C ++. Nếu bạn muốn thực hiện các bộ đệm có thể thay đổi kích thước theo cách C ++, hãy sử dụng một vectơ (hoặc deque, nếu bạn thực sự không cần bộ nhớ liền kề). Đừng cố kết hợp cả hai bằng cách sử dụng new[]cho bộ đệm thô, trừ khi bạn đang triển khai một vùng chứa giống như vectơ.

Đây là một ví dụ std :: move triển khai một vector đơn giản với một realloc (* 2 mỗi khi chúng ta đạt đến giới hạn). Nếu có cách nào để làm tốt hơn bản sao tôi có bên dưới, vui lòng cho tôi biết.

Biên dịch thành:

  g++ -std=c++2a -O2 -Wall -pedantic foo.cpp

Mã:

#include <iostream>
#include <algorithm>

template<class T> class MyVector {
private:
    T *data;
    size_t maxlen;
    size_t currlen;
public:
    MyVector<T> () : data (nullptr), maxlen(0), currlen(0) { }
    MyVector<T> (int maxlen) : data (new T [maxlen]), maxlen(maxlen), currlen(0) { }

    MyVector<T> (const MyVector& o) {
        std::cout << "copy ctor called" << std::endl;
        data = new T [o.maxlen];
        maxlen = o.maxlen;
        currlen = o.currlen;
        std::copy(o.data, o.data + o.maxlen, data);
    }

    MyVector<T> (const MyVector<T>&& o) {
        std::cout << "move ctor called" << std::endl;
        data = o.data;
        maxlen = o.maxlen;
        currlen = o.currlen;
    }

    void push_back (const T& i) {
        if (currlen >= maxlen) {
            maxlen *= 2;
            auto newdata = new T [maxlen];
            std::copy(data, data + currlen, newdata);
            if (data) {
                delete[] data;
            }
            data = newdata;
        }
        data[currlen++] = i;
    }

    friend std::ostream& operator<<(std::ostream &os, const MyVector<T>& o) {
        auto s = o.data;
        auto e = o.data + o.currlen;;
        while (s < e) {
            os << "[" << *s << "]";
            s++;
        }
        return os;
    }
};

int main() {
    auto c = new MyVector<int>(1);
    c->push_back(10);
    c->push_back(11);
}

thử một cái gì đó như thế:

typedef struct Board
{
    string name;
    int size = 0;
};

typedef struct tagRDATA
{
    vector <Board> myBoards(255);

    // Board DataBoard[255];
    int SelectedBoard;

} RUNDATA;

Vector sẽ phàn nàn. Đó là lý do tại sao các mảng, malloc và new vẫn tồn tại.