小编Mic*_*ael的帖子

我的程序中有一个奇怪的错误,经过几个小时的调试后,我发现了以下非常愚蠢的行:

int a = b * (c * d *  + e)

如果你没有看到它:在d和e我之间写的* +,只是一个+意图.

为什么这会编译,它实际上意味着什么？

令人惊讶的是,没有明确的文档__weakref__.这里解释了弱引用.__weakref__也很快在文档中提到__slots__.但我找不到任何关于__weakref__它自己的东西.

到底是__weakref__什么？ - 它只是一个作为标志的成员:如果存在,该对象可能被弱引用？ - 或者它是一个可以被覆盖/分配以获得所需行为的函数/变量？怎么样？

我有一个类,它本质上是一个集合/事物列表.但是我想在这个列表中添加一些额外的功能.我想要的是以下内容:

• 我有一个例子li = MyFancyList().变量li应该表现为它是每当我用它作为一个列表的列表:[e for e in li],li.expand(...),for e in li.
• 再加上它应该有这样一些特殊功能li.fancyPrint(),li.getAMetric(),li.getName().

我目前使用以下方法:

class MyFancyList:
  def __iter__(self): 
    return self.li 
  def fancyFunc(self):
    # do something fancy

这可以作为迭代器使用[e for e in li],但我没有完整的列表行为li.expand(...).

第一种猜测是继承list到MyFancyList.但这是推荐的pythonic方式吗？如果是,那要考虑什么？如果不是,那会是更好的方法吗？

假设我有一个由a管理的对象std::unique_ptr.我的代码的其他部分需要访问此对象.传递指针的正确解决方案是什么？我应该只是通过普通指针,std::unique_ptr::get还是应该使用并传递一个std::shared_ptr而不是std::unique_ptr根本？

我有一些偏好,std::unique_ptr因为该指针的所有者实际负责清理.如果我使用共享指针,那么由于共享指针,对象将有可能保持活动状态,即使它实际上应该被销毁.

编辑:不幸的是,我忘了提到指针不仅仅是函数调用的参数,而是存储在其他对象中以构建对象的网络结构.我不喜欢共享指针,因为它不再清楚,谁拥有该对象.

A类使用用C编写的库.这个库提供了一些在A中使用的数据类型和常量.不幸的是,该库还在其头文件中定义了宏,它与main.cpp或其他使用A的类中的C++代码冲突.

当Ah被包含在某处时,如何防止执行c_library.h的宏？我也愿意接受架构改变,但我宁愿不接触C库.

当然,还有#undef指令.但这意味着每个宏或每次碰撞都会进行大量的手动操作.(好吧,没有太多 - 但嘿,这一定可能更优雅吗？)

码:

//main.cpp

#include "A.h"

...
A a(...)
...
std::max(x, y); // oops, problem since max is defined as macro in c_library.h
...

//A.h
#include "c_library.h"

class A{
public:
    A(...);
    static void callbackForCLibrary(datatypeOfCLibrary d){...}
private:
    private datatypeOfCLibrary1;
    private datatypeOfCLibrary2;
}

使用Aztec线性系统求解器库时,我遇到了奇怪的行为.使用valgrind,我发现这个库memcpy在重叠缓冲区上执行.规范说明memcpy没有定义重叠缓冲区的行为.

事实证明,memcpy在许多机器上具有与使用for循环一样的行为,因此您可以安全地从较高的源复制到较低的目标:

for(int i = 0; i < len; i ++)
  dest[i] = source[i];

但是在我们的大型集群上,memcpy重叠缓冲区具有不同的行为,这会导致问题.

现在我想知道memcpy库中的重叠是正常的还是仅仅是由我的代码中的另一个错误引起的.由于库被广泛使用,我认为memcpy应该早先发现该问题.另一方面,绝大多数memcpy实现仍然可能像for循环一样,因此没有人遇到过这个问题.

• 谁能告诉我他memcpy在各种机器上重叠的经历？
• 我的计算机系统的哪一部分确实提供了memcpy？

我想指出的问题是关于各种实现的实际经验,而不是规范所说的内容.

我有以下非常简单的模板.据我所知,^不是指数运算符.现在我正在寻找一种计算这种能力的方法.互联网上有许多递归模板的例子.这不是太难.

但我想知道:在C++中实际上没有"内置"方法来在编译时计算它吗？

template <int DIM>
class BinIdx : Idx
{
        static const int SIZE = 3 ^ DIM; // whoops, this is NOT an exponential operator!
}

假设我构建了一个基本上代表数字加上一些奇特东西的类.在任何算术/数学运算中,该类的实例应该像数字一样.

我可以重载该类中的所有数字运算符,但是没有更短的解决方案吗？

该课程基本上如下:

class MyFancyNumber:
    def __init__(self, num, info):
        self.num = num # the actual number
        self.info = info # some more info, or other data
    def doFancyStuff(self):
        # does something fancy
    def __add__(self, other):
        return self.num + other # same pattern for all numeric functions

假设我有类似的东西:

template <class T>
void do_something(T t){
  pass_it_somewhere(t);
  t->do_something();
}

现在T允许是指针类型或非指针类型是有用的.函数do_something(...)基本上可以处理指针和非指针,除了t->do_something().对于指针,我需要一个->和非指针,我需要一个.访问成员.

有没有办法让T接受指针和非指针？

我只是好奇当我将一个实例继承到一个类时会发生什么.

所以我尝试过:

class X:
    def __init__(self, x):
        self.x = x
    def print(self):
        print(self.x)

def inherit(obj):
    class Child(obj): # Line 20
        pass  # or maybe added functionality

    return Child

param = 5
x = X(param)
y = inherit(x) # Line 27
y.print()

我得到(至少)以下错误:

Traceback (most recent call last):
  File "/test.py", line 27, in <module>
    y = inherit(x)
  File "/test.py", line 20, in inherit
    class Child(obj):
TypeError: __init__() takes 2 positional arguments but 4 were given

我只是想知道:继承一个有意义/有用的实例还是简单的废话？

(这个问题有点学术性,特别是关于继承实例的细节.它不是关于对象委托或一般设计实践等替代方案.)