小编sel*_*bie的帖子

使用以下代码段：

 f = open("/mnt/remoteserver/bar/foo.bin", O_RDONNLY);
 while (true)
 {
       byteseread = read(f, buffer, 1000);
       if (bytesread > 0)
           ProcessBytes(buffer, bytesread);
       else
           break;
  }

如果以上面的示例为例，假设远程文件foo.bin为1MB，并且以前从未被客户端访问过。因此，大约需要进行1000次“读取”调用才能获取整个文件。

此外，假设在客户端上安装了目录的服务器是通过Internet而不是本地的。到客户端的快速带宽，但延迟较长。

是否每个“读取”调用都调用往返服务器的往返请求更多数据？还是客户机/服务器协议识别出远程文件上的后续读取通常是顺序读取的，因此，在应用程序实际对其进行read（）调用之前，将后续块下推。因此，由于预取并缓存了数据，因此后续的读取调用返回得更快。

现代网络文件系统协议（NFS，SMB / Samba或其他协议）是否进行了类似的优化。是否有针对互联网优化的网络文件系统协议具有这样的优化？

我正在调查一个个人项目，该项目可能涉及通过Internet实施网络文件系统。令我震惊的是，如果可以减少文件I / O的往返次数，性能可能会更快。

是否有一个通用的C/C++库(或常用技术)用于获取输入文本的行并将单词拆分为单独的行.每行输出具有最大宽度,而单词不跨行分割.崩溃或保留的空白是可以的.必须保留标点符号.小而紧凑的图书馆是首选.

我可以轻松地度过一个下午把一些东西放在一起起作用,但是想知道是否有一些共同点,所以我不会重新发明轮子.如果输入行可以包含格式说明符以指示输出行的缩进级别,则加分.

示例输入:"Shankle鼓腌牛肉,夹头火鸡鸡肉猪肉牛排牛排牛排香肠.尾部短腰肩球尖,下颚鼓臀.尾舌球尖肉饼,bresaola短腰三尖端肥猪腰里脊牛腿biltong.鹿肉短腰里ou.

示例输出(目标宽度= 60)

123456789012345678901234567890123456789012345678901234567890   Line added to show where 60 is
Shankle drumstick corned beef, chuck turkey chicken pork
chop venison beef strip steak cow sausage. Tail short loin
shoulder ball tip, jowl drumstick rump. Tail tongue ball tip
meatloaf, bresaola short loin tri-tip fatback pork loin
sirloin shank flank biltong. Venison short loin andouille.

我了解NAT打孔,ICE和SIP VOIP调用的许多细节.关于这些主题,我已经回答了很多关于SO的问题.现在我有一个问题.

我试图理解在呼叫已经建立之后需要为SIP + ICE记录的RE-INVITE消息.

假设VOIP设备的拓扑结构通过SIP发信号并使用ICE(使用STUN/TURN)建立媒体连接.执行ICE连接检查后,两个端点都应确定最佳地址候选配对(IP,端口),并准备好在两个方向上流媒体.

但是我使用SIP和大量文档的经验表明,在被叫方发送200 OK消息以表明他处于应答状态后,调用者将发送一个带有SDP的RE-INVITE,其中包含通过连接性检查选择的特定地址候选者.

描述RE-INVITE与ICE的一些链接在这里和这里(步骤8).Rosenberg的教程(第30页)讨论了RE-INVITE"确保中间盒具有正确的媒体地址".我不确定为什么这很重要.

在收到RE-INVITE时,被叫方是否期望根据收到的新SDP重新配置其ICE堆栈以切换套接字或地址？或者RE-INVITE只是一种协议形式,正式承认呼叫已经建立？如果跳过RE-INVITE步骤并且双方都开始流媒体,那么可能出现什么问题？

我问的原因是因为我正在探索使用ICE而不是SIP的信令服务.我想弄清楚RE-INVITE是否需要模拟.

调用getsockoptwithSO_RCVBUF将返回套接字接收缓冲区的分配大小。

我很好奇，想知道是否有可能查询多少数据报数据包（或字节）实际上是在调用缓存之前，recv还是recvfrom？如果有帮助，我可以满足于 Linux 特定的答案。有问题的套接字是 UDP，但我怀疑它对 TCP 无关紧要。

我问的原因只是为了测试和调试目的。我正在尝试验证我对 setocktop(SO_RCVBUF) 的调用是否设置了足够的大小。知道接收缓冲区是否接近达到其限制将验证是否设置了足够的大小。

我们来看一个表示子节点树的数据结构(Node)的示例.每个对象的子节点集存储在map>中

class Node;
typedef std::shared_ptr<Node> NodePtr;

