Con trỏ NULL với tăng :: shared_ptr?

Question

tương đương như sau là gì:

std::vector<Foo*> vec; 
vec.push_back(NULL); 

khi giao dịch với boost::shared_ptr? Có phải mã sau không?

std::vector< boost::shared_ptr<Foo> > vec; 
vec.push_back(boost::shared_ptr<Foo>()); 

Lưu ý: Tôi có thể đẩy lùi nhiều đối tượng như vậy. Tôi có nên khai báo một đối tượng tĩnh nullPtr tĩnh ở đâu đó không? Bằng cách đó, chỉ một trong số chúng sẽ phải được xây dựng:

boost::shared_ptr<Foo> nullPtr; 

Answer 1

Có, khai báo một con trỏ rỗng tĩnh tổng thể.

Answer 2

Bạn có thể khai báo toàn cầu nullPtr cho shared_ptr<Foo>. Nhưng nếu bạn gây ô nhiễm không gian tên chung, bạn sẽ gọi toàn cầu là gì nullPtr cho shared_ptr<Bar>?

Thông thường tôi khai báo ptr rỗng là tĩnh trong lớp con trỏ.

#include <boost\shared_ptr.hpp> 

class Foo; // forward decl 
typedef boost::shared_ptr<Foo> FooPtr; 
class Foo 
{ 
public: 
    static FooPtr Null; 
} 
... 
// define static in cpp file 
FooPtr Foo::Null; 
... 
// use Foo Null 
vec.push_back(Foo::Null); 

Bằng cách đó, mỗi lớp có một Null tĩnh.

Answer 3

Đề xuất của bạn (gọi số shared_ptr<T> hàm tạo không có đối số) là chính xác. (Gọi hàm khởi tạo với giá trị 0 là tương đương.) Tôi không nghĩ rằng điều này sẽ chậm hơn gọi số vec.push_back() với số sẵn có shared_ptr<T>, vì yêu cầu xây dựng trong cả hai trường hợp (xây dựng trực tiếp hoặc sao chép-xây dựng).

Nhưng nếu bạn muốn cú pháp "đẹp hơn", bạn có thể thử đoạn mã sau:

class { 
public: 
    template<typename T> 
    operator shared_ptr<T>() { return shared_ptr<T>(); } 
} nullPtr; 

này khai báo một đối tượng toàn cầu duy nhất nullPtr, cho phép cú pháp tự nhiên sau đây:

shared_ptr<int> pi(new int(42)); 
shared_ptr<SomeArbitraryType> psat(new SomeArbitraryType("foonly")); 

... 

pi = nullPtr; 
psat = nullPtr; 

Note nếu bạn sử dụng điều này trong nhiều đơn vị dịch (tệp nguồn), bạn sẽ cần đặt tên cho lớp (ví dụ: _shared_null_ptr_type), di chuyển định nghĩa của đối tượng nullPtr sang tệp .cpp riêng biệt và thêm extern khai báo trong t ông tập tin tiêu đề nơi lớp được xác định.

Answer 4

Vâng, điều này là hợp pháp:

shared_ptr<Foo> foo; /* don't assign */ 

Và trong trạng thái này, nó không trỏ đến bất cứ điều gì.Bạn thậm chí có thể kiểm tra khách sạn này:

if (foo) { 
    // it points to something 
} else { 
    // no it doesn't 
} 

Vậy tại sao không làm điều này:

std::vector < shared_ptr<Foo> > vec; 
vec.push_back (shared_ptr<Foo>); // push an unassigned one 

Answer 5

Dưới đây là một cái gì đó mà tôi nghĩ là một chút đơn giản hơn và làm việc tốt

(hãy nhớ rằng typedef là của bạn bạn bè):

#include <cstdlib> 
#include <vector> 
#include <iostream> 
#include <boost/shared_ptr.hpp> 

typedef boost::shared_ptr< std::vector<char> > CharVecHandle; 

inline CharVecHandle newCharVec(std::vector<char>::size_type size) { 
    return CharVecHandle(new std::vector<char>(size)); 
} 

inline CharVecHandle newCharVec(void) { 
    return CharVecHandle(); 
} 

int main (void) 
{ 
    CharVecHandle cvh = newCharVec(); 

    if (cvh == NULL) 
     std::cout << "It's NULL" << std::endl; 
    else 
     std::cout << "It's not NULL" << std::endl; 

    std::vector<CharVecHandle> cvh_vec; 

    cvh_vec.push_back(newCharVec(64)); 
    cvh_vec.push_back(newCharVec()); 

    // or call the NULL constructor directly 
    cvh_vec.push_back(CharVecHandle()); 

    return EXIT_SUCCESS; 
} 

Answer 6

Trong C++ 0x, bạn chỉ cần chuyển đổi từ nullptr đến std::shared_ptr:

std::vector< boost::shared_ptr<Foo> > vec; 
vec.push_back(nullptr);