小编Bjö*_*lex的帖子

在代码中:

template<class T>
struct is_builtin
{
    enum {value = 0};
};

template<>
struct is_builtin<char>
{
    enum {value = 1};
};

template<>
struct is_builtin<int>
{
    enum {value = 1};
};

template<>
struct is_builtin<double>
{
    enum {value = 1};
};

template<class T>
struct My
{
    typename enable_if<is_builtin<T>::value,void>::type f(T arg)
    {
        std::cout << "Built-in as a param.\n";
    }


    typename enable_if<!is_builtin<T>::value,void>::type f(T arg)
    {
        std::cout << "Non - built-in as a param.\n";
    }
};

struct A
{
};

int main()
{
    A a;
    My<int> …

我目前正在重新实现一些用Python编写的算法.一步是计算值列表的标准偏差.最初的实现使用DescriptiveStatistics.getStandardDeviation了Apache Math 1.1库.我使用numpy 1.5的标准偏差.问题是,它们为相同的输入提供(非常)不同的结果.我的样本是这样的:

[0.113967640255, 0.223095775796, 0.283134228235, 0.416793887842]

我得到以下结果:

numpy           : 0.10932134388775223
Apache Math 1.1 : 0.12620366805397404
Wolfram Alpha   : 0.12620366805397404

我与Wolfram Alpha核实了第三个意见.我不认为这种差异可以仅通过精确来解释.有谁知道为什么会这样,我能做些什么呢？

编辑:在Python中手动计算它会得到相同的结果:

>>> from math import sqrt
>>> v = [0.113967640255, 0.223095775796, 0.283134228235, 0.416793887842]
>>> mu = sum(v) / 4
>>> sqrt(sum([(x - mu)**2 for x in v]) / 4)
0.10932134388775223

另外,关于不正确使用它:

>>> from numpy import std
>>> std([0.113967640255, 0.223095775796, 0.283134228235, 0.416793887842])
0.10932134388775223

像:

void f()
{
  cout << "blah" << endl;
}

BOOST_AUTO_TEST_CASE(f)
{
  f();
  // This would be a beauty
  // BOOST_CHECK_PROGRAM_OUTPUT_MATCH("blah");
}

我在Mac OS X 10.6.4上运行Python 2.6.5(这不是本机版本,我自己安装)与Scipy 0.8.0.如果我执行以下操作:

>>> from scipy.stats import hypergeom
>>> hypergeom.sf(5,10,2,5)

我得到了IndexError.然后我做:

>>> hypergeom.sf(2,10,2,2)
-4.44....

我怀疑负值是由于浮点精度差.然后我又做了第一个:

>>> hypergeom.sf(5,10,2,5)
0.0

现在它有效!有人可以解释一下吗？你也看到了这种行为吗？

我编写了一个类,用于以便捷的方式存储参数进行酸洗.它超载__setattr__以方便访问.它还使用列表来记住添加属性的顺序,以便迭代顺序可预测且不变.这里是:

class Parameters(object):
    def __init__(self):
        self._paramOrder = []

    def __setattr__(self, name, value):
        self._paramOrder.append(name)
        object.__setattr__(self, name, value)

    def __delattr__(self, name):
        self._paramOrder.remove(name)
        object.__delattr__(self, name)

    def __iter__(self):
        for name in self._paramOrder:
            yield self.name

    def iteritems(self):
        for name in self._paramOrder:
            yield name, self.name

问题是__init__调用我的重载__setattr__以便添加_paramOrder到实例字典.有没有办法处理这个而不添加特殊情况__setattr__？

我最近偶然发现,OSGi中的Declarative Services可以将组件的配置设置为必需,以便组件在激活时接收它,消除组件激活和配置之间的差距.我也意识到你可以通过modified-method 接收配置更新.

在我看来,这个功能非常类似于通过实现ManagedService接口和发布作为您提供的"服务"之一提供的功能.

看起来我可以完全忽略ManagedService并只使用DS配置注入.

这些技术中的一种比其他技术更受欢迎,还是还有其他我没有看到的权衡取舍？

我最近尝试创建一个is_class类,并且需要一种方法让编译器区分枚举类型和定义了转换运算符的类类型.看到类,结构和联合是如何与指针到成员函数兼容的唯一类型,我决定让编译器确定用于实例化is_class模板的类型是否与指向成员函数的指针兼容.在遇到几个问题之后,我决定在与指向成员的指针一起使用时测试枚举的行为并得到一些古怪的结果.以下部分说明了第一个怪癖:

enum ENUM {};
void Test(void (ENUM::*pmem) (void))
{
    /* ... */
}
Test(NULL);

使用Microsoft Visual C++ 2010进行编译时,函数定义的指向成员的部分: (ENUM::*pmem)

以红色突出显示,鼠标悬停在声明上显示错误:

Error: "ENUM" is not a class type

但是,编译器解析此段而不会遇到任何错误,分配pmem给NULL.有趣的是,编译器允许这种看法,因为枚举类型不是类,结构或联合,因此不能拥有自己的方法.

第二个兴趣点出现在创建模板函数时,采用其类型不同的指向成员的参数:

template<class _Ty>
void Test_Template(void (_Ty::*pmem) (void))
{
    /* ... */
}

当然为了使用这个功能,必须明确限定:

Test_Template<ENUM>(NULL);

但是,此调用会生成错误说明:

invalid explicit template argument(s) for 'void Test(void (__thiscall _Ty::* )(void))'

我通过创建一个额外的函数模板解决了这个问题,该模板的原型将匹配任何未能匹配前模板函数原型的调用(涉及使用省略号).

问题:

1. 为什么枚举与指向成员的指针兼容？

2. 当Test编译器为模板Test_Template显式限定生成错误时,为什么在调用非模板函数时存在完全匹配？

最近,当我向某人解释指针和引用(在C++编程的上下文中)之间的基本区别时,我告诉通常的解释,讨论不同的函数参数传递约定 - 按值调用,按指针调用,按引用调用,以及所有关于参考文献的相关理论.

但后来我认为无论C +引用在参数传递方面做了什么,(允许传递大型结构/对象的内存有效方式,同时通过不允许被调用者修改作为引用传递的对象的任何变量来保持安全性,如果我们的设计需要它)

C中的const指针将实现相同的功能,例如,如果需要通过将结构指针强制转换为常量来传递结构指针(例如struct mystr*ptr) -

func(int,int,(const struct mystr*)(ptr));

ptr不会某种等同于参考？

1. 它是否会以不通过复制结构(通过指针传递)来节省内存的方式工作,而且由于它被作为const指针传递而不允许对结构字段进行任何更改,因此也是安全的.

   在C++对象上下文中,我们可以传递const对象指针而不是对象引用来实现相同的功能)

