Tôi có thể tạo biến _const từ bây giờ trở đi_ không?

Question

Tôi đang sử dụng thư viện có lớp học với hàm init khác với hàm tạo của nó. Mỗi lần tôi làm cho một trường hợp mới tôi cần phải gọi, ví dụ:

MyClass a; 
a.init(); 

Kể từ init không phải là const, điều này ngăn cản tôi từ việc tạo trường const (Tôi không thể viết const MyClass a). Có cách nào để gọi init và sau đó tuyên bố từ "ở đây trên" (tôi đoán cho phần còn lại của phạm vi) biến của tôi là const?

này hoạt động, nhưng dựa vào không chạm vào biến ban đầu:

MyClass dont_touch; 
dont_touch.init(); 
const MyClass & a = dont_touch; 

Answer 1

Nếu bạn đang sử dụng C++ 11 bạn có thể sử dụng một hàm lambda

const MyClass ConstantVal = []{ 
    MyClass a; 
    a.init(); 
    return a; 
}(); 

này cho phép bạn để giữ cho khởi tạo tại chỗ trong khi không bao giờ cho phép truy cập bên ngoài để các đối tượng có thể thay đổi. also see: http://herbsutter.com/2013/04/05/complex-initialization-for-a-const-variable/

Answer 2

Tạo một chức năng mà kết thúc tốt đẹp hai dòng đầu tiên và mang đến cho bạn một đối tượng mà đã sẵn sàng để đi.

MyClass makeMyClass() 
{ 
    MyClass a; 
    a.init(); 
    return a; 
} 

// Now you can construct a const object or non-const object. 
const MyClass a = makeMyClass(); 
MyClass b = makeMyClass(); 

Cập nhật

Sử dụng makeMyClass() liên quan đến việc xây dựng và phá hủy một đối tượng tạm thời mọi hàm được gọi. Nếu điều đó trở thành chi phí đáng kể, makeMyClass() có thể được thay đổi thành:

MyClass const& makeMyClass() 
{ 
    static bool inited = false; 
    static MyClass a; 
    if (!inited) 
    { 
    inited = true; 
    a.init(); 
    } 
    return a; 
} 

Cách sử dụng, như được mô tả trước đó sẽ tiếp tục hoạt động. Ngoài ra, một khi cũng có thể thực hiện việc này:

const MyClass& c = makeMyClass(); 

Answer 3

Bạn có thể tạo lớp trình bao bọc và sử dụng thay thế.

Nếu MyClass có một destructor ảo mà bạn có thể cảm thấy bắt nguồn an toàn từ nó như thế này:

class WrapperClass : public MyClass 
{ 
public: 
    WrapperClass() 
    { 
     init(); // Let's hope this function doesn't throw 
    } 
}; 

Hoặc viết một lớp có chứa các ví dụ MyClass

class WrapperClass 
{ 
public: 
    WrapperClass() 
    { 
     m_myClass.init(); // Let's hope this function doesn't throw 
    } 
    operator MyClass&() {return m_myClass;} 
    operator const MyClass&() const {return m_myClass;} 
private: 
    MyClass m_myClass; 
}; 

Hoặc viết một bản mẫu để giải quyết này vấn đề chung khi sử dụng một trong hai giải pháp trên: ví dụ:

template <class T> class WrapperClass : public T 
{ 
public: 
    WrapperClass() 
    { 
     T::init(); 
    } 
}; 

typedef WrapperClass<MyClass> WrapperClass; 

Answer 4

Bạn thực sự có thể làm điều đó khá đơn giản, thậm chí không có C++ 11 và lambdas:

const MyClass a; 
{ 
    MyClass _a; 
    _a.init(); 
    std::swap(const_cast<MyClass&>(a), _a); 
} 

Việc sử dụng const_cast là phải thừa nhận là một chút của một hack, nhưng nó đã giành' t phá vỡ bất cứ điều gì như const là một specifier khá yếu. Đồng thời, nó khá hiệu quả, vì đối tượng MyClass chỉ đổi chỗ, không được sao chép (hầu hết các đối tượng đắt tiền để sao chép hợp lý nên cung cấp chức năng swap và bơm quá tải std::swap).

Nếu không có các diễn viên, nó sẽ đòi hỏi một helper:

struct Construct_Init { 
    operator MyClass() const 
    { 
     MyClass a; 
     a.init(); 
     return a; 
    } 
}; 
const MyClass a = Construct_Init(); 

Đây có thể là như thế này trong một hàm (cấu trúc Construct_Init cần không được khai báo ở phạm vi không gian tên), nhưng nó là lâu hơn một chút. Bản sao của đối tượng có thể hoặc không được tối ưu hóa bằng cách sử dụng bản sao.

Lưu ý rằng trong cả hai trường hợp, giá trị trả lại của init() bị mất. Nếu nó trả về một boolean nơi true là thành công và false là thất bại, nó là tốt hơn để:

if(!a.init()) 
    throw std::runtime_error("MyClass init failed"); 

Hoặc chỉ cần đảm bảo để xử lý các lỗi một cách thích hợp.