小编ine*_*ght的帖子

我们正在大量使用boost :: serialization和模板.一切似乎进展顺利.

除此之外,我们在Windows版本上遇到了麻烦.它似乎导致目标文件中的问题太大.我们使用MinGW/Msys和g ++ 4.7.0.

c:/mingw/bin/../lib/gcc/mingw32/4.7.0/../../../../mingw32/bin/as.exe: CMakeFiles/source.dir/sourcecode.cpp.obj: too many sections (33396)
C:\Users\username\AppData\Local\Temp\ccnAocvD.s: Assembler messages:
C:\Users\username\AppData\Local\Temp\ccnAocvD.s: Fatal error: can't write CMakeFiles/source.dir/sourcecode.cpp.obj: File too big

谷歌大师透露了这个存档的消息,http://sourceforge.net/mailarchive/forum.php？ thread_name = CA%2Bsc5mkLvj%3DW9w2%3DsY%3Dc_N%3DEwnsQuPDEX%3DiBcbsbxS3CuE_5Bg%40mail.gmail.com&forum_name=mingw- users

在其中,它表明另一个人几乎同样陷入困境.它确实指向了Visual Studio /bigobj选项的一个选项,它似乎可以满足我们的需求.但是,我们无法转移到Visual Studio.

一个建议是在汇编程序选项中添加--hash-size.这没有用.

如果我没有弄错,问题在于目标文件的限制为2 ^ 16个条目.实际上,根据错误信息,我冒昧地说它是签名的2 ^ 16条目,但那是花生./bigobjVisual Studio 的选项会将其更改为2 ^ 32.邮件列表结果不知道gcc的等效选项.进一步的谷歌搜索结果似乎与此无关.

在这一点上,我们将不得不重构我们的代码(呃)以克服这个限制.但是我仍然担心,经过大量模板化,我们可能会一次又一次地遇到这个问题(我们已经遇到了三个源文件).

所以我的问题是这样的; 有没有相当于微软/bigobj选项的gcc ？我还没有找到第三种选择吗？

我的问题是安全问题.我搜索了cplusplus.com和cppreference.com,他们似乎缺乏std :: move期间的迭代器安全性.具体来说:使用已移动对象的迭代器调用std :: unordered_map :: erase(iterator)是否安全？示例代码:

#include <unordered_map>
#include <string>
#include <vector>
#include <iostream>
#include <memory>

class A {
public:
    A() : name("default ctored"), value(-1) {}
    A(const std::string& name, int value) : name(name), value(value) { }
    std::string name;
    int value;
};
typedef std::shared_ptr<const A> ConstAPtr;

