如何創建類的靜態對象成員？

Question

我對c ++很新，特別是在它的技術方面。 我的問題是，如何創建類本身的靜態對象成員。 我的意思是我在類中聲明了一個靜態成員對象。 例：

CFoo:CFoo *pFoo[2] = {0};

class CFoo
{
   public: static CFoo *pFoo[2];
   public: CFoo(int a);
   public: CFoo *getFoo();
};

現在的問題是，如何創建pFoo，就像我想創建兩個靜態對象pFoo一樣，

pFoo[0] = new CFoo(0);
pFoo[1] = new CFoo(1);

這樣我就可以使用getFoo方法返回一個pFoo，比如

CFoo *getFoo()
{
   return pFoo[0]; //or pFoo(1);
}

非常感謝你們。 希望我的問題很清楚。

再次感謝您的提前。 -sasayins

Answer 1

讓我們一步一步改進您的代碼。 我將解釋我在每一步所做的事情。

第1步，這不是Java。 您不需要為每個成員指定公共。 public:后的所有內容public:在您指定其他內容（ protected或private ）之前是公開的。 我在pFoo也pFoo的定義。 在聲明變量之前，您無法定義變量。

class CFoo
{
   public: 
      static CFoo *pFoo[2];
      CFoo(int a);
      CFoo *getFoo();
};

CFoo* CFoo::pFoo[2] = {0};

第2步，如果您要使用getFoo成員函數， pFoo可能不應該是公共的。 讓我們強制實現類的接口 ，而不是暴露內部數據。

class CFoo
{
   public: 
      CFoo(int a);
      CFoo *getFoo();

   private:
      static CFoo *pFoo[2];
};

CFoo* CFoo::pFoo[2] = {0};

第3步，你可以通過指針返回而不必費心去使用new 。 我已經編寫了多年的C ++代碼，我必須查找如何delete為靜態成員變量新建的內存。 找出它是不值得的麻煩，所以讓我們把它們分配到堆棧上。 另外，讓我們通過const指針返回它們，以防止用戶意外修改兩個static CFoo對象。

class CFoo
{
   public: 
      CFoo(int a);
      const CFoo *getFoo();

   private:
      static CFoo foos[2];
};

CFoo CFoo::foos[2] = {CFoo(0), CFoo(1)};

然后getFoo的實現變為：

const CFoo * CFoo::getFoo()
{
   return &foos[0];  // or &foos[1]
}

IIRC，靜態成員foos將在您第一次創建CFoo對象時分配。 那么，這段代碼......

CFoo bar;
const CFoo *baz = bar.getFoo();

...是安全的。 名為baz的指針將指向靜態成員foos[0] 。

Answer 2

你不需要這里的指針。 事實上，他們可能不是一個好主意。

以下代碼適用於我：

#include <iostream>

struct Foo {
    static Foo const foos[];

    Foo(int i) : i(i) { }

    int i;
};

Foo const Foo::foos[2] = { Foo(1), Foo(2) };

using namespace std;

int main() {
    cout << Foo::foos[0].i << endl;
}

（請注意（為了保持演示簡單）我已將所有成員public ，這可能不是您想要的。它與私有成員一樣。）

Answer 3

要初始化您的數組，您應該寫這個：

CFoo* CFoo::pFoo [2] = { new CFoo(0), new CFoo(1) };

不要釋放以這種方式分配的內存。

Answer 4

有幾種方法可以做到這一點。 一個就是繼續做你正在做的事情並像這樣初始化pFoo數組

// In source file (not header)
CFoo* CFoo::pFoo[2] = {new CFoo(1), new CFoo(2)};

但我建議將它們包裝在這樣的存取器中：

// In header
class CFoo 
{
public:
  CFoo(int a);
  CFoo* getFoo1() const;
  CFoo* getFoo2() const;

private:
  static CFoo* getFoo(int n);
};

// In source file

CFoo::CFoo(int a)
{
 // Constructor implementation
}

CFoo* CFoo::getFoo1() const
{
  return getFoo(1);
}

CFoo* CFoo::getFoo2() const
{
  return getFoo(2);
}

CFoo* CFoo::getFoo(int n)
{
  static CFoo* pFoo[2] = {new Foo(1), new Foo(2)}; 
  return pFoo[n];
}

主要原因是這繞過了靜態初始化命令fiasco。 當你在一個類中有一個靜態變量時，它在初始化時有點不確定，這是危險的，特別是當變量是公共的時。 在訪問器中進行包裝意味着在首次調用訪問器時將初始化變量，因此在嘗試使用它之前，您將知道它已初始化。 如果它暫時不使用或根本沒有使用，你還可以獲得延遲初始化的好處。

上面的代碼不是線程安全的，但我懷疑你在這里使用線程。

此外，您應該檢查您的編碼風格。 使用C前綴類是一種有點過時的做法，在每個公共函數之前放置“public：”是奇怪的，你只需要編寫一次。