标签: member-variables

是否有任何有意义的区别:

class A(object):
    foo = 5   # some default value

与

class B(object):
    def __init__(self, foo=5):
        self.foo = foo

如果您要创建大量实例,那么这两种样式的性能或空间要求是否存在差异？当您阅读代码时,您是否认为两种样式的含义有显着差异？

如何在Python中将方法和数据成员设为私有？或者Python不支持私有成员？

以下据说比公共成员有第一个/第二个更好.我相信这几乎一样糟糕.如果您正在提供一种方法来访问课外的私有变量,那么重点是什么？功能不应该是

T First(); void(or T) First(const T&)

样品:

// Example 17-3(b): Proper encapsulation, initially with inline accessors. Later
// in life, these might grow into nontrivial functions if needed; if not, then not.
//
template<class T, class U>
class Couple {
  Couple()           : deleted_(false) { }
  T& First()         { return first_; }
  U& Second()        { return second_; }
  void MarkDeleted() { deleted_ = true; }
  bool IsDeleted()   { return deleted_; }

private:
 T first_;
 U second_;
 bool deleted_;
};

我只是在学习Python,而且我来自C背景,所以如果我在两者之间有任何困惑/混淆,请告诉我.

假设我有以下课程:

class Node(object):
    def __init__(self, element):
        self.element = element
        self.left = self.right = None

    @classmethod
    def tree(cls, element, left, right):
        node = cls(element)
        node.left = left
        node.right = right
        return node

这是一个名为的类Node,它重载构造函数,以便能够在需要时处理不同的参数.

是什么定义之间的差异self.element在__init__只(如上所示),而不是执行以下操作:

class Node(object):
    element, left, right = None
    def __init__(self, element):
        self.element = element
        self.left = self.right = None

是不是self.element在__init__相同类的element变量定义？这难道不只是简单地覆盖element从None到element传入值__init__？

考虑以下(简化)情况:

class Foo
{
private:
    int evenA;
    int evenB;
    int evenSum;
public:
    Foo(int a, int b) : evenA(a-(a%2)), evenB(b-(b%2)), evenSum(evenA+evenB)
    {
    }
};

当我像这样实现Foo时:

Foo foo(1,3);

然后evenA是0,evenB是2,但是甚至将初始化为2？

我在我当前的平台(iOS)上尝试了这个,它似乎工作,但我不确定这段代码是否可移植.

谢谢你的帮助!

根据以下资源,在C++(特别是Visual C++)中,作用域静态变量初始化不是线程安全的.但是,全局静态变量是安全的.

线程安全的静态变量没有静音？

http://blogs.msdn.com/oldnewthing/archive/2004/03/08/85901.aspx

那么,遵循静态成员变量的代码是否是线程安全的？

class TestClass
{
public:
   static MyClass m_instance;
}

Myclass TestClass::m_instance;

提前致谢!

我正在制作一个非常简单的类来表示3D空间中的位置.

目前,我只是让用户访问和修改个人X,Y和Z值直接.换句话说,它们是公共成员变量.

template <typename NumericType = double>
struct Position
{
    NumericType X, Y, Z;

    // Constructors, operators and stuff...
};

这背后的原因是,因为NumericType是一个模板参数,我不能依赖于有一个体面的方法来检查值的理智.(我怎么知道用户不希望用负值表示位置？)因此,添加getter或setter以使接口复杂化是没有意义的,因为简洁直接访问应该受到青睐.

Pos.X = Pos.Y + Pos.Z; // Versus...
Pos.SetX(Pos.GetY() + Pos.GetZ());

这是一个好的例外吗？我的代码的(假设的)未来维护者是否会追捕我并打击我的脸？

好的,所以我对C++编程非常陌生,而且我已经花了几天的时间来寻找一个决定性的答案.什么时候我应该在堆与堆栈上声明成员变量？我发现的大多数答案都涉及其他问题,但我想知道何时最好将堆用于成员变量,以及为什么最好堆积成员而不是堆叠它们.

我已经开始阅读Magnus Lie Hetland的"从新手到专业的初学蟒蛇",今天令我印象深刻的是一个对象创建新成员变量的能力,即使这些成员变量不存在于该对象的类中被"创造"了.这是一个例子:

class Test:
    pass

b = Test()

b.variable1 = 12
b.variable2 = "Jim"

print b.variable1
print b.variable2

到目前为止,我认为对象只能改变父类中存在的成员值,而不能凭空创建新的成员值？顺便说一句,我没有编程或python的先验知识.

struct B
{
  void (B::*pf)(int, int);  // data member
  B () : pf(&B::foo) {}
  void foo (int i, int j) { cout<<"foo(int, int)\n"; } // target method
};

int main ()
{
  B obj;
  // how to call foo() using obj.pf ?
}

在上面的测试代码中,pf是一个数据成员B.调用它的语法规则是什么？它应该是直截了当的,但我没有得到正确的匹配.例如,如果我尝试,obj.*pf(0,0);那么我得到:

error: must use ‘.*’ or ‘->*’ to call pointer-to-member function in ‘pf (...)’, e.g. ‘(... ->* pf) (...)’