當設計開發一個類的時候，程序員通常需要在類的內部定義一些靜態變量。在通常情況下，你會在一個類的頭文件中定義一個靜態變量并在源代碼程序中初始化，如下所示：??


// File.h
class File
{
// . . . code
private:
static char DELIMETER;
}
// File.cpp
char File:ELIMETER = "/";

然而，這一方法并不適用于模板類。模板類通常位于頭文件中。生成一個原文件并沒有太多的用處，因為你不能為所用的模板參數初始化。
// Array.h
template< class T>;
class Array
{
// . . .
private:
// hold all instances of this type (T) in an array
static std::vector< Array< T>; *>; s_aAllInstances;
};
// Array.cpp
// illegal C++
template< class T>;
std::vector< Array< T>; >; Array< T>;::s_aAllInstances;
然而，C++允許靜態函數在模板中操作，而在一個靜態函數中，你可以調用一個靜態變量。
如下所示：
template< class T>;
class Array
{
//...
private:
typedef std::vector< Array< T>;*>; ElementsArray;
static ElementsArray & s_Elements()
{
static ElementsArray s_array;
return s_array;
}
};
這一技巧功能非常強大，因為對于Array< int>;，你必須提供Array< int>;::s_Elements；對于rArray< std::string>;，你必須擔任 Array< std::string>;::s等。

這里你必須完成下面的兩個步驟：

在模板類中必須有一個模板函數(不是變量)；我們建議你以變量名的形式來為它命名。
在模板函數中添加靜態數據。
下面的范例包含了Array< T>;類，這一類在內部里把每一數組定義為類型T。當某一類型被生成或刪除時，它會顯示出數組元素個數及其類型。
#include <vector>;
#include <algorithm>;
#include <iostream>;
template< class T>;
struct Type;
template<>;
struct Type< int>;
{
static const char * name() { return "int"; }
};
template<>;
struct Type< long>;
{
static const char * name() { return "long"; }
};
template<>;
struct Type< std::string>;
{
static const char * name() { return "std::string"; }
};
template<>;
struct Type< float>;
{
static const char * name() { return "float"; }
};
/*
holds internal references to its objects
(of Type T)
*/
template< class T>;
class Array
{
public:
Array()
{ AddMe(); }

Array( const Array &
{ AddMe(); }

~Array()
{ DeleteMe(); }

private:
void AddMe()
{
s_Elements().push_back( this);
std::cout
<< "We have added one element of type "
<< Type< T>;::name() << std::endl;
std::cout
<< "We have now " << s_Elements().size()
<< " " << Type< T>;::name() << " elements" << std::endl;
}

void DeleteMe()
{
ElementsArray::iterator itFound =
std::find( s_Elements().begin(), s_Elements().end(), this);
if ( itFound != s_Elements().end())
{
s_Elements().erase( itFound);
}
std::cout
<< "We have deleted one element of type "
<< Type< T>;::name() << std::endl;
std::cout
<< "We have now " << s_Elements().size()
<< " " << Type< T>;::name() << " elements" << std::endl;
}
private:
// note: we're treating it as an internal variable
typedef std::vector< Array< T>;*>; ElementsArray;
static ElementsArray & s_Elements()
{
static ElementsArray s_array;
return s_array;
}

};

int main(int argc, char* argv[])
{
Array< int>; int1;
Array< int>; int2;
Array< long>; long1;
Array< long>; long2;
Array< std::string>; str1;
Array< std::string>; str2;
Array< float>; float1;
Array< float>; float2;
Array< float>; float3;
Array< int>; int3;
Array< long>; long3;
Array< std::string>; str3;
return 0;
}