Xóa toán tử và mảng?

Question

Tôi có lớp học abstractBase và lớp Derived.

int main() 
{ 
    Base *arrayPtr[3]; 

    for (int i = 0; i < 3; i++) 
    { 
    arrayPtr[i] = new Derived(); 
    } 

    //some functions here 

    delete[] arrayPtr; 

    return 0; 
} 

Tôi không biết cách sử dụng toán tử xóa. Nếu tôi xóa các mảng của các con trỏ lớp cơ sở như được hiển thị ở trên, thì cuộc gọi này có dẫn xuất các đối tượng lớp hủy và làm sạch bộ nhớ không?

Answer 1

Bạn có để lặp qua các phần tử của mảng của bạn, delete mỗi trong số họ. Sau đó, gọi delete [] trên mảng nếu nó đã được phân bổ động bằng cách sử dụng new[].

Trong mã mẫu của bạn, mảng được cấp phát trên ngăn xếp để bạn không được gọi delete [] trên đó.

Ngoài ra, hãy đảm bảo lớp học Base của bạn có hàm hủy là virtual.

Tham chiếu: When should my destructor be virtual.

Answer 2

Không, bạn phải xóa một cách rõ ràng từng hạng mục trong mảng:

for (int i = 0; i < 3; ++i) 
{ 
    delete arrayPtr[i]; 
} 

Answer 3

Bạn thay vào đó nên làm:

for (int = i; i < 3; i++) 
{ 
    delete arrayPtr[i]; 
} 

Và bạn không nên làm delete[] arrayPtr; như bạn đang cố gắng để miễn phí/xóa một stack giao arrayPtr.

Một điều cần xem xét là sử dụng một số std::vector của con trỏ thay vì mảng. Và nếu bạn đang sử dụng trình biên dịch thực hiện TR1, bạn cũng có thể sử dụng một số std::vector của std::tr1::shared_ptr thay cho con trỏ thô và bạn sẽ không phải lo lắng về việc xóa các đối tượng đó.

Ví dụ:

{ 
    std::vector< std::tr1::shared_ptr<Base> > objects; 
    for (int i=0; i < 3; ++i) 
    { 
     objects.push_back(std::tr1::shared_ptr<Base>(new Derived())); 
    } 
} // here, once "objects" exit scope, all of your Derived objects are nicely deleted 

Answer 4

Hãy chắc chắn rằng Base có một destructor ảo. Sau đó, như fretje outlined, hãy xóa từng phần tử trong mảng, sau đó xóa mảng đó.

Bạn nên sử dụng std::vector cho mảng đó. Điều đó nói rằng, bạn nên thực sự đang sử dụng một hộp chứa được làm cho loại điều này. (Vì vậy, bạn không vô tình không xóa tất cả các yếu tố, mà chắc chắn sẽ là trường hợp nếu một ngoại lệ được ném!) Tăng có such a library.

Answer 5

Bạn phải xóa từng thành viên của mảng. Bạn cũng phải chắc chắn rằng lớp cơ sở của bạn có một destructor ảo. Bạn cũng có thể muốn xem xét làm cho nó trở thành một mảng (hoặc tốt hơn vẫn là một std :: vector) của các con trỏ thông minh, chẳng hạn như boost :: shared_ptr.

Answer 6

Không, bạn không thể làm điều đó. Như những người khác đề nghị bạn phải đi qua từng mục và xóa nó. Đó là một quy tắc rất đơn giản cần nhớ. Nếu bạn đã phân bổ bằng cách sử dụng new thì hãy sử dụng delete và nếu bạn đã sử dụng new[] thì sử dụng delete[]

Answer 7

Không, điều này không thực sự làm những gì bạn muốn.

Có hai điểm cần xem ra cho ở đây:

1. Cú pháp delete[] arrayPtr được sử dụng nếu bạn tự động phân bổ mảng, như thế này:

   arrayPtr = new (Base *)[mylength]; 
   

   Trong trường hợp của bạn, tuy nhiên, bạn có một mảng được phân bổ tĩnh, vì vậy không cần phải xóa nó. Bạn làm gì, tuy nhiên, cần phải xoá bỏ các yếu tố cá nhân trong mảng:

   for (int = i; i < 3; i++) 
       delete arrayPtr[i]; 
   

2. Điểm thứ hai bạn cần phải chăm sóc là làm cho destructor của lớp Base ảo:

   class Base 
   { 
       virtual ~Base(); 
       /* ... */ 
   }; 
   

   Điều này đảm bảo rằng khi bạn gọi xóa trên Base * thực sự trỏ đến một số Derived, thì hàm hủy của Derived được gọi, không chỉ là hàm hủy của Base.

Answer 8

Chú ý gì vắng mặt:

int main() { 
    boost::ptr_vector<Base> v; 
    for (int i = 0; i < 3; i++) v.push_back(new Derived()); 
    // some functions here, using v[0] through v[2] 
} 

Kiểm tra Boost's pointer containers ra.

Answer 9

Toán tử xóa phải khớp với toán tử mới trên con trỏ đó, nếu nó được cấp phát với new[], bạn phải gọi delete[] và ngược lại;

int* pInt = new int; 
delete pInt; OK 
delete [] pInt; WRONG 

int[] pIntArr = new int[3]; 
delete [] pIntArr; OK 
delete pIntArr; WRONG 

Trong trường hợp của bạn có điều gì khác không đúng - bạn đang cố gắng phân bổ delete trên ngăn xếp. Điều đó sẽ không hiệu quả.

Bạn phải xóa riêng từng con trỏ trong trường hợp cụ thể này.

Answer 10

Những gì bạn có ở đó là hành vi không xác định - một lỗi. Mỗi cuộc gọi đến new cần phải khớp với delete; mỗi cuộc gọi đến new[] cần phải được đối sánh với một delete[]. Cả hai là riêng biệt và không thể được trộn lẫn.

Trong mã bạn đã đăng, bạn có một chuỗi con trỏ tới Căn cứ được cấp phát trên ngăn xếp. Sau đó, bạn đang gọi delete[] trên một mảng được cấp phát trên ngăn xếp - bạn không thể làm điều đó. Bạn chỉ có thể delete[] một mảng được phân bổ trên heap với new[].

Bạn cần có cuộc gọi đến delete cho mỗi phần tử được phân bổ với new - hoặc tốt hơn là hãy xem xét sử dụng lớp chứa, chẳng hạn như std::vector, thay vì sử dụng mảng.

Answer 11

Bạn đang trộn mô hình - Toán tử xóa mảng được thiết kế để giải phóng bộ nhớ được cấp bởi toán tử mới mảng, nhưng bạn phân bổ mảng của bạn trên ngăn xếp dưới dạng mảng con trỏ và sau đó phân bổ đối tượng cho mỗi mảng hội viên. Trong mã của bạn, bạn cần phải lặp qua mảng.

Để sử dụng các nhà điều hành mảng mới, bạn muốn tuyên bố như thế này:

Base *array; 
array = new Base[3]; 
/* do stuff */ 
delete[] array; 

này phân bổ một khu vực bộ nhớ tiếp giáp với ba đối tượng - lưu ý rằng bạn đã có một mảng các đối tượng cơ sở, không một mảng con trỏ tới các đối tượng Base.