小编kre*_*ieg的帖子

出于好奇.在过去,我已经看到了功能性能下降喜欢boost::to_lower的,因为CriticalSection在使用std::use_facet时,小懒分配.据我记得,有一个全局锁定区域设置的错误,但根据Stephan Lavavej,它已在VS2013中修复.瞧,昨天我看到了锁定服务器性能的方面,所以我想我混淆了两个不同的问题.
但首先,为什么有一个CriticalSection懒惰的方面呢？显然它会破坏性能.为什么他们没有决定对指针进行某种可升级的锁定或原子操作？

我正在使用 ZMQ (cppzmq) 的 C++ 绑定，并且尝试使用.setsockopt()如下方法设置 TCP 套接字的连接超时：

int connectTimeout = 1000;
socket.setsockopt(ZMQ_CONNECT_TIMEOUT, &connectTimeout, sizeof(connectTimeout));
socket.connect(clientConfiguration.uri);

但是，在代码到达.send()/.recv()套接字上的实际位置之前，我没有看到任何事情发生（抛出异常？）。为了确保套接字有机会抛出，我在.connect()和.send()方法之间放置了一个睡眠。

根据文档，.zmq_connect()只是进入READY- 状态，而不与端点建立实际连接。那么问题是我应该何时以及如何经历连接超时？

如何称呼new带有对齐方式的运算符？

auto foo = new(std::align_val_t(32)) Foo; //?

然后，如何正确删除它？

delete(std::align_val_t(32), foo); //?

如果这是使用这些重载的正确形式，那么为什么要抱怨抱怨free（）/ delete / delete []不匹配？

寻找Win32 InterlockedExchangePointer的便携,简单和优雅的替代品.理想情况下只使用C++ 11,但也会使用boost.

什么不符合将 lambda 传递给apply方法的条件std::valarray？考虑以下代码：

int main()
{
    std::valarray<int> arr = {1, 2, 3, 4, 5, 6};
    auto arr1 = arr.apply([](int val) { return val * 2; }); // compiles
    int n = 3;
    auto arr2 = arr.apply([n](int val) { return val * n; }); //does not compile
    return 0;
}

住在coliru http://coliru.stacked-crooked.com/a/f0407046699574fc

在https://gcc.godbolt.org/ 上测试
GCC、MSVC 或 CLang 都不会编译上述代码

我的目标与几个使用TARGET_LINK_LIBRARIESwithPUBLIC关键字的库链接，INSTALL命令看起来像INSTALL(TARGETS foo DESTINATION ${CMAKE_INSTALL_PREFIX}/bin). 我想以某种方式强制 cmake 包含我链接的所有（最好不包括系统库）库（仅限 SO）以包含在安装过程中。我试过 EXPORT 关键字，但看起来它只影响我在项目中构建的库，并标记为与库相同EXPORT的foo库。
是否可以？
EDIT001：可能影响答案的附加信息。我正在使用vcpkg来管理第三方。所以TARGET_LINK_LIBRARIES看起来像

TARGET_LINK_LIBRARIES(foo PUBLIC
                      GTest::GTest
                      GTest::Main
                      ${GOOGLE_MOCK}
                      event
                      ${THRIFT_LIBRARIES}
                      ${Boost_LIBRARIES}
                      lzo2
                      sqlite3
                      ${ZeroMQ_LIBRARY}
                      gRPC::grpc
                      gRPC::grpc++
                      xml2
                      stdc++fs
                      bfd
                      -l:libisal.so.2
                      sgutils2
                      pthread
                      uuid
                      rt
                      )

所以，本质上我想要实现的是获取所有这些被宏化的库vcpkg，像${THRIFT_LIBRARIES}, ${Boost_LIBRARIES} and gRPC::grpc等等

