小编Max*_*rin的帖子

所以我们正在使用一个版本的boost,这个版本现在很老了,直到升级我需要在C++中为我的代码进行原子CAS操作.(我们还没有使用C++ 0x)

我创建了以下cas函数:

inline uint32_t CAS(volatile uint32_t *mem, uint32_t with, uint32_t cmp)
{
    uint32_t prev = cmp;
    // This version by Mans Rullgard of Pathscale
    __asm__ __volatile__ ( "lock\n\t"
            "cmpxchg %2,%0"
            : "+m"(*mem), "+a"(prev)
              : "r"(with)
                : "cc");

    return prev;
}

我使用该函数的代码有点如下:

void myFunc(uint32_t &masterDeserialize )
{
    std::ostringstream debugStream;

    unsigned int tid = pthread_self();
    debugStream << "myFunc, threadId: " << tid << " masterDeserialize= " << masterDeserialize << " masterAddress = " << &masterDeserialize << std::endl;

    // memory fence
    __asm__ …

我正在尝试通过boost python创建一个包含几个模块的包.

原因是我们希望公开一个非常大的API,将它组合在不同的模块中以便于使用和保留python内存使用是有意义的.另一方面,我们被迫(由于超出此问题范围的原因将其编译为单个共享对象)

所以我用boost python创建了一个导出几个模块的包,如下所示:

void exportClass1()
{
    namespace bp = boost::python;
    // map the IO namespace to a sub-module
    // make "from myPackage.class1 import <whatever>" work
    bp::object class1Module(bp::handle<>(bp::borrowed(PyImport_AddModule("myPackage.class1"))));
    // make "from mypackage import class1" work
    bp::scope().attr("class1") = class1Module;
    // set the current scope to the new sub-module
    bp::scope io_scope = class1Module;

    // export stuff in the class1 namespace

    class_<class1 >("class1", init<>())
    .
    .   CLASS SPECIFICS GO HERE
    .

    Other class of module class1 go here …

我想在编译期间检查是否使用/不使用某些类的某些函数,并因此失败/通过编译过程.

例如,如果函数F1在代码中的某处被调用,我希望编译成功,如果函数F2被调用,我希望它失败.

有关如何使用预处理器,模板或任何其他c ++元编程技术的任何想法？

我有一个Python API，它可以返回一个对象，或者None如果没有找到对象。我想避免运行时异常/崩溃等，因此我想强制我的 API 的用户进行测试is not None。

例如：

x = getObject(...)
if x is not None:
   print x.getName()  #should be o.k.


y = getObject(...)
print y.getName() # print an error to the log

我怎样才能做到这一点？

在 C++ 中的类似代码中，我可以添加一个标志，当我调用getName();时将检查该标志。该标志仅在将对象与 进行比较时设置NULL。

然而，在 Python 中，我无法重载该is运算符。还有其他方法可以在 Python 中实现该功能吗？

使用 GCC 时，考虑到我有时在发布时编译相同的库，有时在调试时编译相同的库，ABI 是否保证兼容？

（同时使用相同的编译器）

我有一个可执行文件和一些共享对象（有些依赖于其他对象），我希望能够交换发布/调试共享对象，而无需重新编译所有内容，而只重新编译感兴趣的共享对象。

这是可能的，还是在某些情况下我可能会以这种方式获得一些未定义的行为？（假设我的代码被严格打包，并在发布和调试中填充）

编辑：

我将详细说明我们看到的问题。我们有一个自定义版本intrusive_ptr，在调试模式下，我们有自己intrusive_ptr的一个成员，即 a boost::intrusive_ptr，而在发布中，我们只使用boost::intrusive_ptr. 我们的 APIintrusive_ptr与 相同boost::intrusive_ptr，并且我们在类中没有任何虚函数。
我们看到的是：
如果我们使用所有调试库或所有发布库，则一切正常。如果我们将调试可执行文件与发布库混合使用，则会发生内存泄漏，intrusive_ptr并且不会释放对象。

我们intrusive_ptr和的大小boost::intrusive_ptr在调试和发布中都是相同的（我们的类不会在顶部添加任何大小开销）。

所以我想知道是什么导致了泄漏，ABI 差异是唯一想到的事情。

想法？

我有一个头文件,我可以控制它的内容.

另外,我有一个接口I1(在一些其他文件中定义),从中派生出各种实现.我想禁止这些实现包含此头文件.因此,在编译期间,如果包含该文件,编译将失败,否则它将照常继续.

所以我有头文件和接口定义(在其他一些文件中).我想在编译期间禁止接口实现包含给定的头文件.

关于如何实现这一点的任何建议？我可以使用一些聪明的模板/预处理技巧吗？

我正在尝试覆盖通过 boost python 公开的类的 python 相等运算符。

所以我的代码看起来像这样：

   class_<MyClass, boost::noncopyable, boost::shared_ptr<MyClass> >("MyClass", no_init)
    .def("foo", &MyClass::foo)                                    
     .
     .
     .
    .def("__eq__", &MyClass::operator==) 
    .def("__ne__", &MyClass::operator!=)

然而在 python 中，当我获取代表相同 C++ 对象但来自不同 python 对象的对象的 2 个实例时，它们永远不相等......

因此：

from myPackage import myClass

v1 = myClass.get("abc")
v2 = myClass.get("abc")
if v1 == v2:
   print "true"
else:
   print "false"

总是打印错误。（为了简单起见，我省略了对象中的 get 函数定义）

有任何想法吗？