小编eca*_*mur的帖子

我想定义一个支持__getitem__但不允许迭代的类.例如:

class B:
   def __getitem__(self, k):
      return k

cb = B()

for x in cb:
   print x

我可以在课堂B上添加什么来强制for x in cb:失败？

该标准似乎提供了两个规则来区分涉及用户定义的转换运算符的隐式转换序列:

C++ 11

13.3.3最佳可行功能[over.match.best]

[...]一个可行的功能F1被定义为比另一个可行的功能F2更好的功能,如果[...]

• 上下文是用户定义转换的初始化(见8.5,13.3.1.5和13.3.1.6),从返回类型F1到目标类型的标准转换序列(即,被初始化的实体的类型)是比从返回类型F2到目标类型的标准转换序列更好的转换序列.

13.3.3.2对隐式转换序列进行排序[over.ics.rank]

3 - 相同形式的两个隐式转换序列是无法区分的转换序列,除非以下规则之一适用:[...]

• 用户定义的转换序列U1是比另一个用户定义的转换序列U2更好的转换序列,如果它们包含相同的用户定义的转换函数或构造函数或聚合初始化,并且U1的第二标准转换序列优于第二标准转换序列U2.

据我了解,13.3.3允许编译器区分不同的用户定义的转换运算符,而13.3.3.2允许编译器区分不同的函数(某些函数的重载f),每个函数都需要在参数中进行用户定义的转换(请参阅我的侧边栏给出以下代码(在GCC 4.3中),为什么转换为引用调用两次？).

是否有其他规则可以区分用户定义的转换序列？/sf/answers/96883111/上的答案表明,13.3.3.2:3可以根据隐式对象参数(转换运算符)的cv限定来区分用户定义的转换序列,或者构造函数或聚合初始化的单个非默认参数,但我不知道这是如何相关的,因为这需要比较各个用户定义的转换序列的第一个标准转换序列,标准没有似乎提到了.

假设S1优于S2,其中S1是U1的第一个标准转换序列,S2是U2的第一个标准转换序列,那么U1是否优于U2？换句话说,这段代码是否格式良好？

struct A {
    operator int();
    operator char() const;
} a;
void foo(double);
int main() {
    foo(a);
}

g ++(4.5.1),Clang(3.0)和Comeau(4.3.10.1)接受它,更喜欢非const限定A::operator int(),但我希望它被拒绝为含糊不清且因此格式错误.这是标准中的缺陷还是我对它的理解？

关于我是否以最佳方式进行某事的问题......

我希望在Python中有一个类层次结构,它看起来(最低限度)如下所示;

class Actor
  class Mover(Actor)
  class Attacker(Actor)
    class Human(Mover, Attacker)

但我反对的事实跑起来Actor有一定的属性,我想初始化它,从每个的Mover和Attacker子类,如以下;

class Actor:
    _world = None
    def __init__(self, world):
        self._world = world

class Mover(Actor):
    _speed = 0
    def __init__(self, world, speed):
        Actor.__init__(self, world)
        self._speed = speed

class Attacker(Actor):
    _range = 0
    def __init__(self, world, range):
        Actor.__init__(self, world)
        self._range = range

如果我当时采用我的初始方法,并遵循我在使用超类'构造函数方面的常规方法,我显然最终会调用Actor构造函数两次 - 不是问题,但我的程序员感觉到了刺痛并说我'而宁愿做一个更干净的方式;

class Human(Mover, Attacker):
    def __init__(self, world, speed, range):
        Mover.__init__(self, world, speed)
        Attacker.__init__(self, world, range)

我也 …

我试图运行Eric Lippert的博客文章中的代码"为什么递归的lambda导致明确的赋值错误？"

