我有一个带有常量静态变量a的基类A. 我需要B类的实例对静态变量a有不同的值.如何实现这一点,最好是使用静态初始化？
class A {
public:
static const int a;
};
const int A::a = 1;
class B : public A {
// ???
// How to set *a* to a value specific to instances of class B ?
};
public class Main {
static int x = Main.y;
// static int x = y; //Not allowed; y is not defined
static int y = x;
public static void main(String[] args) {
System.out.println(x);//prints 0
}
}
为什么我被允许在课堂上使用,但不能直接使用？
什么时候定义？
我理解(我认为)Ruby中类的类变量和实例变量之间的区别.
我想知道如何从OUTSIDE那个类访问类的实例变量.
从内部(即在类方法而不是实例方法中),它可以直接访问,但是从外部,有没有办法MyClass.class.[@$#]variablename呢？
我没有任何具体的理由这样做,只是学习Ruby并想知道它是否可行.
我想知道如何做到这一点:
package Something;
our $secret = "blah";
sub get_secret {
my ($class) = @_;
return; # I want to return the secret variable here
}
我什么时候去
print Something->get_secret();
我想要它打印blah.现在在你告诉我使用之前$secret,我想确保如果派生类使用Something作为基础,我打电话给get_secret我应该让那个类'秘密.
你如何使用包变量引用$class？我知道我可以使用,eval但有更优雅的解决方案吗？
我想将类的一些信息存储为类(静态)变量.但是,我无法弄清楚这些东西是如何初始化的.这是一个基本的,愚蠢的例子:
class A(object):
clsVar = 'a'
@classmethod
def clsMeth(cls):
print 'changing clsVar'
cls.clsVar = 'b'
A.clsMeth()
# prints 'changing clsVar'
print A.clsVar # prints 'a'
A.clsVar = 'b'
print A.clsVar # prints 'b'
由于调用了函数(因为print语句有效),为什么类变量不会保持更改？如果在类定义完成后我不想这样做,我是否必须使用元类？
[具体来说,我想clsMeth成为一个装饰器,让类变量成为所有装饰的函数列表.我猜这不是实现这一目标的正确方法,所以我继续前进,但我仍然很好奇.
编辑:正如许多人所指出的,上面的代码将无法运行.我在IPython会话中运行它,其中调用A.clsMeth()将引用以前的版本A并运行.我想这就是使用解释性语言的风险.我结束了这样的事情:
outsideDict = {}
def outsideDec(func):
outsideDict[func.__name__] = func
class A(object):
@outsideDec
def someMethod(self):
print 'ID %s' % id(self)
def otherMethod(self):
print 'other'
print outsideDict
one, two = A(), A()
outsideDict['someMethod'](one)
outsideDict['someMethod'](two)
也许这应该是另一个问题,但是当outsideDec运行时,有没有办法告诉它的论证是什么类？或者,有没有更好的方法在Python中进行这样的内省？我知道我在这里偏离正轨,所以我会接受下面的答案并做更多的研究.感谢大家!
我static final class variable和之间有一些混淆final instance variable.
以下是示例代码: -
class Foof{
final int size=3;
final int whuffie;
Foof()
{
whuffie=42;
}
public static void main(String [] args){
Foof obj1 = new Foof();
Foof obj2 = new Foof();
obj1.size=53; //compile time error
System.out.println(obj1.size);
obj2.whuffie=45; //compile time error
System.out.println(obj2.whuffie);
}
}
错误:-
ankit@stream:/home/Data/JAVA/practice/src/test.com/test-20121031_static_demystified$ javac Foof.java
Foof.java:14: error: cannot assign a value to final variable size
obj1.size=53; //compile time error
^
Foof.java:16: error: cannot assign a value to final variable …我有一些常量只需要在编译时使用来简化代码,所以我不需要在运行时可用的实际变量.
传统上这样做的方式是,#define NAME 123但我想要一个类型安全的替代品.
在课程之外你可以const int name = 123;正常工作,但似乎不可能把它放在一个类中.例如:
class Example {
public:
const double usPerSec = 1000000.0;
};
double usOneMinute = 60 * Tempo::usPerSec;
使用Visual C++,但不适用于GCC:
error: non-static const member ‘const double Example::usPerSec’,
can’t use default assignment operator
您可以通过使其静态来修复它,但随后Visual C++抱怨:
error C2864: 'Example::usPerSec' : a static data member with an in-class
initializer must have non-volatile const integral type
type is 'const double'
我猜这意味着VC++只会接受static const int.
我想避免在构造函数中设置值,因为我在运行时需要一个类的实例来访问该值,而实际上我希望它在编译时像处理它一样处理#define.
那么如何将一个常量定义为double类的内部,而不是使其成为全局或使用#define,这将在没有类的实例的情况下工作,并且将与主要的C++ …
可以说我有这样的功能:
void processElement() {
doSomething(someArray[lastProcessedElement + 1]);
}
问题是,每次调用此函数时,我都需要存储我调用doSomething的最后一个元素.所以在这里我有两个选择:
我可以创建一个名为lastProcessedElement的私有类变量,并在每次调用该函数时递增它的值.这种方法似乎最常见.所以代码可以是这样的:
class Foo {
int lastProcessedElement = 0;
public:
void processElement() {
doSomething(someArray[++lastProcessedElement]);
}
}
作为第二个选项,我可以在函数中创建一个静态变量并每次递增它:
// Class is not important here, so the function is:
void processElement() {
static int lastProcessedElement = 0;
doSomething(someArray[++lastProcessedElement]);
}
第一个解决方案增加了一些我不想要的复杂性.我喜欢把东西放在原地.
我知道第二个解决方案只有在该类只有一个实例时才有效.
那么使用静态变量法是一个很好的解决方案？是否有多实例类的在线解决方案？(可以有一个解决这个特定的数组元素索引的东西,但我刚刚做了,我说的是为函数的下一次调用存储一些值)
我读到在类命名空间中创建变量然后在类构造函数中更改其值被认为是不好的做法。
（我的一个来源：SoftwareEngineering SE：在 Python 的类中将实例变量声明为 None 是一种好习惯。）
考虑以下代码：
# lib.py
class mixin:
def __init_subclass__(cls, **kwargs):
cls.check_mixin_subclass_validity(cls)
super().__init_subclass__(**kwargs)
def check_mixin_subclass_validity(subclass):
assert hasattr(subclass, 'necessary_var'), \
'Missing necessary_var'
def method_used_by_subclass(self):
return self.necessary_var * 3.14
# app.py
class my_subclass(mixin):
necessary_var = None
def __init__(self, some_value):
self.necessary_var = some_value
def run(self):
# DO SOME STUFF
self.necessary_var = self.method_used_by_subclass()
# DO OTHER STUFF
为了强制其子类声明变量required_var，该类mixin使用元类subclass_validator。
我所知道的让它同时工作的唯一方法app.py是将必要的变量初始化为类变量。
我错过了什么还是这是唯一的方法？
我有一个类层次结构，其中一些方法使用在类级别定义的属性列表。
假设对于A我拥有A.X = [propA1, propA2]的类和C我需要的子类C.X = [propA1, propA2, propC]。子类从父类继承属性，因此编写类方法是有意义的super()调用的，每个都使用自己类的属性。
然而，这有点麻烦。我可以在基类中的单个方法中处理所有属性。因此，为每个子类定义一个包含一组新属性的类变量并手动向下执行确实感觉更自然cls.__mro__检索所有属性。
我想出的（下面）似乎相对透明地工作，但它是惯用的吗？是否有更典型的编码模式？有没有办法避免装饰所有子类？
class Base(object):
pass
class InheritClassVariable:
def __init__(self, var, base):
self.var = var
self.base = base
def __call__(self, cls):
name = self.var
uname = '_' + name
bases = [B for B in cls.__mro__ if issubclass(B, self.base)]
setattr(cls, uname, getattr(cls, name, []))
value = [item for B in bases for item in getattr(B, uname, [])]
setattr(cls, name, value) …