Design&Art
C++博客 首页 新随笔 联系 聚合 管理
  26 Posts :: 0 Stories :: 38 Comments :: 0 Trackbacks

#

typename

(zz) C++箴言：理解typename的两个含义

　　问题：在下面的 template declarations（模板声明）中 class 和 typename 有什么不同？
template<class T> class Widget; // uses "class"
template<typename T> class Widget; // uses "typename"
　　答案：没什么不同。在声明一个 template type parameter（模板类型参数）的时候，class 和 typename 意味着完全相同的东西。一些程序员更喜欢在所有的时间都用 class，因为它更容易输入。其他人（包括我本人）更喜欢 typename，因为它暗示着这个参数不必要是一个 class type（类类型）。少数开发者在任何类型都被允许的时候使用 typename，而把 class 保留给仅接受 user-defined types（用户定义类型）的场合。但是从 C++ 的观点看，class 和 typename 在声明一个 template parameter（模板参数）时意味着完全相同的东西。

　　然而，C++ 并不总是把 class 和 typename 视为等同的东西。有时你必须使用 typename。为了理解这一点，我们不得不讨论你会在一个 template（模板）中涉及到的两种名字。

　　假设我们有一个函数的模板，它能取得一个 STL-compatible container（STL 兼容容器）中持有的能赋值给 ints 的对象。进一步假设这个函数只是简单地打印它的第二个元素的值。它是一个用糊涂的方法实现的糊涂的函数，而且就像我下面写的，它甚至不能编译，但是请将这些事先放在一边——有一种方法能发现我的愚蠢：
template<typename C> // print 2nd element in
void print2nd(const C& container) // container;
{ 
　// this is not valid C++!
　if (container.size() >= 2) {
　　C::const_iterator iter(container.begin()); // get iterator to 1st element
　　++iter; // move iter to 2nd element
　　int value = *iter; // copy that element to an int
　　std::cout << value; // print the int
　}
}
　　我突出了这个函数中的两个 local variables（局部变量），iter 和 value。iter 的类型是 C::const_iterator，一个依赖于 template parameter（模板参数）C 的类型。一个 template（模板）中的依赖于一个 template parameter（模板参数）的名字被称为 dependent names（依赖名字）。当一个 dependent names（依赖名字）嵌套在一个 class（类）的内部时，我称它为 nested dependent name（嵌套依赖名字）。C::const_iterator 是一个 nested dependent name（嵌套依赖名字）。实际上，它是一个 nested dependent type name（嵌套依赖类型名），也就是说，一个涉及到一个 type（类型）的 nested dependent name（嵌套依赖名字）。

　　print2nd 中的另一个 local variable（局部变量）value 具有 int 类型。int 是一个不依赖于任何 template parameter（模板参数）的名字。这样的名字以 non-dependent names（非依赖名字）闻名。（我想不通为什么他们不称它为 independent names（无依赖名字）。如果，像我一样，你发现术语 "non-dependent" 是一个令人厌恶的东西，你就和我产生了共鸣，但是 "non-dependent" 就是这类名字的术语，所以，像我一样，转转眼睛放弃你的自我主张。）

　　nested dependent name（嵌套依赖名字）会导致解析困难。例如，假设我们更加愚蠢地以这种方法开始 print2nd：
template<typename C>
void print2nd(const C& container)
{
　C::const_iterator * x;
　//
}
　　这看上去好像是我们将 x 声明为一个指向 C::const_iterator 的 local variable（局部变量）。但是它看上去如此仅仅是因为我们知道 C::const_iterator 是一个 type（类型）。但是如果 C::const_iterator 不是一个 type（类型）呢？如果 C 有一个 static data member（静态数据成员）碰巧就叫做 const_iterator 呢？再如果 x 碰巧是一个 global variable（全局变量）的名字呢？在这种情况下，上面的代码就不是声明一个 local variable（局部变量），而是成为 C::const_iterator 乘以 x！当然，这听起来有些愚蠢，但它是可能的，而编写 C++ 解析器的人必须考虑所有可能的输入，甚至是愚蠢的。

　　直到 C 成为已知之前，没有任何办法知道 C::const_iterator 到底是不是一个 type（类型），而当 template（模板）print2nd 被解析的时候，C 还不是已知的。C++ 有一条规则解决这个歧义：如果解析器在一个 template（模板）中遇到一个 nested dependent name（嵌套依赖名字），它假定那个名字不是一个 type（类型），除非你用其它方式告诉它。缺省情况下，nested dependent name（嵌套依赖名字）不是 types（类型）。（对于这条规则有一个例外，我待会儿告诉你。）