2. 如果是,那么C++中的用例场景需要引用.参考文献的任何特定好处,以及相关的缺点？

谢谢.

-广告

我有几个共享一些不变量并具有通用接口的类,我想为每个类自动运行相同的测试.

作为一个例子,假设我有几个类实现不同的方法来分区数据集.这里的常见不变量是,对于所有这些类,所有分区上的并集应该等于原始数据集.

我目前看到的是这样的:

class PartitionerInvariantsTests(unittest.TestCase):
    def setUp(self):
        self.testDataSet = range(100) # create test-data-set

    def impl(self, partitioner):
        self.assertEqual(self.testDataSet, 
                         chain.from_iterable(partitioner(self.testDataSet))

然后我添加了一个不同的函数,该函数调用impl我想要使​​用该类的实例测试的每个类.当针对多个测试功能执行此操作时,此问题变得明显.假设我有5个测试函数和5个我想测试的类.这将使25个函数在调用所有测试时几乎完全相同.

我想到的另一种方法是将模板实现为超类,然后为我想要测试的每个类创建一个子类.子类可以提供实例化类的功能.问题在于默认的测试加载器会将(不可用的)基类视为有效的测试用例并尝试运行它,这会失败.

那么,你的建议是什么？

PS:我使用的是Python 2.6

我目前正在编写自己的小ORM,并发现自己面临着创建规范化映射的任务,以防止从数据库中多次加载同一个实体.

我目前的做法是使用a HashMap<Object, WeakReference<Object>>.密钥是映射的数据库实体的主键(ArrayList<Object>如果它是复合键),则值为WeakReference<Object>.

我的主要问题是如何清理地图？当一个对象不再使用时,地图中的弱引用将会出现null,我只会在下一次查找时发现这一点(或者,如果我不再查看该对象,则永远不会发现).ReferenceQueue当它们被清除时,我可以使弱引用注册为a ,然后每次查看时检查该队列.清除的引用不会给我任何关于哪个对象被清除的提示,所以我想我必须子类WeakReference将该键存储在地图中,所以我可以在清除引用后将其删除.

这是要走的路,还是有更简单的方法来实现它？