小编Mar*_*tin的帖子

在单个翻译单元中考虑以下代码:

class C {
private:

    struct Init {

        Init() {
            /* compute data once here */
        }
    };
    static const Init& i;
    static int data[];
public:
    /* interface for reading data */
};

const C::Init& C::i = Init();
int C::data[200];

1. C :: i总是在C :: data之后初始化,无论两者的定义顺序如何？
2. 这个解决方案是一次计算静态数据最优雅的解决方案吗？

考虑下面的两个模板函数:

template <typename T, typename A>
T* create(A i) {
   return new T(i);
}

template <typename T, typename A>
T* create(A i) {
   return new T();
}

它们具有相同的签名,但对于给定的T和A,只能实例化一次.

有没有办法将一些SFINAE惯用法应用于上述模板函数,以便可以实例化的模板函数的版本是第一个版本,当且仅当T具有接受A作为参数类型的构造函数时,否则第二个版本具有默认构造函数将被实例化,例如:

// S is given, cannot be changed:
struct S {
   S(int) {}
}

int main() {
   // the first template function should be instantiated since S has S(int)
   create<S, int>(0); // the only call in the program
   // ...
}

我知道这已经被问到了,但是我们真的想拒绝任何提交文件的尝试,这些文件会破坏trunk中的项目.拒绝已提交文件的决定基于正在提交的文件所属的项目构建过程的结果.我知道在预提交阶段,无法同时访问存储库,但这对我们来说不是问题,因为我们的构建非常快,我们可以容忍任何延迟.

有没有工具可以达到我们想要的效果？请注意,有必要重新编译整个项目单元,而不仅仅是要提交的单个文件.

如果不能以任何合理的方式完成,那么是否可以在后提交时构建代码,然后在构建步骤失败的情况下立即回滚？哈德森或其他工具可以配置为我们想要的吗？

在我的程序中,我需要动态加载共享库dlopen().程序和共享库都成功交叉编译,用于ARM我的安装交叉编译器的体系结构x86.但是,每当程序尝试在运行时加载库时ARM,它都会失败,并显示以下错误:

未定义的符号:_dl_hwcap

我找不到这个错误的罪魁祸首.

让我详细说明如何libmyplugin.so构建共享库()x86.我使用g++交叉编译器如下:

/home/me/arm/gcc-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ -march=armv7-a -mfloat-abi=hard -c -s -fPIC -o build/module1.o module1.cpp
/home/me/arm/gcc-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ -march=armv7-a -mfloat-abi=hard -c -s -fPIC -o build/module2.o module2.cpp
/home/me/arm/gcc-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ -o dist/libmyplugin.so build/module1.o build/module2.o --sysroot /home/me/arm/sysroot/ -Wl,--no-as-needed -ldl -lX11 -lXext /home/me/arm/libstatic.a -shared -s -fPIC

请注意以下注意事项:

1. module1.cpp并且module2.cpp是我的源代码文件.
2. libstatic.a是一个大型的目标.o文件存档,它实现了由module1.cppand 直接调用/引用的东西module2.cpp.这些目标文件已由其他人编译为与我相同的ARM体系结构,具有相同的编译器标志,但使用稍微更新的g++编译器(v4.9而不是我的v4.8.3).不幸的是,我无法控制这些物体的构建.
3. --sysroot /home/me/arm/sysroot/表示我的远程文件系统,ARM OS本地g++交叉编译器在链接时可以从中获取本机库.
4. -Wl,--no-as-needed …

在最近的一篇文章中,我读到以下使用std :: map ::\templace可能会泄漏内存,但我不明白为什么:

// might leak if allocation fails due to insufficient memory for an object A
std::map<int, std::unique_ptr<A>> m;
m.emplace(1, std::make_unique<A>("Ann",63));

谁能解释一下？

请考虑以下代码:

#include <iostream>

struct A {
    const char *name;

    A() : name("A") {
        std::cout << "A()\n";
    }

    virtual ~A() {
        std::cout << "~A()\n";
    }
};

class B {
    const A& a;
public:

    B() : a(A()) {
    };

    void print_data() const {
        std::cout << a.name << '\n';
    }

    ~B() {
        std::cout << "~B()\n";
    }
};

int main() {
    B b;
    b.print_data();
    return 0;
}

GCC 4.4的输出是:

A()~A()A~B()

这看起来很奇怪.我原本期望A的临时实例的副本被绑定到B :: a或者临时本身在~B()期间被破坏.

基本上,我认为B :: a在b的生命期间始终是有效的参考.事实上,b.print_data()显然工作,编译器不会发出任何警告.

标准c ++ 98/03对此事有何评价？

考虑以下定义:

struct A {
   // ...
};

struct B : public A {}; // empty

void f(B& b) { /* use b */}

void g(A& a) {
   f(static_cast<B&>(a)); // is this a safe downcast?
}

int main() {
   A a;
   g(a);
}

在上面的例子a中确实是一个实例A.

由于B有一个空的定义,我想知道在这种特定情况下,对f及其执行的调用是否是未定义的行为.

请考虑以下示例.

#include <string>


template<class CharT, class Traits = std::char_traits<CharT >, class Allocator = std::allocator<CharT >>
void f(const std::basic_string<CharT, Traits, Allocator>& s) {
}

int main() {
     f("Hello World!");
}

在编译时,我得到了

不匹配的类型 ‘const std::basic_string<_CharT, _Traits, _Alloc>’ and ‘const char []’

为什么编译器不能扣除"CharT"并进行相应的转换basic_string<>？我想只有一个f()签名对任何转换为basic_string<>存在的参数类型有效,是否有解决此问题的方法？

考虑class D从a class B和a的sb实例派生std::shared_ptr<B>.一旦我确认了dynamic_cast<D*>(sb.get())可能,我想std::shared_ptr<D>从某人那里创建一个合适的.换句话说,我想dynami_cast<>在shared_ptr之间实现一种.我怎么能以干净的方式做到这一点？一种可能的解决方案是使B 从(铸造)指针派生std::enable_shared_from_this并使用.但这需要改变B类的定义.是否有更好的想法？有什么吗？shared_from_this()Dboost

出于多种原因,我想在两个进程之间使用unix域套接字进行IPC.

每个进程通过写入套接字并将此事件传递给第二个进程来响应来自外部世界的某些特定类型的异步事件 - 同时 - 每个进程还需要读取来自另一个套接字的数据来执行某些操作.实质上,在这个模型中,每个进程将有一个套接字和两个线程:一个用于可能阻塞读取,一个用于写入.

我想知道是否可以使用unix域套接字来独立地从/向每个进程读取和写入,而不使用任何显式锁定,这种安全性将由这些套接字隐式保证.如果是的话,我也想知道这个保证在哪里正式声称.