C++ C++；简化构造函数重载

假设我正在制作一个类

客户端

。我希望

client

能够使用以下类型构造：

client(const boost::network::uri::uri &, const boost::network::uri::uri &)
client(const std::string &, const std::string &)
client(const char *, const char *)

但是。。。我还想要所有的排列

client(const boost::network::uri::uri &, const boost::network::uri::uri &)
client(const std::string &, const std::string &)
client(const char * &, const char * &)
client(const boost::network::uri::uri &, const std::string &)
client(const std::string &, const boost::network::uri::uri &)
client(const boost::network::uri::uri &, const char * &)
client(const char * &, const boost::network::uri::uri &)
client(const std::string &, const char * &)
client(const char * &, const std::string &)

为了简单起见，可以假设我的客户机类如下所示

#include <string>
#include <boost/network.hpp>

#define HOST_URI "..."
#define AUTH_URI HOST_URI"..."

namespace bn = boost::network;

class client
{

private:

  const bn::uri::uri host_;

  const bn::uri::uri auth_;

public:

  client(const bn::uri::uri & host = const bn::uri::uri(HOST_URI),
         const bn::uri::uri & auth = const bn::uri::uri(AUTH_URI));

  client(const std::string & host = const std::string(HOST_URI),
         const std::string & auth = const std::string(AUTH_URI));

  client(const char * & host = HOST_URI,
         const char * & auth = AUTH_URI);

  client(const bn::uri::uri & host = const bn::uri::uri(HOST_URI),
         const std::string & auth = const std::string(AUTH_URI));

  client(const std::string & host = const std::string(HOST_URI),
         const bn::uri::uri & auth = const bn::uri::uri(AUTH_URI));

  client(const bn::uri::uri & host = const bn::uri::uri(HOST_URI),
         const char * & auth = AUTH_URI);

  client(const char * & host = HOST_URI,
         const bn::uri::uri & auth = const bn::uri::uri(AUTH_URI));

  client(const std::string && host = const std::string(HOST_URI),
         const char * & auth = AUTH_URI);

  client(const char * & host = HOST_URI,
         const std::string && auth = const std::string(AUTH_URI));

};

#包括
#包括
#定义主机URI“…”
#定义身份验证URI主机URI“…”
名称空间bn=boost:：network；
类客户端
{
私人：
常量bn:：uri:：uri主机；
常量bn：：uri：：uri auth；
公众：
客户端（const bn:：uri:：uri&host=const bn:：uri:：uri（host_uri），
常量bn:：uri:：uri&auth=const bn:：uri:：uri（auth_uri））；
客户端（const std:：string&host=const std:：string（host_URI），
const std:：string&auth=const std:：string（auth_URI））；
客户端（const char*&host=host\u URI，
const char*&auth=auth_URI）；
客户端（const bn:：uri:：uri&host=const bn:：uri:：uri（host_uri），
const std:：string&auth=const std:：string（auth_URI））；
客户端（const std:：string&host=const std:：string（host_URI），
常量bn:：uri:：uri&auth=const bn:：uri:：uri（auth_uri））；
客户端（const bn:：uri:：uri&host=const bn:：uri:：uri（host_uri），
const char*&auth=auth_URI）；
客户端（const char*&host=host\u URI，
常量bn:：uri:：uri&auth=const bn:：uri:：uri（auth_uri））；
客户端（const std:：string&&host=const std:：string（主机URI），
const char*&auth=auth_URI）；
客户端（const char*&host=host\u URI，
常量std:：string&&auth=const std:：string（auth_URI））；
};

目前定义为：

#include <string>
#include <boost/network.hpp>

namespace bn = boost::network;

client::client(const bn::uri::uri & host,
               const bn::uri::uri & auth)
: host_(host), auth_(auth)
{
    ...
};

client::client(const std::string & host,
               const std::string & auth)
: client(bn::uri::uri(host), bn::uri::uri(auth)){}

client::client(const char * & host,
               const char * & auth)
: client(bn::uri::uri(host), bn::uri::uri(auth)){}

client::client(const bn::uri::uri & host,
               const std::string & auth)
: client(host, bn::uri::uri(auth)){}

client::client(const std::string & host,
               const bn::uri::uri & auth)