在比较boost :: lexical_cast和boost spirit解析时,我注意到了一些奇怪的东西.我正在尝试将字符串解析为float.由于某种原因,精神给出了非常不精确的结果.例如:当使用lexical_cast解析字符串"219721.03839999999"时,我得到219721.03,这或多或少都可以.但是当我使用精神(见下面的代码)时,我得到了"219721.11",这远远不是好的.知道为什么会这样吗？

template<>
inline float LexicalCastWithTag(const std::string& arg)
{
    float result = 0;

    if(arg.empty())
    {
        throw BadLexicalCast("Cannot convert from to std::string to float");
    }

    auto itBeg = arg.begin();
    auto itEnd = arg.end();

    if(!boost::spirit::qi::parse(itBeg, itEnd, boost::spirit::qi::float_, result) || itBeg != itEnd)
    {
        throw BadLexicalCast("Cannot convert from to std::string to float");
    }

    return result;
}

I'm observing odd behavior of std::unordered_map in MSVC14 (VS2015). Consider following scenario. I create an unordered map and fill it with dummy struct which consumes considerable amount of memory, lets say 1Gb, overall 100k elements inserted. Then you start to delete elements from the map. Lets say you have deleted half of elements, then, you expect half of memory being freed. Right? Wrong! I see that memory is released when number of elements in map pass some threshold, in my …

我有一个模板函数,它将字符串转换为数字如下:

template <typename RetType,
    typename Parser =
    typename boost::spirit::traits::create_parser<RetType>::type>
    inline std::enable_if_t<std::is_arithmetic<RetType>::value, RetType>
    cast(const std::string &input)
{
    RetType result;

    if(input.empty())
    {
        // handle this
    }
    auto itBeg = input.cbegin();
    auto itEnd = input.cend();
    if(!bsq::parse(itBeg, itEnd, Parser(), result) || itBeg != itEnd)
    {
        // handle that
    }
    return result;
}

现在我想创建一个类似于上面的函数,它将解析表示某个基数中的数字的字符串

template <typename RetType, unsigned Radix,
    typename Parser =
    typename boost::spirit::traits::create_parser<RetType>::type>
    inline std::enable_if_t<std::is_arithmetic<RetType>::value, RetType>
    cast(const std::string &input)
{
    RetType result;

    if(input.empty())
    {
        // handle this
    }
    auto itBeg = input.cbegin();
    auto itEnd …

最近我一直在寻找一种方法来替换字符串中的标记本质上是查找和替换(但至少还有一种方法可以解决这个问题)并且看起来非常平庸.我有几个可能的实现,但从性能的角度来看,它们都没有令人满意.最佳成就是每次迭代约50us.案例是理想的,字符串的大小从未增长,最初我省略了不区分大小写的要求
以下是我机器上的Coliru

结果的代码:
Boost.Spirit符号结果:3421？= 3421
100000个周期需要6060ms.
Boyer-Moore结果:3421？= 3421
100000个周期为5959ms.
Boyer Moore Hospool结果:3421？= 3421
100000个循环耗时5008ms.
Knuth Morris Pratt结果:3421？= 3421
100000个循环耗时12451ms.
天真的STL搜索和替换结果:3421？= 3421
100000个循环需要5532ms.
提升replace_all结果:3421？= 3421
100000个周期需要4860ms.

那么问题是,在如此简单的任务中需要这么长时间？可以说,好的,简单的任务,继续并更好地实施它.但现实是,15年前MFC天真的实施使任务的数量级更快:

CString FillTokenParams(const CString& input, const std::unordered_map<std::string, std::string>& tokens)
{
    CString tmpInput = input;
    for(const auto& token : tokens)
    {
        int pos = 0;
        while(pos != -1)
        {
            pos = tmpInput.Find(token.first.c_str(), pos);
            if(pos != -1)
            {
                int tokenLength = token.first.size();
                tmpInput.Delete(pos, tokenLength);
                tmpInput.Insert(pos, token.second.c_str());
                pos += 1;
            }
        }
    }

    return tmpInput;
}

结果: …