Можно ли отложить инициализацию члена в тело конструктора?

Question

У меня есть класс с объектом в качестве члена, который не имеет конструктора по умолчанию. Я хотел бы инициализировать этот элемент в конструкторе, но кажется, что в C++ я не могу этого сделать. Вот класс:

#include <boost/asio.hpp> 
#include <boost/array.hpp> 

using boost::asio::ip::udp; 

template<class T> 
class udp_sock 
{ 
    public: 
     udp_sock(std::string host, unsigned short port); 
    private: 
     boost::asio::io_service _io_service; 
     udp::socket _sock; 
     boost::array<T,256> _buf; 
}; 

template<class T> 
udp_sock<T>::udp_sock(std::string host = "localhost", 
    unsigned short port = 50000) 
{ 
    udp::resolver res(_io_service); 
    udp::resolver::query query(udp::v4(), host, "spec"); 
    udp::endpoint ep = *res.resolve(query); 
    ep.port(port); 
    _sock(_io_service, ep); 
} 

Компилятор говорит мне, в принципе, что он не может найти конструктор по умолчанию для UdP :: розеткой и моих исследований я понял, что C++ неявно инициализирует каждый элемент перед вызовом конструктора. Есть ли способ сделать это так, как я хотел это сделать, или это слишком «ориентировано на Java» и не возможно в C++?

Я работал вокруг проблемы, определив мой конструктор так:

template<class T> 
udp_sock<T>::udp_sock(std::string host = "localhost", 
    unsigned short port = 50000) : _sock(_io_service) 
{ 
    udp::resolver res(_io_service); 
    udp::resolver::query query(udp::v4(), host, "spec"); 
    udp::endpoint ep = *res.resolve(query); 
    ep.port(port); 
    _sock.bind(ep); 
} 

Так что мой вопрос больше из любопытства и, чтобы лучше понять ООП в C++

Answer 1

При определении конструктора, у вас есть 2 способа "Initialize" атрибуты:

• список инициализатор
• корпус конструктора

Если вы не используете exp lictly инициализирует один из атрибутов в списке инициализаторов, он тем не менее инициализируется (вызывая его конструктор по умолчанию) для вас ...

Таким образом, в сущности:

class Example 
{ 
public: 
    Example(); 
private: 
    Bar mAttr; 
}; 

// You write 
Example::Example() {} 

// The compiler understands 
Example::Example(): mAttr() {} 

И это, конечно, не выполняется, если базовый тип не имеет конструктор по умолчанию.

Существуют различные способы отложить эту инициализацию. «Стандартный» способ будет использовать указатель:

class Example { public: Example(); private: Bar* mAttr; }; 

Однако я предпочитаю использовать Boost.Optional в сочетании с подходящими аксессорами:

class Example 
{ 
public: Example(); 
private: 
    Bar& accessAttr() { return *mAttr; } 
    const Bar& getAttr() const { return *mAttr; } 
    boost::Optional<Bar> mAttr; 
}; 

Example::Example() { mAttr = Bar(42); } 

Поскольку Boost.Optional означает, что нет никаких накладных расходов на распределении и нет накладных расходов на разыменование (объект создается на месте) и все же несет правильную семантику.

Answer 2

Я думаю, что это один возможный вариант использования boost::optional.

Answer 3

В C++ это предпочтительнее, чтобы инициализировать элементы в списке инициализации, а не тело конструктора, поэтому на самом деле вы могли бы рассмотреть вопрос о создании других членов в списке инициализации

Если вы подумываете о создании конструктора что другие ctors называют, что не доступно сезам C++ 0x (см inheriting constructors)

Answer 4

Если это инициализировать переменную во время строительства в конструктору класса правильный путь:

template<class T> 
udp_sock<T>::udp_sock(std::string host = "localhost", unsigned short port = 50000) 
    :res(_io_service) 
    ,query(udp::v4(), host, "spec") 
    ,ep(*res.resolve(query)) 
    ,_sock(_io_service, ep) 
{ 
} 

Edi t: Забыл упомянуть, что «res», «query» и «ep» должны быть частью класса. Другой грубый метод (без _sock как указатель) является, как указано ниже:

template<class T> 
udp_sock<T>::udp_sock(std::string host = "localhost", unsigned short port = 50000) 
    :_sock(_io_service, udp::resolver(_io_service).resolve(udp::resolver::query(udp::v4(),host,"spec")) 
{ 
} 

Answer 5

Я думаю, что ваше решение является правильным способом сделать вещи.

Вы также можете отложить создание объекта, делая это указатель (однако он изменяет код и тип данных):

std::auto_ptr<udp::socket> _sock; 

И тогда в теле:

_sock.reset(new udp::soket(_io_service, ep)); 

Но я думаю, что ваш «обходной путь» является скорее правильным решением, чем обходным путем.

Answer 6

Вы можете превратить _sock элемент в smart pointer:

#include <boost/asio.hpp> 
#include <boost/array.hpp> 
#include <boost/scoped_ptr.hpp> 

using boost::asio::ip::udp; 

template<class T> 
class udp_sock 
{ 
    public: 
     udp_sock(std::string host, unsigned short port); 
    private: 
     boost::asio::io_service _io_service; 
     boost::scoped_ptr<udp::socket> _sock_ptr; 
     boost::array<T,256> _buf; 
}; 

template<class T> 
udp_sock<T>::udp_sock(std::string host = "localhost", 
    unsigned short port = 50000) 
{ 
    udp::resolver res(_io_service); 
    udp::resolver::query query(udp::v4(), host, "spec"); 
    udp::endpoint ep = *res.resolve(query); 
    ep.port(port); 
    _sock_ptr.reset(new udp::socket(_io_service, ep)); 
} 

Answer 7

Другим вариантом в этом случае является работой по вопросу создания статической функции для построения ера:

#include <boost/asio.hpp> 
#include <boost/array.hpp> 

using boost::asio::ip::udp; 

template<class T> 
class udp_sock 
{ 
    public: 
     udp_sock(std::string host, unsigned short port); 
    private: 
     static udp::endpoint build_ep(const std::string &host, 
      unsigned short port, boost::asio::io_service &io_service); 

     boost::asio::io_service _io_service; 
     udp::socket _sock; 
     boost::array<T,256> _buf; 
}; 

template<class T> 
udp::endpoint udp_sock<T>::build_ep(const std::string &host, 
    unsigned short port, boost::asio::io_service &io_service) 
{ 
    udp::resolver res(io_service); 
    udp::resolver::query query(udp::v4(), host, "spec"); 
    udp::endpoint ep = *res.resolve(query); 
    ep.port(port); 
    return ep; 
} 

template<class T> 
udp_sock<T>::udp_sock(std::string host = "localhost", 
    unsigned short port = 50000) 
    : _sock(_io_service, build_ep(host, port, _io_service)) 
{ 
}