: client(bn::uri::uri(host), auth){}

client::client(const bn::uri::uri & host,
               const char * & auth)
: client(host, bn::uri::uri(auth)){}

client::client(const char * & host,
               const bn::uri::uri & auth)
: client(bn::uri::uri(host), auth){}

client::client(const std::string & host,
               const char * & auth)
: client(bn::uri::uri(host), bn::uri::uri(auth)){}

client::client(const char * & host,
               const std::string & auth)
: client(bn::uri::uri(host), bn::uri::uri(auth)){}

#包括
#包括
名称空间bn=boost:：network；
客户端：：客户端（常量bn：：uri：：uri和主机，
常量bn:：uri:：uri&auth）
：主机（主机），身份验证（身份验证）
{
...
};
客户端：：客户端（const std：：字符串和主机，
常量std:：字符串和身份验证）
：客户端（bn：：uri：：uri（主机），bn：：uri：：uri（auth））{
客户端：：客户端（常量字符*&主机，
常量字符*&auth）
：客户端（bn：：uri：：uri（主机），bn：：uri：：uri（auth））{
客户端：：客户端（常量bn：：uri：：uri和主机，
常量std:：字符串和身份验证）
：客户端（主机，bn:：uri:：uri（auth））{}
客户端：：客户端（const std：：字符串和主机，
常量bn:：uri:：uri&auth）
：client（bn：：uri：：uri（主机），auth）{}
客户端：：客户端（常量bn：：uri：：uri和主机，
常量字符*&auth）
：客户端（主机，bn:：uri:：uri（auth））{}
客户端：：客户端（常量字符*&主机，
常量bn:：uri:：uri&auth）
：client（bn：：uri：：uri（主机），auth）{}
客户端：：客户端（const std：：字符串和主机，
常量字符*&auth）
：客户端（bn：：uri：：uri（主机），bn：：uri：：uri（auth））{
客户端：：客户端（常量字符*&主机，
常量std:：字符串和身份验证）
：客户端（bn：：uri：：uri（主机），bn：：uri：：uri（auth））{

所以我的问题是，做这件事的正确和简单的方法是什么？

---

诚然，这次我手工完成了所有的置换，但将来我可能会有3+个变量进行置换，这将变得丑陋、快速。

因为uri定义了可以接受

字符串以及
常量char*
的构造函数，所以消除了参数不包括uri类型的构造函数。这允许uri隐式地为您转换这些类型

#define HOST_URI "..."
#define AUTH_URI HOST_URI"..."

class client
{
private:
  uri host_;

  uri auth_;

public:
  client(const uri & host = uri(HOST_URI),
         const uri & auth = uri(AUTH_URI));

  client(const char * host = HOST_URI,
         const char * auth = AUTH_URI);
};

-

“我如何专门将其委托给该构造函数？”
在使用委托构造函数时要明确

client(const char * && host, const char * && auth) :
             client(uri(host), uri(auth)){}

或

由于uri定义了可以接受
string
以及
const char*
的构造函数，因此消除了参数不包括uri类型的构造函数。这允许uri隐式地为您转换这些类型

#define HOST_URI "..."
#define AUTH_URI HOST_URI"..."

class client
{
private:
  uri host_;

  uri auth_;

public:
  client(const uri & host = uri(HOST_URI),
         const uri & auth = uri(AUTH_URI));

  client(const char * host = HOST_URI,
         const char * auth = AUTH_URI);
};

-

“我如何专门将其委托给该构造函数？”
在使用委托构造函数时要明确

client(const char * && host, const char * && auth) :
             client(uri(host), uri(auth)){}

或

由于uri定义了可以接受
string
以及
const char*
的构造函数，因此消除了参数不包括uri类型的构造函数。这允许uri隐式地为您转换这些类型

#define HOST_URI "..."
#define AUTH_URI HOST_URI"..."

class client
{
private:
  uri host_;

  uri auth_;

public:
  client(const uri & host = uri(HOST_URI),
         const uri & auth = uri(AUTH_URI));

  client(const char * host = HOST_URI,
         const char * auth = AUTH_URI);
};

-

“我如何专门将其委托给该构造函数？”
在使用委托构造函数时要明确

client(const char * && host, const char * && auth) :
             client(uri(host), uri(auth)){}

或

由于uri定义了可以接受
string
以及
const char*
的构造函数，因此消除了参数不包括uri类型的构造函数。这允许uri隐式地为您转换这些类型

#define HOST_URI "..."
#define AUTH_URI HOST_URI"..."

class client
{
private:
  uri host_;

  uri auth_;

public:
  client(const uri & host = uri(HOST_URI),
         const uri & auth = uri(AUTH_URI));

  client(const char * host = HOST_URI,
         const char * auth = AUTH_URI);
};

-

“我如何专门将其委托给该构造函数？”
在使用委托构造函数时要明确

client(const char * && host, const char * && auth) :
             client(uri(host), uri(auth)){}

或

模板怎么样：

#include <type_traits>

class client
{
    uri host_;
    uri auth_;

public:
    template <typename U, typename V,
              typename = typename std::enable_if<
                  std::is_constructible<uri, U&&>::value &&
                  std::is_constructible<uri, V&&>::value>::type>
    client(U && u, V && v)
    : host_(std::forward<U>(u))
    , auth_(std::forward<V>(v))
    { }

    // ...
};

#包括
类客户端
{
uri主机；
uri验证；
公众：
模板：：类型>
客户机（U&U、V&V）
：主机（标准：：转发（u））
，auth_（std:：forward（v））
{ }
// ...
};
模板怎么样：

#include <type_traits>

class client
{
    uri host_;
    uri auth_;

public:
    template <typename U, typename V,
              typename = typename std::enable_if<
                  std::is_constructible<uri, U&&>::value &&
                  std::is_constructible<uri, V&&>::value>::type>
    client(U && u, V && v)
    : host_(std::forward<U>(u))
    , auth_(std::forward<V>(v))
    { }

    // ...
};

#包括
类客户端
{
uri主机；
uri验证；
公众：
模板：：类型>
客户机（U&U、V&V）
：主机（标准：：转发（u））
，auth_（std:：forward（v））
{ }
// ...
};
模板怎么样：

#include <type_traits>

class client
{
    uri host_;
    uri auth_;

public:
    template <typename U, typename V,
              typename = typename std::enable_if<
                  std::is_constructible<uri, U&&>::value &&
                  std::is_constructible<uri, V&&>::value>::type>
    client(U && u, V && v)
    : host_(std::forward<U>(u))
    , auth_(std::forward<V>(v))
    { }

    // ...
};

#包括
类客户端
{
uri主机；
uri验证；
公众：
模板：：类型>
客户机（U&U、V&V）
：主机（标准：：转发（u））
，auth_（std:：forward（v））
{ }
// ...
};
模板怎么样：

#include <type_traits>

class client
{
    uri host_;
    uri auth_;

public:
    template <typename U, typename V,
              typename = typename std::enable_if<
                  std::is_constructible<uri, U&&>::value &&
                  std::is_constructible<uri, V&&>::value>::type>
    client(U && u, V && v)
    : host_(std::forward<U>(u))
    , auth_(std::forward<V>(v))
    { }

    // ...
};

#包括
类客户端
{
uri主机；
uri验证；
公众：
模板：：类型>
客户机（U&U、V&V）
：主机（标准：：转发（u））
，auth_（std:：forward（v））
{ }
// ...
};
您可以创建一个单独的类，它可以将这三个东西都作为参数。你的帖子没有包含足够的细节，我无法写出具体的答案，但下面是伪代码：

struct input_helper
{
    input_helper(uri &u);
    input_helper(string &u);
    input_helper(char *u);

    // data members to hold the inputs, maybe other processing to bring them to a common type
};

// the constructor
client(input_helper host, input_helper auth);

您可以创建一个单独的类，该类可以将这三个方面都作为参数。你的帖子没有包含足够的细节，我无法写出具体的答案，但下面是伪代码：

struct input_helper
{
    input_helper(uri &u);
    input_helper(string &u);
    input_helper(char *u);

    // data members to hold the inputs, maybe other processing to bring them to a common type
};

// the constructor
client(input_helper host, input_helper auth);

您可以创建一个单独的类，该类可以将这三个方面都作为参数。你的帖子没有足够的细节让我写一篇具体的文章