但不是运行(或给出编译"明确的分配错误",我得到:

名为't'的局部变量不能在此范围内声明,因为它会给't'赋予不同的含义,'t'已在'父或当前'范围内用于表示其他内容

为什么？
它在父母或当前范围内已经在哪里使用？
试图重命名它有相同的错误
我应该如何更改代码以启动此代码？

using System;
namespace LippertRecursiveLambdaError
{
  class Program
  {
    static void Main(string[] args)
    {
      Tree<int> tree = new Tree<int>
      (3, new Tree<int>
             (4, new Tree<int>(1), null), 
          new Tree<int>(5));
      PrintTree(tree);
      Console.ReadLine();
    }

    delegate void Action<A>(A a);
    delegate void Traversal<T>(Tree<T> t, Action<T> a);

  static void DepthFirstTraversal<T>(Tree<T> t, Action<T> a)
  {
    if (t == null) return;
    a(t.Value);
    DepthFirstTraversal(t.Left, a);
    DepthFirstTraversal(t.Right, a);
  }
  static void Traverse<T>(Tree<T> t, Traversal<T> f, Action<T> a)
  {
    f(t, a); …

我在 BitBucket 上分叉了一个仓库：

$ hg paths
default = https://bitbucket.org/mine/project
upstream = https://bitbucket.org/theirs/project

现在我想将我的存储库的（本地）状态与其上游进行比较。使用 git 我只是写git diff --stat upstream/master origin/master，但 hg 似乎不接受远程分支名称作为参数：

$ hg diff --stat upstream/default default/default
default/default: No such file or directory
upstream/default: No such file or directory

我猜我可能可以将其指定为revset，但我无法正确使用语法，并且找不到任何示例。

问题Mercurial - 比较本地和远程存储库？看起来相关，但这只是显示了本地和远程状态之间的差异；我想看看远程状态和它所分叉的上游远程之间的区别。

我有几个WinZipped csv文件,并希望将其作为Pandas数据帧阅读.问题是,解压缩选项('gzip'或'bz2')似乎都不起作用.这是文件的样子:

00000000011!00023011!89011!200812
00000000012!00023011!89011!200812
00000000013!00023011!89011!200812

因此,似乎我将不得不使用Python的zipfile模块解压缩文件,读取行并从我读入的内容创建数据框.我想这样做的方法是创建一个这样的字典列表:

[
    {"header1": 00000000011, "header2": 00023011, "header3": 89011, "header4": 200812}, 
    {"header1": 00000000012, "header2": 00023011, "header3": 89011, "header4": 200812},
    ...
]

然后将其转换为数据框,如http://pandas.pydata.org/pandas-docs/stable/dsintro.html#from-a-list-of-dicts.

然而,这似乎涉及大量手动操作线 - 有没有更好的方法来做到这一点？

我玩弄模板专业化和 SFINAE。

至于下面的例子，事情似乎很简单：

    template <class T>
    void Do(T t, typename std::enable_if<std::is_integral<T>::value >::type* = 0)
    {
        cout << "is integer" << endl;
    }

    template <class T>
    void Do(T t, typename std::enable_if<std::is_floating_point<T>::value >::type* = 0)
    {
        cout << "is float" << endl;
    }

不，我尝试过 std::is_array，但从未使用过 std::is_array 的专业化。

所以我尝试了为什么 is_array 从不匹配：

    template <int num>
    void Do( int a[num])
    {
        cout << "int array size " << num << endl;
    }

    void Do( int* x)
    {
        cout << "int*" << endl;
    }

    ...
    int …

运行XCode 4.6的分析器和新的clang编译器,我发出了警告

被调用的C++对象指针为空

即使是像保守的表达

- (BOOL) validate: (Node*) node
{
    if (!self.hypertext) return YES;
    return self.hypertext->HasNode(node);
}

1)我怎样才能说服静态分析仪这是否得到了适当的保护？2)在某些情况下,我可能想断言指针不会为空.怎么样？

我非常喜欢"魔术方法"的语法或者在Python中调用的任何语法,比如

class foo:
    def __add__(self,other): #It can be called like c = a + b
        pass

电话

c = a + b

然后被翻译成

a.__add__(b)

是否有可能模仿"非魔法"功能的这种行为？在数值计算中,我需要Kronecker产品,并且渴望拥有"kron"功能

kron(a,b) 

实际上是

a.kron(b)?

用例是:我有两个类似的类,比如,矩阵和向量,都有Kronecker产品.我想打电话给他们

a = matrix()
b = matrix()
c = kron(a,b)

a = vector()
b = vector()
c = kron(a,b)

矩阵和向量类在一个.py文件中定义,因此共享公共命名空间.那么,实现上述功能的最佳(Pythonic？)方式是什么？可能的解决方案:

1)有一个kron()函数并进行类型检查

2)具有不同的名称空间

3)？

我在网上的某个地方发现了这段代码.程序的输出是字符串字符串字符串有人请解释我为什么第一个secon和第三个printf语句打印相同的输出,即使它们的参数不同？

#include<stdio.h>
int main()
{
char a[2][3][3] = {'s','t','r','i','n','g'};
printf("%s\n", *a);
printf("%s\n", a);
printf("%s\n", **a);
getchar();
return 0;
}