C++ Suppress Automatic Initialization and Destruction

Question

Làm thế nào để ngăn chặn việc khởi tạo và hủy kiểu tự động? Trong khi nó là tuyệt vời mà T buffer[100] tự động khởi tạo tất cả các yếu tố của buffer, và phá hủy chúng khi chúng rơi ra khỏi phạm vi, đây không phải là hành vi tôi muốn.

#include <iostream> 

static int created = 0, 
      destroyed = 0; 

struct S 
{ 
    S() 
    { 
     ++created; 
    } 
    ~S() 
    { 
     ++destroyed; 
    } 
}; 

template <typename T, size_t KCount> 
class fixed_vector 
{ 
private: 
    T m_buffer[KCount]; 
public: 
    fixed_vector() 
    { 
     // some way to suppress the automatic initialization of m_buffer 
    } 

    ~fixed_vector() 
    { 
     // some way to suppress the automatic destruction of m_buffer 
    } 
}; 

int main() 
{ 
    { 
     fixed_vector<S, 100> arr; 
    } 

    std::cout << "Created:\t" << created << std::endl; 
    std::cout << "Destroyed:\t" << destroyed << std::endl; 
    return 0; 
} 

Kết quả của chương trình này là:

Created: 100 
Destroyed: 100 

Tôi muốn nó là:

Created: 0 
Destroyed: 0 

ý tưởng duy nhất của tôi là làm cho m_buffer một số trivially xây dựng và destructed loại như char và sau đó dựa vào operator[] để bọc toán con trỏ cho tôi, mặc dù điều này có vẻ giống như một giải pháp bị tấn công khủng khiếp. Một giải pháp khác là sử dụng malloc và free, nhưng điều đó mang lại một mức độ vô hướng mà tôi không muốn.

---

Lý do tôi muốn điều này là vì tôi đang tạo thùng chứa và tôi không muốn trả tiền cho phí khởi tạo của những thứ mà tôi sẽ không sử dụng. Ví dụ, nếu chức năng main của tôi là:

int main() 
{ 
    { 
     std::vector<S> vec; 
     vec.reserve(50); 
    } 

    std::cout << "Created:\t" << created << std::endl; 
    std::cout << "Destroyed:\t" << destroyed << std::endl; 
    return 0; 
} 

Kết quả sẽ chính xác:

Created: 0 
Destroyed: 0 

Answer 1

Bạn có thể tạo mảng dưới dạng mảng char s rồi sử dụng placement new để tạo các phần tử khi cần.

template <typename T, size_t KCount> 
class Array 
{ 
private: 
    char m_buffer[KCount*sizeof(T)]; // TODO make sure it's aligned correctly 

    T operator[](int i) { 
     return reinterpret_cast<T&>(m_buffer[i*sizeof(T)]); 
    } 

---

Sau khi đọc câu hỏi của bạn có vẻ như bạn muốn có một mảng thưa thớt, điều này đôi khi trôi qua tên của đồ; o) (tất nhiên các đặc tính hiệu suất khác nhau ...)

template <typename T, size_t KCount> 
class SparseArray { 
    std::map<size_t, T> m_map; 
public: 
    T& operator[](size_t i) { 
     if (i > KCount) 
      throw "out of bounds"; 
     return m_map[i]; 
    } 

Answer 2

Bạn có thể có một cái nhìn vào cách nó được thực hiện với các container STL, nhưng tôi nghi ngờ bạn có thể tha mình malloc s và free s

Answer 3

mã này:

#include <iostream> 
#include <vector> 
using namespace std; 

int created = 0, destroyed = 0; 

struct S 
{ 
    S() 
    { 
     ++created; 
    } 
    S(const S & s) { 
     ++created; 
    } 
    ~S() 
    { 
     ++destroyed; 
    } 
}; 

int main() 
{ 
    { 
     std::vector<S> vec; 
     vec.reserve(50); 
    } 

    std::cout << "Created:\t" << created << std::endl; 
    std::cout << "Destroyed:\t" << destroyed << std::endl; 
    return 0; 
} 

có chính xác kết quả bạn muốn - Tôi không chắc câu hỏi của bạn là gì.

Answer 4

Bạn có thể muốn xem xét boost::optional

template <typename> struct tovoid { typedef void type; }; 

template <typename T, size_t KCount, typename = void> 
struct ArrayStorage { 
    typedef T type; 
    static T &get(T &t) { return t; } 
}; 

template <typename T, size_t KCount> 
struct ArrayStorage<T, KCount, typename tovoid<int T::*>::type> { 
    typedef boost::optional<T> type; 
    static T &get(boost::optional<T> &t) { 
    if(!t) t = boost::in_place(); 
    return *t; 
    } 
}; 

template <typename T, size_t KCount> 
class Array 
{ 
public: 
    T &operator[](std::ptrdiff_t i) { 
     return ArrayStorage<T, KCount>::get(m_buffer_[i]); 
    } 

    T const &operator[](std::ptrdiff_t i) const { 
     return ArrayStorage<T, KCount>::get(m_buffer_[i]); 
    } 

    mutable typename ArrayStorage<T, KCount>::type m_buffer_[KCount]; 
}; 

Một chuyên môn được thực hiện cho loại lớp kết thúc chúng thành một optional, do đó gọi hàm tạo/destructor lazily. Đối với các loại không phải lớp, chúng tôi không cần gói đó. Không gói chúng có nghĩa là chúng ta có thể xử lý &a[0] như một vùng bộ nhớ liền kề và chuyển địa chỉ đó tới các hàm C muốn một mảng. boost::in_place sẽ tạo các loại lớp tại chỗ, mà không cần sử dụng tạm thời T hoặc hàm tạo bản sao của lớp.

Không sử dụng thừa kế hoặc thành viên private cho phép các lớp ở một số tổng hợp, cho phép một hình thức thuận tiện để khởi

// only two strings are constructed 
Array<std::string, 10> array = { a, b }; 

Answer 5

Nếu bạn muốn được như vector, bạn nên làm một cái gì đó như thế này:

template <typename T> 
class my_vector 
{ 
    T* ptr; // this is your "array" 
    // ... 
    public: 

    void reserve(size_t n) 
    { 
     // allocate memory without initializing, you could as well use malloc() here 
     ptr = ::operator new (n*sizeof(T)); 
    } 

    ~my_vector() 
    { 
     ::operator delete(ptr); // and this is how you free your memory 
    } 

    void set_element(size_t at, const T& element = T()) 
    { 
     // initializes single element 
     new (&ptr[at]) T(element); // placement new, copies the passed element at the specified position in the array 
    } 

    void destroy_element(size_t at) 
    { 
     ptr[at].~T(); // explicitly call destructor 
    } 
}; 

Mã này rõ ràng chỉ dành cho trình diễn, tôi đã bỏ qua trình tạo bản sao của my_vector và bất kỳ việc theo dõi nào được tạo ra và những gì không (gọi destructor trên một vị trí mà bạn chưa gọi là hàm tạo có thể là hành vi không xác định). Ngoài ra, phân bổ vector của STL và deallocations được abstracted đi qua việc sử dụng các phân bổ (các đối số mẫu thứ hai của vector).

Hy vọng rằng sẽ giúp