小编Chr*_*isz的帖子

根据文档：

“程序必须确保流不执行其他写入操作（例如 async_write、流的 async_write_some 函数或任何其他执行写入的组合操作），直到此操作完成。”

这是否意味着，在调用第一个处理程序之前，我不能第二次调用 boost::asio::async_write ？如何实现这一点并且仍然是异步的？

如果我有一个方法发送：

//--------------------------------------------------------------------
void Connection::Send(const std::vector<char> & data)
{
    auto callback = boost::bind(&Connection::OnSend, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred);
    boost::asio::async_write(m_socket, boost::asio::buffer(data), callback);
}

我是否必须将其更改为：

//--------------------------------------------------------------------
void Connection::Send(const std::vector<char> & data)
{
    // Issue a send
    std::lock_guard<std::mutex> lock(m_numPostedSocketIOMutex);
    ++m_numPostedSocketIO;

    m_numPostedSocketIOConditionVariable.wait(lock, [this]() {return m_numPostedSocketIO == 0; });

    auto callback = boost::bind(&Connection::OnSend, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred);
    boost::asio::async_write(m_socket, boost::asio::buffer(data), callback);
}

如果是这样，那么我不是在第一次调用后又阻塞了吗？

创建通道和存根时，如何检查 RPC 客户端是否确实成功连接到 RPC 服务器？

我希望能够在连接失败时抛出异常或信号。我不确定什么方法有资格在这里尝试“操作”。我不想进行我们定义的任何 RPC 调用，因为它们都会产生影响......除非唯一的选择是实现一些“嗨，我在这里”RPC 方法，但这看起来很愚蠢， 不？

void ChatSyncClient::connect(QUrl const& endpoint)
{
    disconnect();

    // TODO - How do we tell if this fails?
    //        The comments say a lame channel will be returned, where all operations fail
    //        How are we suppose to check right here rather than later?
    auto channel = ::grpc::CreateChannel(endpoint.toString().toStdString(), ::grpc::InsecureChannelCredentials());
    m_stub = std::make_unique<chat_sync::Chat::Stub>(channel);

    emit signalOnConnected();
}

我正在尝试学习如何在 C++ 中异步使用 gRPC。在https://github.com/grpc/grpc/blob/v1.33.1/examples/cpp/helloworld/greeter_async_client.cc查看客户端示例

除非我误解，否则我没有看到任何异步被证明。只有一个 RPC 调用，它会阻塞在主线程上，直到服务器处理它并将结果发回。

我需要做的是创建一个可以进行一个 RPC 调用的客户端，然后在等待第一个从服务器返回的结果的同时启动另一个。

我不知道该怎么做。

有没有人有一个工作示例，或者任何人都可以描述如何实际异步使用 gRPC？

他们的示例代码：

