Question

我正在尝试使用c ++ asio库（http://think-async.com/Asio/asio-1.10.6/doc/asio/overview/core/allocation.html）的自定义分配器功能。我的函数代码全部在命名空间bb中，自定义分配函数void* asio_handler_allocate(std::size_t size, ...)也是如此。我希望ADL选择我的自定义版本，但由于某种原因它会导致歧义：

c:\mysrv\asio\detail\handler_alloc_helpers.hpp(38): error C2668: 'bb::asio_handler_allocate': ambiguous call to overloaded function
1>  c:\mysrv\connection.hpp(16): note: could be 'void *bb::asio_handler_allocate(std::size_t,...)' [found using argument-dependent lookup]
1>  c:\mysrv\asio\impl\handler_alloc_hook.ipp(27): note: or       'void *asio::asio_handler_allocate(std::size_t,...)'
1>  c:\mysrv\asio\detail\handler_alloc_helpers.hpp(38): note: while trying to match the argument list '(std::size_t, bb::Server::do_accept::<lambda_18e060fa7342c1167c1b66e6dfdfd1b2> *)'

关于为什么第二个也正确匹配和/或如何正确使用此功能的任何解释将不胜感激

由于

P.S。我正在添加boost-asio标记，因为它应该是相同的库，但只在不同的命名空间中。我实际上在这里使用独立的c ++ 11版本http://think-async.com/

这是一个简化的例子：

#include "asio.hpp"
#include <memory>
#include <iostream>

namespace bb {
    void* asio_handler_allocate(std::size_t size, ...) {
        std::cerr << 'H' << ' ' << /**h <<*/ ' ' << size << '\n';
        return asio::asio_handler_allocate(size);
    }

    class Connection
        : public std::enable_shared_from_this<Connection>
    {
    public:
        Connection(asio::ip::tcp::socket socket)
            : socket_(std::move(socket))
        {
        }

        void start()
        {
            do_read();
        }

    private:
        void do_read()
        {
            auto self(shared_from_this());
            socket_.async_read_some(asio::buffer(data_),
                [this, self](std::error_code ec, std::size_t length)
            {
                if (!ec)
                {
                    do_write(length);
                }
            });
        }

        void do_write(std::size_t length)
        {
            auto self(shared_from_this());
            asio::async_write(socket_, asio::buffer(data_, length),
                [this, self](std::error_code ec, std::size_t /*length*/)
            {
                if (!ec)
                {
                    do_read();
                }
            });
        }

        asio::ip::tcp::socket socket_;
        std::array<char, 1024> data_;
    };

    class Server
    {
    public:
        Server(asio::io_service& io_service, short port)
            : acceptor_(io_service, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)),
            socket_(io_service)
        {
            do_accept();
        }

    private:
        void do_accept()
        {
            acceptor_.async_accept(socket_,
                [this](std::error_code ec)
            {
                if (!ec)
                {
                    std::make_shared<Connection>(std::move(socket_))->start();
                }

                do_accept();
            });
        }

        asio::ip::tcp::acceptor acceptor_;
        asio::ip::tcp::socket socket_;
    };
}

int main(int argc, char* argv[])
{
    try
    {
        if (argc != 2)
        {
            std::cerr << "Usage: server <port>\n";
            return 1;
        }

        asio::io_service io_service;
        bb::Server s(io_service, std::atoi(argv[1]));
        io_service.run();
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}

Answer 1

ADL只是将参数的名称空间添加到名称应该被查找的名称空间列表中（这不是很精确，但是出于你的问题的目的，它足够了）。它不会使该命名空间中的重载自动成为优先选择。如果找到两个同等排名的匹配，则仍会出现模糊不清的情况。在你的情况下，两者完全相同。

如果您阅读了链接的ASIO文档，您将知道声明ADL重载的正确方法是

 void* asio_handler_allocate(size_t, Handler);

其中Handler是用户定义的处理程序类型。上述声明也可能包含Handler的CV限定符。在这种情况下，找到的两个重载是一个，第二个参数是具体类型，另一个是...。与类型化参数匹配的任何 legal 的排名都高于可变参数（不要与C ++ 11可变参数模板参数混淆）。因此，不存在模棱两可的匹配

为什么此ADL解决方案不明显

1 个答案: