标签: static-members

有没有更好的方法在C#中获取静态DateTime值而不是以下？

public static DateTime StartOfRecordedHistory = DateTime.Parse("2004-01-01");

谢谢!

首先,我会写一些例子来正确解决这个问题.

首先,我将声明用于创建单例对象的模板(不是自动创建的): singleton_base.h

template <class Derived>
class SingletonBase
{
  public:
    static Derived* instance() { assert(s_instance); return dynamic_cast<Derived*>(s_instance); }
  protected:
    SingletonBase() { assert(s_instance==0); s_instance=this; }
    virtual ~SingletonBase() { assert(s_instance); s_instance=0; }
  private:
    static SingletonBase* s_instance;
};

template <class Derived>
SingletonBase<Derived>* SingletonBase<Derived>::s_instance = 0;

现在我们可以声明从模板派生的任何类,并且每个派生类都应该有自己的s_instance.例如:

child1.h

class Child1 : public SingletonBase<Child1>
{
  ...
  void doSomething();
  static void staticInvokeOne();
};

child2.h

class Child2 : public SingletonBase<Child2>
{
  ...
  void doSomethingElse();
  static void staticInvokeBoth();
};

我也分别在child1.cpp和child2.cpp中实现了Child的实现.

child1.cpp

void Child1::staticInvokeOne()
{ …

所以我最近发现了一些使用特定技术的源代码(成语？)我以前没见过; 简而言之; 它不是使用相关类的静态变量,而是在类源文件中使用局部变量.

myclass.h

class myclass {
    //static int myint;

public:
    myclass();
    ~myclass();
    int count();
};

myclass.cpp

#include "myclass.h"

int myint = 0;

myclass::myclass() {
    myint++;
}
myclass::~myclass() {
    myint--;
}

int myclass::count() {
    return myint;
}

main.cpp中

#include "myclass.h"
#include <iostream>

int main() {
    myclass aclass;
    myclass theclass;

    std::cout << theclass.count(); //outputs 2
    return 0;
}

我的问题是,为什么有人会采用这种方法而不是使用静态变量？

我对它的看法是,理想情况下,变量只能为myclass类(私有静态)所知,并且继承根本不重要(在这种情况下),这可能会阻止其他人知道这个变量.但这是我能看到的唯一优势; 不确定这是否值得保证.

同样的问题适用于私有的(静态/非静态)成员函数; 当继承不重要时.

编辑:读完之后,我要做的是因为有些人仍然使用C编程风格...

在下面的代码中,我假设成员变量mBar只在第一次构造Foo对象时被实例化......并且该mBar实例化将与所有未来的Foo对象共享,但Bar()不会再次调用构造函数.这准确吗？

public class Foo {
  private static Bar mBar = new Bar();

  public Foo() {

  }

我知道在java中静态方法只能使用静态变量和静态方法,但非静态方法可以使用非静态变量和方法.有没有解释为什么静态方法只能访问静态变量/方法？并且无法访问非静态方法和变量？

我们知道,可以在类结构中初始化整数const静态成员.这在初始化后在类结构中使用常量时很有用.例如,它可以用作int数组的大小.查看以下代码:

class MyClass{
static const int num = 100;
int elems[num];
...
};

但是我们仍然需要在类定义之外定义成员num:

const int MyClass::num;

我不知道为什么我们要这样做.有人能告诉我为什么吗？非常感谢.

另外,我写了以下代码:

#include <iostream>
using namespace std;

class MyClass{
public:
MyClass()
{
    cout << "instruct class MyClass!" << endl;
}
static const int num = 100;
int elems[num];
};

//const int MyClass::num;

int main()
{
MyClass a;
const int *b = &(a.num);
cout << "&(a.num): " << &(a.num) << endl;
cout << "a.num: " << a.num << endl;
cout << "*b: …

我有以下类实现必须使用单个全局数组的静态方法.它定义如下:

//Defined in LockTrack.h file

enum LOCK_ID{
    LOCKID_0,
    LOCKID_1,
    LOCKID_2,

    LOCKID_COUNT
};

static LOCK_ID __glob_lock_ids[LOCKID_COUNT];


class CLockTrack
{
public:
    static void getLockedLocks(/*parameters*/)
    {
        //__glob_lock_ids = points to 0x015ef558 address in memory
        LOCK_ID lockID = __glob_lock_ids[0];
    }

    static void inline setLock(LOCK_ID lockID)
    {
        //__glob_lock_ids = points to 0x015ef330 address in memory
        __glob_lock_ids[lockID] = LOCK_ON_FLAG;
    }
};

但是会发生的是'__glob_lock_ids'指针指向每种方法中的不同内存位置.为什么？以及如何解决这个问题？

我有一个包含静态字典的类:

class MyClass:
    my_dict = {}
    def __init__(self, name):
        self.name = name
        MyClass.my_dict[self.name] = []
    def __call__(self, data):
        MyClass.my_dict[self.name].append(data)

每当我想要更新字典时,我都必须使用MyClass.my_dict[key],但我希望类本身能够支持项目分配,所以我可以MyClass[key]用来做同样的事情.有没有办法做到这一点？我正在使用Python 2.7.

#include<iostream>
using namespace std;

class sample {
    public:
        static int x;
};

//int sample::x = 20;

int main() {
    sample s1;
    int sample::x = 30;
}

当我编译这个程序然后得到一个错误无效使用限定名称'sample :: x'

我知道我收到此错误是因为这个语句是int sample :: x = 30; 在主要.

但我不明白为什么我不能定义 int sample :: x = 30; 在主？

举个例子：

SomeClass.h

class Foo {
public:
    static int bar;
    int x;
    void someFunc() {
        this->x = 5;
        this->bar = 9;
    }
};

SomeClass.cpp

int Foo::bar = 0;

mainc.pp

#include <iostream>
#include "SomeClass.h"

int main() {
    Foo f;
    f.someFunc();

    std::cout << "f.x = " << f.x << '\n';
    std::cout << "f.bar = " << f.bar << '\n';
    return 0;
}

使用Visual Studio 2017CE编译和构建。

输出量

f.x = 5
f.bar = 9

但是根据cppreference：static

类的静态成员不与该类的对象关联：它们是具有静态或线程（自C ++ 11起）存储持续时间或常规函数的自变量。

现在，对于静态成员函数，它们声明：

静态成员函数不与任何对象关联。调用时，它们没有此指针。

我只想对此有所澄清：我以为静态成员和静态函数成员都没有this与之关联的指针...