malloc cho struct và con trỏ trong C

Giả sử tôi muốn xác định cấu trúc đại diện cho độ dài của vectơ và các giá trị của nó là:

struct Vector{
    double* x;
    int n;
};

Bây giờ, giả sử tôi muốn xác định một vectơ y và cấp phát bộ nhớ cho nó.

struct Vector *y = (struct Vector*)malloc(sizeof(struct Vector));

Tìm kiếm của tôi trên internet cho thấy rằng tôi nên phân bổ bộ nhớ cho x một cách riêng biệt.

y->x = (double*)malloc(10*sizeof(double));

Nhưng, có vẻ như tôi đang cấp phát bộ nhớ cho y-> x hai lần, một trong khi cấp phát bộ nhớ cho y và một trong khi cấp phát bộ nhớ cho y-> x, và có vẻ như lãng phí bộ nhớ. Nó rất được đánh giá cao nếu cho tôi biết trình biên dịch thực sự làm gì và đâu sẽ là cách phù hợp để khởi tạo cả y và y-> x.

Cảm ơn trước.

Không, bạn không phân bổ bộ nhớ cho y->xhai lần.

Thay vào đó, bạn đang phân bổ bộ nhớ cho cấu trúc (bao gồm một con trỏ) cộng với một thứ gì đó để con trỏ trỏ tới.

Nghĩ theo cách này:

         1          2
        +-----+    +------+
y------>|  x------>|  *x  |
        |  n  |    +------+
        +-----+

Vì vậy, bạn thực sự cần hai phân bổ ( 1và 2) để lưu trữ mọi thứ.

Ngoài ra, kiểu của bạn nên là struct Vector *yvì nó là một con trỏ và bạn không bao giờ nên chuyển giá trị trả về từ malloctrong C vì nó có thể ẩn một số vấn đề nhất định mà bạn không muốn ẩn - C hoàn toàn có khả năng chuyển đổi ngầm void*giá trị trả về sang bất kỳ con trỏ nào khác.

Và, tất nhiên, bạn có thể muốn gói gọn việc tạo các vectơ này để giúp quản lý chúng dễ dàng hơn, chẳng hạn như với:

struct Vector {
    double *data;    // no place for x and n in readable code :-)
    size_t size;
};

struct Vector *newVector (size_t sz) {
    // Try to allocate vector structure.

    struct Vector *retVal = malloc (sizeof (struct Vector));
    if (retVal == NULL)
        return NULL;

    // Try to allocate vector data, free structure if fail.

    retVal->data = malloc (sz * sizeof (double));
    if (retVal->data == NULL) {
        free (retVal);
        return NULL;
    }

    // Set size and return.

    retVal->size = sz;
    return retVal;
}

void delVector (struct Vector *vector) {
    // Can safely assume vector is NULL or fully built.

    if (vector != NULL) {
        free (vector->data);
        free (vector);
    }
}

Bằng cách đóng gói việc tạo ra như vậy, bạn đảm bảo rằng các vectơ hoặc được tạo hoàn chỉnh hoặc không được xây dựng hoàn toàn - không có khả năng chúng được tạo một nửa. Nó cũng cho phép bạn thay đổi hoàn toàn các cấu trúc dữ liệu cơ bản trong tương lai mà không ảnh hưởng đến các máy khách (ví dụ: nếu bạn muốn làm cho chúng thành các mảng thưa thớt để đánh đổi không gian lấy tốc độ).

Lần đầu tiên, bạn cấp phát bộ nhớ cho Vector, có nghĩa là các biến x, n.

Tuy nhiên x vẫn chưa chỉ ra bất cứ điều gì hữu ích .

Vì vậy, đó là lý do tại sao phân bổ thứ hai cũng cần thiết .

Vài điểm

struct Vector y = (struct Vector*)malloc(sizeof(struct Vector)); sai

nó phải được struct Vector *y = (struct Vector*)malloc(sizeof(struct Vector));kể từ khi ycon trỏ đến struct Vector.

1st malloc()chỉ cấp phát bộ nhớ đủ để chứa cấu trúc Vector (là con trỏ đến double + int)

Thứ 2 malloc()thực sự phân bổ bộ nhớ để giữ 10 đôi.

Bạn thực sự có thể làm điều này trong một malloc duy nhất bằng cách phân bổ cho Vectơ và mảng cùng một lúc. Ví dụ:

struct Vector y = (struct Vector*)malloc(sizeof(struct Vector) + 10*sizeof(double));
y->x = (double*)((char*)y + sizeof(struct Vector));
y->n = 10;

Điều này phân bổ Vector 'y', sau đó làm cho y-> x trỏ đến dữ liệu được cấp bổ sung ngay sau cấu trúc Vector (nhưng trong cùng một khối bộ nhớ).

Nếu cần thay đổi kích thước vectơ, bạn nên thực hiện với hai phân bổ như được khuyến nghị. Mảng y-> x bên trong sau đó sẽ có thể được thay đổi kích thước trong khi vẫn giữ nguyên cấu trúc vectơ 'y'.

Về nguyên tắc, bạn đang làm đúng rồi. Đối với những gì bạn muốn, bạn cần hai malloc()giây.

Chỉ là một số nhận xét:

struct Vector y = (struct Vector*)malloc(sizeof(struct Vector));
y->x = (double*)malloc(10*sizeof(double));

nên là

struct Vector *y = malloc(sizeof *y); /* Note the pointer */
y->x = calloc(10, sizeof *y->x);

Trong dòng đầu tiên, bạn cấp phát bộ nhớ cho một đối tượng Vector. malloc()trả về một con trỏ đến bộ nhớ được cấp phát, vì vậy y phải là một con trỏ Vector. Trong dòng thứ hai, bạn phân bổ bộ nhớ cho một mảng 10 nhân đôi.

Trong C, bạn không cần các khuôn mẫu rõ ràng, và việc viết sizeof *ythay vào đó sizeof(struct Vector)là tốt hơn để đảm bảo an toàn khi nhập, và bên cạnh đó, nó tiết kiệm khi nhập.

Bạn có thể sắp xếp lại cấu trúc của mình và thực hiện một thao tác malloc()như sau:

struct Vector{    
    int n;
    double x[];
};
struct Vector *y = malloc(sizeof *y + 10 * sizeof(double));

Khi bạn cấp phát bộ nhớ cho struct Vectorbạn, bạn chỉ cần cấp phát bộ nhớ cho con trỏ x, tức là cho khoảng trắng, nơi giá trị của nó, chứa địa chỉ, sẽ được đặt. Vì vậy, như vậy bạn không phân bổ bộ nhớ cho khối, mà y.xsẽ tham chiếu.

Đầu tiên malloc phân bổ bộ nhớ cho struct, bao gồm cả bộ nhớ cho x (con trỏ để nhân đôi). Malloc thứ hai cấp phát bộ nhớ cho giá trị kép mà x trỏ đến.

Khi bạn malloc(sizeof(struct_name))tự động phân bổ bộ nhớ cho kích thước đầy đủ của cấu trúc, bạn không cần phân bổ từng phần tử bên trong.

Sử dụng -fsanitize=addresscờ để kiểm tra cách bạn đã sử dụng bộ nhớ chương trình của mình.