小编gct*_*gct的帖子

我知道你可以使用boost序列化来序列化为文本格式,然后推送套接字,但我想将一类统计数据序列化为二进制格式(包括大小和编码/解码开销).为此使用boost序列化是否安全？

我特别担心的是:

1. 不同平台上的整数类型大小之间的差异(主要是32位与64位).
   虽然我可以通过使用来自stdint的精确大小的整数来解决这个问题,但我仍然希望了解这种行为.
2. 系统之间的字节序差异确实会提升序列化为标准字节序(例如:网络排序),然后使用主机的字节顺序进行反序列化？

这是一个非常好的库,但遗憾的是它的二进制功能的文档有些限制,所以我只想确保以这种方式使用它是安全的.

我正在玩弄使用虚拟内存系统的想法,允许我对我得到的一些数字数据进行透明数据转换(例如int to float).基本思想是我正在编写的库mmaps您想要的数据文件,同时mmaps一个适当大小的匿名区域来保存转换后的数据,并将此指针返回给用户.

匿名区域的读/写保护,所以,每当用户经历的指针来访问数据,每一个新的页面会造成段错误,我能赶上,然后透明地在mmaped文件转换数据,同时设置权限允许访问继续.到目前为止,整个事情的这一部分很有效.

但是,有时我会绘制非常大的文件(数百GB),并且匿名内存代理访问它,很快你就会开始吃掉交换空间,因为匿名页面会被丢弃到磁盘上.我的想法是,如果我可以在将转换后的数据写入它们之后将匿名页面上的脏位显式设置为false,那么操作系统只会删除它们,并在以后重新访问时按需填充零.

对于这个工作,虽然,我想我必须设置脏位为假,并说服OS设置页面进行阅读时,他们交换出去的保护,这样我就可以重新赶上随后的段错误,并重新转换数据一经请求.在做了一些研究后,我认为没有内核黑客攻击是不可能的,但我想我会问,看看有更多关于虚拟内存系统的人是否知道可以实现的方法.

我很好奇是否有任何方法可以在C++中执行此操作.假设我有一个模板化的矢量类:

template <typename T>
class vector {          
public:
      vector(T a, T b, T c) : x(a), y(b), z(c) {}

      T x,y,z;
};

然后我有一个模板化的加法运算符:

template <typename A, typename B> 
vector<A> operator +(const vector<A> &a, const vector<B> &b) { 
   return vector<A>(a.x+b.x, a.y+b.y, a.z+b.z); 
}

我很好奇是否可以修改那个操作符,所以结果是两种类型A和B中哪一个更精确,除了手动专门化它.

例如:

vector<float>       + vector<double> would produce a vector<double>, 
vector<long double> + vector<float>  would produce a vector<long double>

我的猜测是在C++中没有自动支持,但我想我会问.

我对64位平台上uint32_t类型的对齐感到好奇.规范说uint32_t应该是给定的位宽,实际上它似乎是:

> printf("sizeof(uint32_t): %zd\n", sizeof(uint32_t));   
sizeof(uint32_t): 4

但后来我有一个结构:

typedef struct A {
    uint32_t a;
    uint32_t b;
} A;

但是,令人惊讶的是:

> printf("sizeof(A): %zd\n", sizeof(A));
sizeof(A): 16

由于某种原因,uint32_t是否为8字节对齐？下面真的是一个8字节的类型吗？

我有一些recv()定期调用的代码(带有MSG_DONTWAIT标志).我很好奇,因为在vtune中分析我的代码,我看到一个sigprocmask()与之关联的调用recv(),并且它占用了总时间的很大一部分来执行.我很好奇为什么recv()要打电话sigprocmask().

我的理解是,在Rust中的任务之间共享可变状态是不可能的,那么为什么Rust 在语言中有像互斥体这样的东西呢？他们的目的是什么？

在C/C++中是否有一种合理的可移植方式可以将128位结果乘以两个64位整数并获得结果的前 64位而不是底部的64位？我需要这个来在任意大小的表上分配哈希函数.

鉴于:

void function(int*=0) {}
int main() {
}

铿锵(3.8.0):

test.cc:1:18: error: expected ')'
void function(int*=0) {
                 ^

g ++(5.4.0):

test.cc:1:18: error: expected ‘,’ or ‘...’ before ‘*=’ token
 void function(int*=0) {
                  ^    

如果我将其更改为(注意间距):

void function(int* = 0) {}
int main() {
}

显然,我输入T*= 0或T*= 0时会感到困惑,这是一个错误还是预期？

在编写转换运算符时,如果我同时提供转换const T&和T&&,C++是否总是更喜欢rvalue运算符？在这个小测试中,这似乎是正确的:

#include <algorithm>
#include <stdio.h>

struct holds {
  operator       int&&()      { printf("moving!\n");  return std::move(i); }
  operator const int&() const { printf("copying!\n"); return i;            }

private:
  int i = 0;
};


int main() {
  holds h;
  int val = h;
}

打印:

 ??? ./test
moving!

但也许有人能说出比我能验证的更好的规格吗？

我正在开发一个图形前端，它渲染服务器端并通过将压缩图像发送到客户端（想想VNC）将屏幕更新推送到浏览器。我认为编码 PNG 的开销太高，因此目前我通过 Websocket（启用压缩）发送 8 位 RGB 像素值的原始 blob。这实际上非常快，而且我看到了巨大的压缩增益（例如 75K -> 2.7k）。

然而，在客户端，我必须获取原始像素，然后将它们绘制到画布上。这是我目前最好的代码性能：

// receive message from server
self.ws.onmessage = function (evt) {
    // get image offset
    var dv = new DataView(evt.data);
    var dx = dv.getInt16(0);
    var dy = dv.getInt16(2);
    var ww = dv.getInt16(4);
    var hh = dv.getInt16(6);
    var offset = 8;

    // get context to canvas and create image
    var ctx = self.canvas.getContext("2d");
    var img = ctx.createImageData(ww, hh);

    // unpack image data
    var start = performance.now();
    var dst = …