class Node
{
    std::map<const std::string, NodePtr> _childNodes;
    void SomeOtherMethod();

public:
    bool GetChildByKeyName(/*In*/ const std::string& key, /*Out*/ NodePtr& spChild)
    {
        bool result = false;
        auto itor = _childNodes.find(key);
        if (itor != _childNodes.end())
        {
            spChild = itor->second;
            result = true;
            SomeOtherMethod();
        }
        return result;
    }
};

以下代码示例作为用户通常会调用它.

NodePtr spNode, spChildNode;
bool result;
...
result = spNode->GetChildByKeyName(strChildKeyName, spChildNode);

到现在为止还挺好.

在我看来,调用者可能会遍历树而不必为树中的每个深度处理额外的变量

NodePtr spNode;
bool result;

result = spNode->GetChildItem(strChildKeyName, spNode);
if (result)
   spNode->GetChildItem(strSubKeyName, spNode);

在上面的例子中,如果spNode是对象的最后剩余引用,那么我担心GetChildItem方法中的这段代码:

            spChild = …

我知道"实现接口"的意思是:一个类实现一个接口.现在我在Android Studio中遇到了一个谜题(在IntelliJ IDEA中,有类似的疑问.):请注意以下图片:当Child实现接口,并覆盖方法fun2时,左侧会有一个特定的图标.但是父不执行界面,为什么会出现相同的图标？

这里有更大的图片

我需要的是,我将打开一个UDP监听X端口(本地机器)的服务器,并且 machine(public IP)可以向UDP我发送数据包.我的机器没有public IP.基本上我需要stun.

我正在测试stuntman服务器/客户端项目.我在服务器(公共IP)中运行stuntman-server.在我的系统中运行客户端(本地IP).我要求为端口映射ip/9999port.

./stunclient --mode full --protocol udp --localport 9999 stun.server.ip

Stun服务器返回IP和端口.我做了什么,然后,打开一个UDP在我的本地系统服务器(使用Java),并开始在监听9999端口和发送UDP的消息other machine (which has public IP),以mapped IP/port通过STUN服务器返回.但我无法收到任何数据.您可以假设我的服务器/客户端代码(用java编写)在本地网络中正常工作.

流:

My machine ->>>>>stun request for 9999 port and my ip ------> stun server
My machine <<<<<<<<<<<<<<<<<<mapped ip/port <<<<<<<<<<<<<<<  stun server
My machine : Run JAVA udp server socket in 9999 port

My machine  <<<<<<<<<<<<<<<<<<<UDP …

Qt / QML问题。使用Qt 5.7。

使用以下简单的QML程序，该程序显示垂直对齐的红色矩形和蓝色矩形。两个矩形的单击处理程序都会尝试更改父宿主窗口的颜色。但是有细微的差别。红色矩形直接通过其ID（rootWindow）引用宿主窗口。蓝色单击处理程序通过父引用更改颜色。

前一种情况很好。后一种情况不起作用。似乎根窗口已被特别对待，并且不直接属于父/子层次结构，即使矩形在逻辑上以这种方式嵌套在代码中也是如此。

有人可以解释这个规则吗？

import QtQuick 2.7
import QtQuick.Window 2.2

Window {
    visible: true
    width: 640
    height: 480
    title: qsTr("Hello World")
    id: rootWindow
    color: "#ffffee"

    Rectangle {
        id: rect1; width: 50; height: 50; color:"red"

        MouseArea {
            anchors.fill: parent;
            onClicked: {
                print("rect1 clicked");
                rootWindow.color = "green";  // works fine
            }
        }
    }

    Rectangle {
        id: rect2; width: 50; height: 50; color:"blue"
        anchors.top: rect1.bottom

        MouseArea {
            anchors.fill: parent;
            onClicked: {
                print("rect2 clicked");
                rect2.parent.color = "pink"; …

我有一个命名空间，下面的 func1 和 func2 将从不同的线程调用。

#include<thread>
namespace test{

    std::mutex mu;

    void func1(){
        std::lock_guard<mutex>lock(mu);
       //the whole function needs to be protected
    }

    void func2() {
        mu.lock();
        //some code that should not be executed when func1 is executed
        mu.unlock();
        //some other code
    }
}

使用此互斥锁（一次与 lock_guard 一起使用并在其外部）来保护这些关键部分是否安全？如果不是如何实现这个逻辑？

由于今天是美国的感恩节，所以我将被指定为土耳其来问这个问题：

Take something as innocuous as this. An atomic with a simple plain old data type such as an int:

atomic<int> x;
cout << x;

The above will print out garbage (undefined) data. Which makes sense given what I read for the atomic constuctor:

(1) default constructor

Leaves the atomic object in an uninitialized state. An uninitialized atomic object may later be initialized by calling atomic_init.

Feels like an odd committee decision. But I'm sure they had their reasons. …