　　记住这个，再看看 print2nd 的开头：
template<typename C>
void print2nd(const C& container)
{
　if (container.size() >= 2) {
　　C::const_iterator iter(container.begin()); // this name is assumed to
　　 // not be a type
　　这为什么不是合法的 C++ 现在应该很清楚了。iter 的 declaration（声明）仅仅在 C::const_iterator 是一个 type（类型）时才有意义，但是我们没有告诉 C++ 它是，而 C++ 就假定它不是。要想转变这个形势，我们必须告诉 C++ C::const_iterator 是一个 type（类型）。我们将 typename 放在紧挨着它的前面来做到这一点：
template<typename C> // this is valid C++
void print2nd(const C& container)
{
if (container.size() >= 2) {
typename C::const_iterator iter(container.begin());

}
}
　　通用的规则很简单：在你涉及到一个在 template（模板）中的 nested dependent type name（嵌套依赖类型名）的任何时候，你必须把单词 typename 放在紧挨着它的前面。（重申一下，我待会儿要描述一个例外。）

　　typename 应该仅仅被用于标识 nested dependent type name（嵌套依赖类型名）；其它名字不应该用它。例如，这是一个取得一个 container（容器）和这个 container（容器）中的一个 iterator（迭代器）的 function template（函数模板）：
template<typename C> // typename allowed (as is "class")
void f(const C& container, // typename not allowed
typename C::iterator iter); // typename required
　　C 不是一个 nested dependent type name（嵌套依赖类型名）（它不是嵌套在依赖于一个 template parameter（模板参数）的什么东西内部的），所以在声明 container 时它不必被 typename 前置，但是 C::iterator 是一个 nested dependent type name（嵌套依赖类型名），所以它必需被 typename 前置。

　　"typename must precede nested dependent type names"（“typename 必须前置于嵌套依赖类型名”）规则的例外是 typename 不必前置于在一个 list of base classes（基类列表）中的或者在一个 member initialization list（成员初始化列表）中作为一个 base classes identifier（基类标识符）的 nested dependent type name（嵌套依赖类型名）。例如：
template<typename T>
class Derived: public Base<T>::Nested { 
　// base class list: typename not
　public: // allowed
　　explicit Derived(int x)
　　: Base<T>::Nested(x) // base class identifier in mem
　　{ 
　　　// init. list: typename not allowed
　
　　　typename Base<T>::Nested temp; // use of nested dependent type
　　　 // name not in a base class list or
　　} // as a base class identifier in a
　　 // mem. init. list: typename required
};
　　这样的矛盾很令人讨厌，但是一旦你在经历中获得一点经验，你几乎不会在意它。

　　让我们来看最后一个 typename 的例子，因为它在你看到的真实代码中具有代表性。假设我们在写一个取得一个 iterator（迭代器）的 function template（函数模板），而且我们要做一个 iterator（迭代器）指向的 object（对象）的局部拷贝 temp，我们可以这样做：
template<typename IterT>
void workWithIterator(IterT iter)
{
　typename std::iterator_traits<IterT>::value_type temp(*iter);
　
}
　　不要让 std::iterator_traits<IterT>::value_type 吓倒你。那仅仅是一个 standard traits class（标准特性类）的使用，用 C++ 的说法就是 "the type of thing pointed to by objects of type IterT"（“被类型为 IterT 的对象所指向的东西的类型”）。这个语句声明了一个与 IterT objects 所指向的东西类型相同的 local variable（局部变量）(temp)，而且用 iter 所指向的 object（对象）对 temp 进行了初始化。如果 IterT 是 vector<int>::iterator，temp 就是 int 类型。如果 IterT 是 list<string>::iterator，temp 就是 string 类型。因为 std::iterator_traits<IterT>::value_type 是一个 nested dependent type name（嵌套依赖类型名）（value_type 嵌套在 iterator_traits<IterT> 内部，而且 IterT 是一个 template parameter（模板参数）），我们必须让它被 typename 前置。

　　如果你觉得读 std::iterator_traits<IterT>::value_type 令人讨厌，就想象那个与它相同的东西来代表它。如果你像大多数程序员，对多次输入它感到恐惧，那么你就需要创建一个 typedef。对于像 value_type 这样的 traits member names（特性成员名），一个通用的惯例是 typedef name 与 traits member name 相同，所以这样的一个 local typedef 通常定义成这样：
template<typename IterT>
void workWithIterator(IterT iter)
{
　typedef typename std::iterator_traits<IterT>::value_type value_type;

　value_type temp(*iter);
　
}
　　很多程序员最初发现 "typedef typename" 并列不太和谐，但它是涉及 nested dependent type names（嵌套依赖类型名）规则的一个合理的附带结果。你会相当快地习惯它。你毕竟有着强大的动机。你输入 typename std::iterator_traits<IterT>::value_type 需要多少时间？

　　作为结束语，我应该提及编译器与编译器之间对围绕 typename 的规则的执行情况的不同。一些编译器接受必需 typename 时它却缺失的代码；一些编译器接受不许 typename 时它却存在的代码；还有少数的（通常是老旧的）会拒绝 typename 出现在它必需出现的地方。这就意味着 typename 和 nested dependent type names（嵌套依赖类型名）的交互作用会导致一些轻微的可移植性问题。

　　Things to Remember

　　·在声明 template parameters（模板参数）时，class 和 typename 是可互换的。

　　·用 typename 去标识 nested dependent type names（嵌套依赖类型名），在 base class lists（基类列表）中或在一个 member initialization list（成员初始化列表）中作为一个 base class identifier（基类标识符）时除外。

posted @ 2007-04-16 15:27 安帛伟 阅读(418) | 评论 (0) | 编辑 收藏

VC6下使用STLPort
为了使用hash_map，今天下载了STLport，在VC6下编译成功。

1. STLport下载：http://www.stlport.org/
      我下载的是最新版  02.25.07: STLport 5.1.2 released

2. STLport编译：
      我的STLport目录是：D:\STLport-5.1.2
      先设置一下VC6下的环境变量：C:\Program Files\Microsoft Visual Studio\VC98\Bin\VCVARS32.BAT
     把D:\STLport-5.1.2\stlport;加入Include路径中；把D:\STLport-5.1.2\lib;加入Lib路径中
      在命令行窗口下：
      运行VCVARS32.BAT，然后
      cd D:\STLport-5.1.2\build\lib
      configure -c msvc6
      nmake /fmsvc.mak install
      编译全部用的默认选项，因此编译出来的是多线程静态链接库。库文件被拷贝到D:\STLport-5.1.2\lib

3. 在VC6中使用STLport：
      Tools->Options...->Directories中
      include设置中添加目录：D:\STLport-5.1.2\stlport
      library设置中添加目录：D:\STLport-5.1.2\lib
      Project->Settings...->C/C++中
      Category选择Code Generation，然后在use run-time library中选择Debug Multithreaded。（如果是release版本，选择Multithreaded；如果想用动态链接，则要先编译动态链接版本的STLport，再在这儿选择相应的DLL）

4. hash_map的例子：
#include <iostream>
#include <hash_map>
#include <string>

using namespace std;

int main()
{
    hash_map<int, string> mymap;
    mymap[2008]="VC6";
    mymap[999999]="STLport";
    mymap[123456]="hello hash_map!";
    hash_map<int, string>::iterator iter = mymap.find(123456);
    if(iter != mymap.end())
    {
        cout<<iter->second<<endl;
    }
    return 0;
}
posted @ 2007-04-16 14:22 安帛伟 阅读(8277) | 评论 (21) | 编辑 收藏

Visual C++ Toolkit 2003 下载

现在在 Visual C++ Toolkit 2003 的主页上，下载链接已经被去掉，转而劝告人们使用 Visual C++ 2005 Express。
VCToolkitSetup.exe
下载

http://xona.com/programs/VCToolkitSetup%28v1.01%29%282004.07.06%29.zip
MD5: 90D8B963CA196AA9855B2CA6C3174C14
posted @ 2007-04-13 17:05 安帛伟 阅读(4171) | 评论 (6) | 编辑 收藏

explicit

我们在编写应用程序的时候explicit关键字基本上是很少使用,它的作用是"禁止单参数构造函数"被用于自动型别转换,其中比较典型的例子就是容器类型,在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数.
例如:
你可以声明这样一个构造函数

class Array
{
public:
 explicit Array(int size);
 //
};
在这里explicit关键字起着至关重要的作用,如果没有这个关键字的话,这个构造函数有能力将int转换成Array.一旦这种情况发生,你可以给Array支派一个整数值而不会引起任何的问题,比如:
Array arr;
//
arr = 40;
此时,C++的自动型别转换会把40转换成拥有40个元素的Array,并且指派给arr变量,这个结果根本就不是我们想要的结果.如果我们将构造函数声明为explicit,上面的赋值操作就会导致编译器报错,使我们可以及时发现错误.
需要注意的是:explicit同样也能阻止"以赋值语法进行带有转型操作的初始化";
例如:
Array arr(40);//正确
Array arr = 40;//错误 
看一下以下两种操作:
X x;
Y y(x);//显式类型转换
另一种
X x;
Y y = x;//隐式类型转换
这两种操作存在一个小小的差别,第一种方式式通过显式类型转换,根据型别x产生了型别Y的新对象;第二种方式通过隐式转换产生了一个型别Y的新对象.
explicit关键字的应用主要就是上面所说的构造函数定义中,参考该关键字的应用可以看看STL源代码,其中大量使用了该关键字
posted @ 2007-04-12 11:09 安帛伟 阅读(366) | 评论 (0) | 编辑 收藏

mutable

关键字mutable是C++中一个不常用的关键字,他只能用于类的非静态和非常量数据成员
我们知道一个对象的状态由该对象的非静态数据成员决定,所以随着数据成员的改变,
对像的状态也会随之发生变化!
如果一个类的成员函数被声明为const类型,表示该函数不会改变对象的状态,也就是
该函数不会修改类的非静态数据成员.但是有些时候需要在该类函数中对类的数据成员
进行赋值.这个时候就需要用到mutable关键字了

例如:

class Demo
{
public:
    Demo(){}
    ~Demo(){}
public:
    bool getFlag() const
    {
        m_nAccess++;
        return m_bFlag;
    }
private:
    int  m_nAccess;
    bool m_bFlag;
}; 

int main()
{
    return 0;
} 


编译上面的代码会出现 error C2166: l-value specifies const object的错误
说明在const类型的函数中改变了类的非静态数据成员.

这个时候需要使用mutable来修饰一下要在const成员函数中改变的非静态数据成员
m_nAccess,代码如下:

class Demo
{
public:
    Demo(){}
    ~Demo(){}
public:
    bool getFlag() const
    {
        m_nAccess++;
        return m_bFlag;
    }
private:
    mutable int  m_nAccess;
    bool m_bFlag;
}; 

int main()
{
    return 0;
} 

这样再重新编译的时候就不会出现错误了!
posted @ 2007-04-12 10:50 安帛伟 阅读(294) | 评论 (0) | 编辑 收藏

工厂方法和抽象工厂

工厂方法和抽象工厂实际上是从不同角度在描述问题。
工厂方法描述了具体产品的创建，而抽象工厂描述的是产品系列的组织。

//  Computer.cpp : Defines the entry point for the console application.
 //
#include  " stdafx.h "
#include  < string >
#include  < iostream >

using   namespace  std;

 class  Ram {} ;
 class  IBMRam:  public  Ram {} ;
 class  HPRam:  public  Ram {} ;
 class  Cpu {} ;
 class  IBMCpu:  public  Cpu {} ;
 class  HPCpu:  public  Cpu {} ;

 class  Computer
 {
 public :
 Computer( string  strName, Ram *  pRam, Cpu *  pCpu)
  {
  m_strName  =  strName;
  m_pRam  =  pRam;
  m_pCpu  =  pCpu;
  cout << " A  " <<  m_strName  << "  computer is produced " << endl;
 }
  ~ Computer()
  {
  delete m_pRam;
  delete m_pCpu;
  cout << " A  " <<  m_strName  << "  computer is deleted " << endl;
 }
public :
  string  m_strName;
 private :
 Ram *  m_pRam;
 Cpu *  m_pCpu;
} ;

 class  ComputerProducer
 {
 public :
 Computer *  createComputer()
  {
   return   new  Computer(setName(), createRam(), createCpu());
 }
  virtual  Ram *  createRam()  =   0 ;
  virtual  Cpu *  createCpu()  =   0 ;
  virtual   string  setName()  =   0 ;
} ;

 class  IBMProducer:  public  ComputerProducer
 {
 public :
  virtual  Ram *  createRam()
  {
  cout << " A IBMRam is producted " << endl;
   return   new  IBMRam;
 }
  virtual  Cpu *  createCpu()
  {
  cout << " A IBMCPU is producted " << endl;
   return   new  IBMCpu;
 }
  virtual   string  setName()
  {
   return   string ( " IBM " );
 }
} ;

 class  HPProducer:  public  ComputerProducer
 {
 public :
  virtual  Ram *  createRam()
  {
  cout << " A HPRam is producted " << endl;
   return   new  HPRam;
 }
  virtual  Cpu *  createCpu()
  {
  cout << " A HPCPU is producted " << endl;
   return   new  HPCpu;
 }
  virtual   string  setName()
  {
   return   string ( " HP " );
 }
} ;

 int  main( int  argc,  char *  argv[])
 {
  //  client code
 ComputerProducer *  pIBMFac =   new  IBMProducer;
 ComputerProducer *  pHPFac  =   new  HPProducer;
 Computer *  pIBMComputer  =  pIBMFac -> createComputer();
 Computer *  pHPComputer  =  pHPFac  -> createComputer();
 delete pIBMComputer;
 delete pHPComputer;
 delete pIBMFac;
 delete pHPFac;
  return   0 ;
}

这个例子比较清楚了，不同的工厂生产不同的计算机，但计算机的基本组成(这里假设计算机仅由ram和cpu组成)是一样的，这样的产品系列很适合用抽象工厂来组织。
而在实际生产计算机的时候，createRam()和createCpu()这两个工厂方法又起到了作用。

posted @ 2007-03-25 23:20 安帛伟 阅读(1086) | 评论 (0) | 编辑 收藏

仅列出标题
共3页: 1 2 3