Подходящее использование boost::asio::placeholders::error

Если вы думали о положении параметра (_1), это правильно, потому что подпись обработчика (docs):

void handler(
    const boost::system::error_code& error // Result of operation.
);

Обратите внимание, что вашим обработчиком является выражение связывания, а не handle_accept (которое принимает 3 аргумента, включая аргумент this).

Если вы считаете, что _1 более выразительно, дерзайте.

Тем временем,

• не используйте глобальные заполнители Boost Bind (включайте <boost/bind/bind.hpp> или настраивайте определения компилятора)
• еще лучше заменить boost::bind на std::bind
• замените boost::shared_ptr и boost::enable_shared_from_this на std::xxx
• используйте псевдонимы типов вместо определений типов
• не иметь неиспользуемых аргументов (например, bytes_transferred); в частности, НЕ полагайтесь на NUL-завершение data!
• не используйте using namespace без разбора
• не используйте массивы в стиле C
• не завышайте размер буфера (это источник ошибок)
• ловить исключения const&
• сделать handle_XYZ приватным
• не нужно sock.close() при ошибке; вы можете отменить любые цепочки асинхронных операций и позволить деструктору con_handler справиться с этим. В вашем случае даже cancel является избыточным, поскольку нет асинхронных циклов, а одно чтение/запись уже не удалось.

Упрощенно до этого момента: Live On Coliru

#include <boost/asio.hpp>
#include <iomanip>
#include <iostream>
namespace asio = boost::asio;
using namespace std::placeholders;
using asio::ip::tcp;

struct con_handler : std::enable_shared_from_this<con_handler> {
    using pointer = std::shared_ptr<con_handler>;
    con_handler(asio::any_io_executor ex) : sock(ex) {}

    tcp::socket& socket() { return sock; }

    void start() {
        auto self = shared_from_this();
        sock.async_read_some(asio::buffer(data), bind(&con_handler::handle_read, self, _1, _2));
        sock.async_write_some(asio::buffer(message), bind(&con_handler::handle_write, self, _1, _2));
    }

  private:
    void handle_read(boost::system::error_code const& err, size_t bytes_transferred) {
        std::cerr << "recv: " << bytes_transferred << "(" << err.message() << ")" << std::endl;
        if (!err) {
            std::string_view msg(data.data(), bytes_transferred);
            std::cout << quoted(msg) << std::endl;
        }
        // else sock.cancel();
    }

    void handle_write(boost::system::error_code const& err, size_t bytes_transferred) {
        std::cerr << "sent: " << bytes_transferred << "(" << err.message() << ")" << std::endl;
        if (!err)
            std::cout << "Server sent " << quoted(message) << std::endl;

        // else sock.cancel();
    }

    tcp::socket            sock;
    std::string            message = "Hello From Server!";
    std::array<char, 1024> data;
};

struct Server {
    Server(asio::any_io_executor ex) //
        : acceptor_(ex, tcp::endpoint(tcp::v4(), 1234)) {
        start_accept();
    }

    void handle_accept(con_handler::pointer connection, boost::system::error_code const& err) {
        if (!err)
            connection->start();

        start_accept();
    }

  private:
    tcp::acceptor acceptor_;

    void start_accept() {
        con_handler::pointer connection = std::make_shared<con_handler>(acceptor_.get_executor());

        acceptor_.async_accept(connection->socket(), bind(&Server::handle_accept, this, connection, _1));
    }
};

int main() try {
    asio::io_context ioc;
    Server           server(ioc.get_executor());
    ioc.run();
} catch (std::exception const& e) {
    std::cerr << e.what() << std::endl;
}

Локальная демо:

Версия Asio: get_io_service() указывает на древнюю версию boost.

• вместо ссылок io_service передавайте исполнителей, делая код менее связанным и его легче поддерживать.
• не используйте частные конструкторы и new в пользу make_shared
• используйте перегрузку перемещения-принятия async_accept, чтобы вам не приходилось нарушать инкапсуляцию с помощью socket() { return sock; }

Текстовые протоколы:

• Рассмотрите возможность логического чтения вместо read_some. Например. определитесь с построчным вводом-выводом, чтобы вы читали до первой новой строки (а также писали сообщения с ограничителем новой строки)

v2 Live On Coliru

#include <boost/asio.hpp>
#include <iomanip>
#include <iostream>
namespace asio = boost::asio;
using namespace std::placeholders;
using asio::ip::tcp;

struct con_handler : std::enable_shared_from_this<con_handler> {
    con_handler(tcp::socket s) : sock(std::move(s)) {}

    void start() {
        do_read();
        async_write(sock, asio::buffer(message), //
                    bind(&con_handler::handle_write, shared_from_this(), _1, _2));
    }

  private:
    void do_read() {
        async_read_until(sock, asio::dynamic_buffer(response), "\n",
                         bind(&con_handler::handle_read, shared_from_this(), _1, _2));
    }

    void handle_read(boost::system::error_code const& err, size_t bytes_transferred) {
        std::cerr << "recv: " << bytes_transferred << "(" << err.message() << ")" << std::endl;
        if (!err) {
            auto msg = response.substr(0, bytes_transferred - 1);
            response.erase(0, bytes_transferred);

            std::cout << quoted(msg) << std::endl;
            do_read();
        }

        // else sock.cancel();
    }

    void handle_write(boost::system::error_code const& err, size_t bytes_transferred) {
        std::cerr << "sent: " << bytes_transferred << "(" << err.message() << ")" << std::endl;
        if (!err)
            std::cout << "Server sent " << quoted(message) << std::endl;

        // else sock.cancel();
    }

    tcp::socket sock;
    std::string message = "Hello From Server!\n", response;
};

struct Server {
    Server(asio::any_io_executor ex) : acceptor_(ex, tcp::endpoint(tcp::v4(), 1234)) { accept_loop(); }

  private:
    tcp::acceptor acceptor_;

    void accept_loop() {
        acceptor_.async_accept([this](boost::system::error_code ec, tcp::socket s) {
            if (!ec)
                std::make_shared<con_handler>(std::move(s))->start();

            accept_loop();
        });
    }
};

int main() try {
    asio::io_context ioc;
    Server           server(ioc.get_executor());
    ioc.run();
} catch (std::exception const& e) {
    std::cerr << e.what() << std::endl;
}

С более полезной локальной демонстрацией: