是否有可能将成员初始化推迟到构造函数体？

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种方式 “初始化” 属性：

• 初始化列表
• 的构造体

如果你没有exp在初始化器列表中初始化其中一个属性，然后初始化它（通过调用它的默认构造器）给你...

因此，在本质：

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++中，它是最好初始化成员初始化列表，而不是在构造函数体，所以实际上你可能会考虑把其他成员在初始化列表

如果你想创建一个构造其他构建函数调用，这是不可直到的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) 
{ 
} 

艾迪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

在这种情况下，另一种选择是通过创建一个静态函数建立EP来解决此问题：

#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)) 
{ 
}