/*
 *
 * Copyright 2015 gRPC authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed …

我试图通过从我的一些方法而不是原始指针返回unique_ptr来更安全一些.但是,在返回指向多态类型的唯一指针时,我有点困惑.

我们如何返回指向派生类类型的基类类型的唯一指针？

另外,作为次要问题不太重要 - 我是否正确地使用移动构造函数从基类创建派生类？

这是我的最小例子:

// Standard Includes
#include <exception>
#include <memory>
#include <string>
#include <sstream>

//--------------------------------------------------------------------------------------------------
class BaseResult
{
public:

    std::string m_x;

    virtual ~BaseResult() {};
};

class DerivedResult : public BaseResult
{
public:

    int m_y;

    DerivedResult()
        :
        BaseResult()
    {}

    DerivedResult(const DerivedResult & rhs)
        :
        BaseResult(rhs)
      , m_y       (rhs.m_y)
    {}

    DerivedResult(DerivedResult && rhs)
        :
        BaseResult(std::move(rhs))
      , m_y(rhs.m_y)
    {}

    DerivedResult(BaseResult && rhs)
        :
        BaseResult(std::move(rhs))
        , m_y()
    {
    }

    ~DerivedResult() {}
};

class BaseCalc
{
public:

    virtual ~BaseCalc() {}

    virtual std::unique_ptr<BaseResult> …

总的来说，我对 VS Code 和 CMake 很陌生。我使用 Visual Studio 和解决方案文件已经有 14 年了。现在业界希望我能够跨平台并在 Linux 中做事。好吧，我不想成为一个被弃用的老人。

我下载了 VSCode 并安装了 cmake 和 cmake 工具扩展。我创建了一个文件夹，打开工作区，ctrl+shift+p 并选择配置，然后选择 VC++ 作为我的编译器。

当我在 VS Code 内部或外部的命令行上键入 cmake 时，它​​不是可识别的命令。但是，我可以使用 ctrl+shift+p cmake->Build 进行构建。

如何在命令行上获取 cmake 并像视频中的“vector-of-bool”一样使用它？ https://www.youtube.com/watch?v=abuCXC3t6eQ

它当前使用的 cmake 可执行文件在哪里，我应该将其添加到路径中吗？

我使用的是 Windows 10，并且在尝试 VSCode + cmake 工具之前安装了 Visual Studio 2019。

我还没有看到很多关于如何在C ++ 11中创建自定义分配器的好的示例或教程。我确实看到，自C ++ 03起，它已经发生了变化。但是，那时我也不知道该怎么做。

通过尽可能多的信息，我得出了以下结论：

// Project Includes
#include "IMemoryManager.h"

// Standard Includes
#include <cstddef>
#include <iostream>
#include <memory>

//------------------------------------------------------------------------------
/// <summary>
/// A STL compliant custom allocator
///
/// Based on Dr Dobbs article
/// http://www.drdobbs.com/the-standard-librarian-what-are-allocato/184403759
/// I attempted to make it C++11 compliant.
/// Takes an Interface to a Memory Manager which will implement the custom memory management solution.
/// </summary>
template <class T>
class CustomAllocator
{
    std::unique_ptr<IMemoryManager> m_memoryManager;

public:

    typedef T value_type;

    /// Allocator takes ownership …

我几次尝试使用boost :: asio创建自己的简单异步TCP服务器几年后没有触及它.

我能找到的最新示例列表是:http: //www.boost.org/doc/libs/1_54_0/doc/html/boost_asio/tutorial/tutdaytime3/src.html

我在这个示例列表中遇到的问题是(我觉得)它欺骗并且通过使tcp_connection成为shared_ptr来欺骗它,这样它就不用担心每个连接的生命周期管理了.(我认为)他们这样做是为了简洁,因为它是一个小教程,但这个解决方案不是现实世界.

如果您想在计时器或类似的东西上向每个客户端发送消息怎么办？在任何真实世界的非平凡服务器中都需要一组客户端连接.

我担心每个连接的生命周期管理.我认为自然要做的就是在tcp_server中保留一些tcp_connection对象或指向它们的指针.从OnConnect回调添加到该集合并从该集合中删除OnDisconnect.

请注意,OnDisconnect很可能是从实际的Disconnect方法调用的,在发生错误的情况下,该方法将从OnReceive回调或OnSend回调调用.

嗯,这就是问题所在.

考虑一下我们有一个看起来像这样的callstack:

tcp_connection::~tcp_connection
tcp_server::OnDisconnect
tcp_connection::OnDisconnect
tcp_connection::Disconnect
tcp_connection::OnReceive

这会在调用堆栈展开时导致错误,并且我们正在一个已经调用了析构函数的对象中执行代码......我想,对吧？

我想每个做服务器编程的人都会以某种方式遇到这种情况.处理它的策略是什么？

我希望这个解释足够好.如果不让我知道,我将创建自己的源列表,但它将非常大.

编辑:相关

)异步C++代码中的内存管理

IMO不是一个可以接受的答案,依赖于在接收电话上使用shared_ptr作弊,仅此而已,并不是现实世界.如果服务器想要每5分钟对所有客户说"嗨"怎么办？某种集合是必要的.如果你在多个线程上调用io_service.run怎么办？

我也在提升邮件列表:http: //boost.2283326.n4.nabble.com/How-to-design-proper-release-of-a-boost-asio-socket-or-wrapper-thereof- td4693442.html

我正在制作一个客户端套接字。

为了让我的测试人员更轻松，我想指定套接字将使用的网卡和端口。

昨天，在我的谷歌搜索中，我发现：Binding boost asio to local tcp endpoint

通过执行 open、bind 和 async_connect，我能够绑定到特定的网卡，并且我开始在 Wireshark 中看到流量。

但是，Wireshark 报告套接字已被赋予一个随机端口，而不是我指定的端口。我想如果端口正在使用它会填写传递给绑定方法的 error_code 。

我究竟做错了什么？

这是我的最小示例，从我的真实解决方案中提取和编辑。

// Boost Includes
#include <boost/asio.hpp>
#include <boost/atomic.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/thread/condition_variable.hpp>

// Standard Includes
#include <exception>
#include <memory>
#include <string>
#include <sstream>


boost::asio::io_service        g_ioService;                     /** ASIO sockets require an io_service to run on*/
boost::thread                  g_thread;                        /** thread that will run the io_service and hence where callbacks are called*/
boost::asio::ip::tcp::socket   g_socket(g_ioService);           /** Aync socket*/
boost::asio::ip::tcp::resolver g_resolver(g_ioService);         /** …

我很长一段时间忽略了这个工具，因为它只是.NET。

根据 MSDN 的说法，该诊断工具适用于在 Visual Studio 2015 中以“调试”方式编译的本机代码。

我正在关注： https ://learn.microsoft.com/en-us/visualstudio/profiling/memory-usage

我在“诊断工具”窗口的“内存使用情况”选项卡下启用了“堆分析”。然后，我重建所有项目，确保每个项目的工具集都是“Visual Studio 2015”，并确保为每个 dll 或 exe 项目构建 PDB。当客户端连接到我的进程时，以及在向客户端发送数据之后，我在 main 处设置了一个断点。其间有数千个对 new 的调用。每次我点击“拍摄快照”。当我单击“拍摄快照”时，会出现一行，其中包含时间、分配和堆大小。后两者被归零。

如果我对我的一个单元测试执行相同的操作，它们就会被填写，我可以按照文档中的描述进行深入研究。

我应该寻找什么才能让它与我的主要项目一起工作？是否有某些链接设置？我构建静态库和动态库重要吗？有什么具体需要寻找的吗？

当您从字节数组构造 MemoryStream 时，该流是否会制作自己的副本？如果与直接从原始数组中读取字节相比，这是否是高性能场景中的性能问题？