小编Pau*_*nta的帖子

说我有这样的宏:

#define SET_TYPE_NAME(TYPE, NAME) \
    template<typename T>          \
    std::string name();           \
                                  \
    template<>                    \
    std::string name<TYPE>() {    \
        return NAME;              \
    }

如果我传递一个具有多个参数的模板,这将无效,因为其中的逗号<int, int>被解释为分隔宏参数,而不是模板参数.

SET_TYPE_NAME(std::map<int, int>, "TheMap")
// Error: macro expects two arguments, three given

这样做似乎可以解决这个问题:

SET_TYPE_NAME((std::map<int, int>), "TheMap")

但现在出现了另一个问题,我真的没想到的问题:

 template<>
 std::string name<(std::map<int, int>)>()
 // template argument 1 is invalid

似乎额外的括号使模板参数无效.有没有办法解决？

D似乎是一种具有很高潜力的语言,我对未来的发展非常感兴趣.我很好奇,有没有关于在D中包含流的讨论？C++流程在过去对我有很大的帮助,它们似乎比使用printf/ writefln或其他任何函数更清晰.

在比较像这样的情况下的指针时,我想了解一些关于最佳实践的信息:

class Base {
};

class Derived
    : public Base {
};

Derived* d = new Derived;
Base* b = dynamic_cast<Base*>(d);

// When comparing the two pointers should I cast them
// to the same type or does it not even matter?
bool theSame = b == d;
// Or, bool theSame = dynamic_cast<Derived*>(b) == d?

我有一个EventManager用C++编写并暴露给Python的类.这就是我打算从Python端使用它的方式:

class Something:
    def __init__(self):
        EventManager.addEventHandler(FooEvent, self.onFooEvent)
    def __del__(self):
        EventManager.removeEventHandler(FooEvent, self.onFooEvent)
    def onFooEvent(self, event):
        pass

(add-和remove-作为静态函数公开EventManager.)

上面代码的问题是回调是在boost::python::object实例中捕获的; 当我这样做时self.onFooEvent会增加引用计数self,这将阻止它被删除,因此析构函数永远不会被调用,因此事件处理程序永远不会被删除(除非在应用程序结束时).

该代码适用于没有self参数的函数(即自由或静态函数).我应该如何捕获Python函数对象,以便我不会增加它们的引用计数？我只需要对对象的弱引用.

标题实际上有点误导,但我想保持简短.我已经读过为什么我应该使用size_t,我经常发现这样的语句:

size_t 保证能够表达任何对象的最大大小,包括任何数组

我真的不明白这意味着什么.是否可以一次分配多少内存,并且size_t保证足够大以计算该内存块中的每个字节？

后续问题:
什么决定了可以分配多少内存？

当你编写一些自给自足的脚本时,使用它if __name__ == '__main__'作为编写测试的地方是一个坏主意吗？

dynamic_casts比较慢,但它们比static_casts 更安全(当然,当与对象层次结构一起使用时).我的问题是,在我的调试代码中确保所有(动态)强制转换都是正确的之后,我有什么理由不将它们更改为static_casts吗？

我计划使用以下构造执行此操作.(顺便说一下,你能想到一个更好的名字assert_cast吗？也许debug_cast？)

#if defined(NDEBUG)

    template<typename T, typename U>
    T assert_cast(U other) {
        return static_cast<T>(other);
    }

#else

    template<typename T, typename U>
    T assert_cast(U other) {
        return dynamic_cast<T>(other);
    }

#endif

编辑: Boost已经有了一些东西:polymorphic_downcast.感谢PlasmaHH指出这一点.

我正在开发一个使用Python扩展/编写脚本的C++应用程序.当然,C++通常比Python快得多,但这是否意味着您应该尽可能多地使用Python代码执行C++代码？

我问这个是因为我不确定,在用C++编写的代码和用Python编写的代码之间切换控制是否有任何性能成本？我是否应该在任何场合使用用C++编写的代码,或者我应该避免回调C++来完成简单的任务,因为执行C++代码可能带来的任何速度增益都超出了语言之间切换的成本？

编辑:我应该说清楚,我不是要求它实际解决问题.我纯粹是出于好奇而问,这是值得记住的未来.所以我对替代解决方案不感兴趣,我只想从技术角度了解答案.:)

有没有办法可以将这个循环内联？

already_inserted = True
for i in indexes:
    already_inserted = already_inserted and bitfield[i]

在C++中,您可以使用模板同时拥有通用容器和类型安全容器.但是在C中,如果你想要通用容器,你必须(afaik)使用void*,这意味着你失去了类型安全性.要拥有类型安全的容器,您必须为要保留的每种类型的数据重新实现它们.

鉴于C遵循比C++ 更多的程序员知道他所做的理念,在C中做什么更惯用的事情:使用通用容器void*,或为每种类型的数据制作自定义容器？