int main(int argc, char **argv) {
    // containers keyed by shared_ptr are keyed by the raw pointer address
    std::unordered_map<ConstAPtr, int> valued_objects;

    for ( int i = 0; i < 10; ++i ) {
        // …

#include <iostream>                                                             

void do_something(void) {                                                       
        std::cout << "blah blah" << std::endl;                                  

        auto lambda_func = [](void){                                            
                std::cout << "in lambda" << std::endl;                          
                return;                                                         
        };                                                                      

        lambda_func();                                                          

        std::cout << "..." << std::endl;                                        

        return;                                                                 
}                                                                               

int main(int argc, char **argv) {                                               
        do_something();                                                         
        return 0;                                                               
}

在这个示例程序中,如果你编译(g++ gdb-call-lambda.cpp --std=c++11 -g)然后在gdb(gdb ./a.out)中运行它,你可以让GDB调用任何"普通"函数.例:

(gdb) break main
Breakpoint 1 at 0x4008e7: file gdb-call-lambda.cpp, line 20.
(gdb) r
Starting program: /home/keithb/dev/mytest/gdb-call-lambda/a.out 

Breakpoint 1, main (argc=1, argv=0x7fffffffdfb8) at gdb-call-lambda.cpp:20
20      do_something();
(gdb) call do_something()
blah blah …

我有一个函数,它试图将给定的字符串与给定的正则表达式模式匹配.如果它不匹配,它应该创建一个指示这种情况的字符串,并包括它失败的正则表达式模式和字符串的内容.类似的东西:

bool validate_content(const std::string & str, const std::regex & pattern, std::vector<std::string> & errors)
{
    if ( false == std::regex_match(str, pattern) )
    {
        std::stringstream error_str;
        // error_str << "Pattern match failure: " << pattern << ", content: " << str;
        errors.push_back(error_str.str());
        return false;
    }
    return true;
}

但是正如您所看到的,注释掉的行提出了一个挑战:是否可以恢复正则表达式对象的原始模式？

显然有一种解决方法是提供原始模式字符串(而不是或旁边)正则表达式对象然后使用它.但是我当然希望不需要包含额外的工作来在每次调用此函数时重新创建正则表达式对象(每次调用函数时重新定位模式的成本)或者将正则表达式模式与正则表达式对象(容易出现拼写错误和错误,除非我提供一个包装器为我做这个,这不方便).

我在Ubuntu 14.04上使用GCC 4.9.2.

#include <iostream>
#include <array>

int main(int argc, char **argv) {
    constexpr const std::array<int, 2> arr {{ 0, 1 }};
    constexpr const int arr2[] = { 0, 1};

    static_assert(arr[0] == arr2[0], "asdf");
    static_assert(arr[1] == arr2[1], "asdfasdf");

    return 0;
}

当编译gcc 4.8.2和4.9.1使用g++ test.cpp --std=c++11,编译成功.当编译clang 3.4和3.5利用clang++ test.cpp --std=c++11然而,编译失败:

test.cpp:8:16: error: static_assert expression is not an integral constant expression
        static_assert(arr[0] == arr2[0], "asdf");
                      ^~~~~~~~~~~~~~~~~
test.cpp:8:16: note: non-constexpr function 'operator[]' cannot be used …

我遇到了一个我不确定如何解决的问题.我相信这是GCC和/或libstdc ++中的一个问题.

我正在使用GCC 4.8.2-19ubuntu1,libstdc ++ 3.4.19运行Ubuntu 14.04 LTS(我相信？你如何找到你的linux机器上安装了什么版本的libstdc ++库？),并提升1.55.

这是代码:

// http://www.boost.org/doc/libs/1_54_0/libs/log/doc/html/log/tutorial.html
// with a slight modification to ensure we're testing with threads too
// g++ -g -O0 --std=c++11 staticlinktest.cpp -lboost_log_setup -lboost_log -lboost_system -lboost_filesystem -lboost_thread -lpthread

#define BOOST_ALL_DYN_LINK 1

#include <boost/log/trivial.hpp>

#include <thread>
#include <atomic>
#include <vector>

int main(int, char*[])
{
    BOOST_LOG_TRIVIAL(trace) << "A trace severity message";
    BOOST_LOG_TRIVIAL(debug) << "A debug severity message";
    BOOST_LOG_TRIVIAL(info) << "An informational severity message";
    BOOST_LOG_TRIVIAL(warning) << "A warning severity message";
    BOOST_LOG_TRIVIAL(error) << "An …

我正在尝试打开一个文件输出并附加到它.在附加到它之后,我想将输出位置移动到文件中的其他位置并覆盖现有数据.据我了解,std::ios_base::app将强制所有写入都在文件的末尾,这不是我想要做的.因此,我认为std::ios_base::ate是传递给它的正确旗帜std::ofstream::open().但是,似乎没有按预期工作:

// g++ test.cpp
// clang++ test.cpp
// with and without -std=c++11
#include <iostream>
#include <fstream>

int main() {
    std::streampos fin, at;
    {
        std::ofstream initial;
        initial.open("test", std::ios_base::out | std::ios_base::binary);
        if ( not initial.good() ) {
            std::cerr << "initial bad open" << std::endl;
            return 1;
        }
        int b = 100;
        initial.write((char*)&b, sizeof(b));
        initial.flush();
        if ( not initial.good() ) {
            std::cerr << "initial write bad" << std::endl;
            return 1;
        } …

我一直在使用gpg加密.有人建议我应该使用gpg2.当我去使用时gpg2,我什么也做不了; 它会抱怨需要访问私钥,但我似乎无法在没有gpg-agent运行的情况下使用私钥.

事实证明我故意禁用gpg-agent(通过使用chmod -x /usr/bin/gpg-agent); 这导致gpg2功能非常有限,并向stderr抱怨.

我禁用的原因gpg-agent是一系列事件.

首先,我将SSH连接到远程计算机,"代理"将打开一个弹出窗口,要求我解锁我的SSH密钥.我不喜欢这个,因为:

• 屏幕上的弹出窗口会中断我的工作流程
• 我的屏幕上的弹出窗口不太可能被注意到,因此它会显示连接停止而不是查询以解锁加密密钥
• 当我绝对不​​希望我的密码被缓存时,代理似乎缓存了我的密码(很像sudo使用密码缓存,我可以在其配置中禁用它); 每次将它们用于任何正在使用它们的程序时,我总是希望为我的加密密钥输入密码.
• 弹出窗口似乎由一个单独的进程拥有,而我希望使用密钥的特定进程查询密码短语(即使它是一个执行实际查询的库); 因为我使用命令行工具来完成大部分活动,这意味着GUI应用程序并不理想,因为我所做的一切都不能访问X11
• 在后台自动启动一个单独的进程会删除"一个命令,一个进程"的概念,特别是如果该后台进程在原始命令退出后仍然存在

它原来是GNOME的核心机构,我不能卸载不卸载GNOME代理.所以我只是禁用它chmod -x /usr/bin/gnome-keyring*.然后我发现SSH会回退到另一个代理,所以我也使用相同的方法禁用了它chmod -x /usr/bin/ssh-agent*

当我开始使用时gpg,我发现它有一个类似的代理,就像我要问的那个.我出于同样的原因立即禁用了它; 我希望软件总是问我密码才能使用私钥.我不希望以任何理由缓存密码.

所以gpg2看似要求 gpg-agent,我想问:

• 我是否过于偏执使用密码缓存？我很想看到或指出对它的讨论.
• 是否有一种最佳实践可以更好地避免意外启用缓存密码短语？
• 有没有办法在gpg2没有gpg-agent运行的情况下使用？
• 鉴于代理是预期能够回答查询的守护进程,是什么阻止在本地计算机上运行的另一个用户或服务能够访问我的缓存或存储的凭据？

我正在一个大型项目中清理 ThreadSanitizer 警告。特别是在这种情况下，有一个生成的线程从文件、生产者中读取。然后有一个或多个解压线程作为线程池的一部分。最后，有一个线程实际上通过检索解压缩的块来进行处理。这当然允许同时解压缩多个块。

该项目在许多位置通过原子 bool 和 进行同步usleep()，特别包括这一处。当然，这并不理想，也是分配给我的事情之一。

但只要表示了互斥体和锁，我就看不出 ThreadSanitizer 会抱怨什么问题（除了与使用条件变量相比可能降低效率之外）。

ThreadSanitizer 抱怨数据争用“好像通过睡眠同步”，并提供了调用位置usleep()。我的问题是，当然通过睡眠同步并不理想，但只要尊重互斥体，我就不会看到数据竞争。据我了解互斥体的工作方式，我确实相信它们受到尊重。

因此，我尝试创建一组最小的重现步骤，以便准确识别 ThreadSanitizer 所抱怨的内容。

这是我想出的代码：

// g++ --std=c++11 -lpthread as-if-synchronized-via-sleep.cpp -g -fsanitize=thread -pie -fPIC
#include <iostream>
#include <iomanip>
#include <thread>
#include <vector>
#include <atomic>
#include <mutex>
#include <chrono>
#include <cstdlib>

#include <unistd.h>

class Data {
public:
        char uncompressed[1024];
        char compressed[1024];
        std::atomic<bool> done = {false};
};

int main(int argc, char **argv) {
        std::atomic<bool> done = {false};
        std::atomic<int> count = {0};

        std::mutex m;
        std::vector<Data*> v;

        std::thread provider{[&](){ …

// g++ --std=c++17 test.cpp -I /usr/local/include -L /usr/local/lib -lboost_system -Wall -pedantic -Wreturn-type -Wstrict-aliasing -Wreturn-local-addr -fsanitize=address -g
// LD_LIBRARY_PATH=/usr/local/lib ./a.out

#include <iostream>
#include <boost/filesystem.hpp>

namespace fs = boost::filesystem;

class A {
public:
    fs::path path_;

    const fs::path & path() const { return path_; }
    fs::path & path() { return path_; }
};

class B {
public:
    fs::path root_path_;

    A path_2;
    A path_3;

    const fs::path & operator()() const {
        for ( const auto & path : {
            path_3.path(),
            path_2.path(),
            root_path_
        }) {
            if …

// g++ sizeofint.cpp --std=c++11 -Wconversion -Wall -Wextra -Werror -pedantic-errors
#include <iostream>
#include <utility>

int main(int argc, char **argv) {
    (void)argc;
    (void)argv;
    int a = 0x12345678;
    std::cout << sizeof(int) << "..." << sizeof(uint16_t) << std::endl;
    std::pair<uint16_t, uint16_t> p{a,a}; // !!!! no warning or error on conversion !!!!
    std::cout << p.first << ":" << p.second << std::endl;
    uint16_t b = a; // !!!! correct behavior: -Wconversion triggers warning, which -Werror turns to an error
    std::cout << b << std::endl;
    return 0;
} …

脚本.sh：

set -x\nset -e\nset -u\nset -o pipefail\n\nfoo=$(tail -1 <(false || { >&2 echo "failed" && exit 1; }) | echo "pipeline still running" || { >&2 echo "failed" && exit 1; }) || { >&2 echo "failed" && exit 1; }\n\necho "Script still running..."\n

为什么echo "Script still running..."最终会被处决？set -e我认为和的组合set -o pipefail应该意味着false传播到主脚本并终止于，foo=...但 foo 被分配为“管道仍在运行”......并且当我希望脚本不会继续时，脚本会继续。我曾想过这个问题支持这个想法。

在阅读了有关 pipelinefail 的 bash 手册页（特别是）后，它指出A pipeline is a sequence of one …