CPP Blog

C++博客 首页 新随笔 联系 聚合 管理
  10 Posts :: 0 Stories :: 0 Comments :: 0 Trackbacks

2010年2月18日 #

How to delete element from Vector:

There is tricky thing for deleting in vector loop.

The erase method returns the next element after the one you just erased. So you can use that to continue in your loop.

vector c;
iterator i = c.begin();
     while(i != c.end()){
          if (i == something)
          {
                //i = i.erase();
                 i = c.erase(i);
          } else {
               i++;
          }
}

OR:

vector c;
for(vector<type>::iterator i=c.begin(); i != c.end(); )
{
     if (some condition)
     {
           //i = i.erase();
             i = c.erase(i);
     }
     else
       ++i;
}




posted @ 2010-02-18 06:02 SimonHan 阅读(735) | 评论 (0)编辑 收藏

2010年2月11日 #

总结C++中的所有强制转换函数(const_cast,reinterpret_cast,static_cast,dynamic_cast)

C 风格(C-style)强制转型如下:

(T) expression // cast expression to be of type T

函数风格(Function-style)强制转型使用这样的语法:

T(expression) // cast expression to be of type T

这两种形式之间没有本质上的不同,它纯粹就是一个把括号放在哪的问题。我把这两种形式称为旧风格(old-style)的强制转型。

使用标准C++的类型转换符:static_cast、dynamic_cast、reinterpret_cast、和const_cast。

3.1 static_cast
用法:static_cast  < type-id >  ( expression )     
该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:
①用于类层次结构中基类和子类之间指针或引用的转换。
进行上行转换(把子类的指针或引用转换成基类表示)是安全的;
进行下行转换(把基类指针或引用转换成子类表示)时,由于没有动态类型检查,所以是不安全的。
②用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。这种转换的安全性也要开发人员来保证。
③把空指针转换成目标类型的空指针。
④把任何类型的表达式转换成void类型。

注意:static_cast不能转换掉expression的const、volitale、或者__unaligned属性。


3.2 dynamic_cast
用法:dynamic_cast  < type-id >  ( expression )
该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *;
如果type-id是类指针类型,那么expression也必须是一个指针,如果type-id是一个引用,那么expression也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换。
在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;
在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。
class B{
public:
       int m_iNum;
       virtual void foo();
};

class D:public B{
    public:
       char *m_szName[100];
};

void func(B *pb){
    D *pd1 = static_cast <D *> (pb);
    D *pd2 = dynamic_cast <D *> (pb);
}

在上面的代码段中,如果pb指向一个D类型的对象,pd1和pd2是一样的,并且对这两个指针执行D类型的任何操作都是安全的;
但是,如果pb指向的是一个B类型的对象,那么pd1将是一个指向该对象的指针,对它进行D类型的操作将是不安全的(如访问m_szName),
而pd2将是一个空指针。

另外要注意:B要有虚函数,否则会编译出错;static_cast则没有这个限制。
这是由于运行时类型检查需要运行时类型信息,而这个信息存储在类的虚函数表(
关于虚函数表的概念,详细可见 <Inside c++ object model> )中,只有定义了虚函数的类才有虚函数表,
没有定义虚函数的类是没有虚函数表的。

另外,dynamic_cast还支持交叉转换(cross cast)。如下代码所示。
class A{
public:
        int m_iNum;
        virtual void f(){}
};

class B:public A{
};

class D:public A{
};

void foo(){
    B *pb = new B;
    pb-> m_iNum = 100;

    D *pd1 = static_cast <D *> (pb);    //compile error
    D *pd2 = dynamic_cast <D *> (pb); //pd2 is NULL
    delete pb;
}

在函数foo中,使用static_cast进行转换是不被允许的,将在编译时出错;而使用 dynamic_cast的转换则是允许的,结果是空指针。


3.3 reinpreter_cast
用法:reinpreter_cast <type-id>  (expression)
type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
它可以把一个指针转换成一个整数,也可以把一个整数转换成一个指针(先把一个指针转换成一个整数,
在把该整数转换成原类型的指针,还可以得到原先的指针值)。

该运算符的用法比较多。

3.4 const_cast
用法:const_cast <type_id>  (expression)
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外, type_id和expression的类型是一样的。
常量指针被转化成非常量指针,并且仍然指向原来的对象;
常量引用被转换成非常量引用,并且仍然指向原来的对象;常量对象被转换成非常量对象。

Voiatile和const类试。举如下一例:
class B{
public:
     int m_iNum;
}
void foo(){
const B b1;
b1.m_iNum = 100;            //comile error
B b2 = const_cast <B> (b1);
b2. m_iNum = 200;           //fine
}
上面的代码编译时会报错,因为b1是一个常量对象,不能对它进行改变;
使用const_cast把它转换成一个常量对象,就可以对它的数据成员任意改变。注意:b1和b2是两个不同的对象。

== ===========================================

== dynamic_cast .vs. static_cast
== ===========================================

class B { ... };
class D : public B { ... };

void f(B* pb)
{

D* pd1 = dynamic_cast <D*> (pb);

D* pd2 = static_cast <D*> (pb);
}

If pb really points to an object of type D, then pd1 and pd2 will get the same value. They will also get the same value if pb == 0.

If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return zero. However, static_cast relies on the programmer’s assertion that pb points to an object of type D and simply returns a pointer to that supposed D object.

即dynamic_cast可用于继承体系中的向下转型,即将基类指针转换为派生类指针,比static_cast更严格更安全。 dynamic_cast在执行效率上比static_cast要差一些,但static_cast在更宽上范围内可以完成映射,这种不加限制的映射伴随 着不安全性。static_cast覆盖的变换类型除类层次的静态导航以外,还包括无映射变换、窄化变换(这种变换会导致对象切片,丢失信息)、用 VOID*的强制变换、隐式类型变换等...


== ===========================================
== static_cast .vs. reinterpret_cast
== ================================================

reinterpret_cast是为了映射到一个完全不同类型的意思,这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的,这是所有映射中最危险的。(这句话是C++编程思想中的原话)

static_cast 和 reinterpret_cast 操 作符修改了操作数类型。它们不是互逆的; static_cast 在编译时使用类型信息执行转换,在转换执行必要的检测(诸如指针越界计算, 类型检 查). 其操作数相对是安全的。另一方面;reinterpret_cast 仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换, 例子如下:

int n=9; double d=static_cast  < double >  (n);

上面 的例子中, 我们将一个变量从 int 转换到 double。 这些类型的二进制表达式是不同的。 要将整数 9 转换到 双精度整 数 9,static_cast 需要正确地为双精度整数 d 补足比特位。其结果为 9.0。而reinterpret_cast 的行为却不同:

int n=9;

double d=reinterpret_cast <double & >  (n);

这次, 结果有所不同. 在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析.

因此, 你需要谨慎使用 reinterpret_cast.
#
# 标准c++中主要有四种强制转换类型运算符:  
#   
# const_cast,reinterpret_cast,static_cast,dynamic_cast等等。  
#   
#   
#   
#   
# 1)static_cast <T*> (a)  
#   
# 将地址a转换成类型T,T和a必须是指针、引用、算术类型或枚举类型。  
#   
# 表达式static_cast <T*> (a), a的值转换为模板中指定的类型T。在运行时转换过程中,不进行类型检查来确保转换的安全性。  
#   
#   
#   
#   
# 例子:  
#   
#   
#   
#   
# class B { ... };  
#   
# class D : public B { ... };  
#   
# void f(B* pb, D* pd)  
#   
# {  
#   
#     D* pd2 = static_cast <D*> (pb);        // 不安全, pb可能只是B的指针  
#   
#   
#   
#   
#     B* pb2 = static_cast <B*> (pd);        // 安全的  
#   
#     ...  
#   
# }  
#   
#

# 2)dynamic_cast <T*> (a)  
#   
# 完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。  
#   
# 表达式dynamic_cast <T*> (a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型,该操作将返回一个空指针。  
#   
#   
#   
#   
# 例子:  
#   
# class A { ... };  
#   
# class B { ... };  
#   
# void f()  
#   
# {  
#   
#    A* pa = new A;  
#   
#    B* pb = new B;  
#   
#   void* pv = dynamic_cast <A*> (pa);  
#   
#   // pv 现在指向了一个类型为A的对象  
#   
#    ...  
#   
#    pv = dynamic_cast <B*> (pb);  
#   
#   // pv 现在指向了一个类型为B的对象  
#   
# }  
#   
#   
#   
#   
# 3)const_cast <T*> (a)  
#   
# 去掉类型中的常量,除了const或不稳定的变址数,T和a必须是相同的类型。  
#   
# 表达式const_cast <T*> (a)被用于从一个类中去除以下这些属性:const, volatile, 和 __unaligned。  
#   
#   
#   
#   
# 例子:  
#   
#   
#   
#   
#   
#   
#   
# class A { ... };  
#   
# void f()  
#   
# {  
#   
# const A *pa = new A;//const对象  
#   
# A *pb;//非const对象  
#   
#   
#   
#   
# //pb = pa; // 这里将出错,不能将const对象指针赋值给非const对象  
#   
# pb = const_cast <A*> (pa); // 现在OK了  
#   
# ...  
#   
# }  
#

# 4)reinterpret_cast <T*> (a)  
#   
# 任何指针都可以转换成其它类型的指针,T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。  
#   
# 表达式reinterpret_cast <T*> (a)能够用于诸如char* 到 int*,或者One_class* 到 Unrelated_class*等类似这样的转换,因此可能是不安全的。  
#   
#   
#   
#   
# 例子:  
#   
# class A { ... };  
#   
# class B { ... };  
#   
# void f()  
#   
# {  
#   
#    A* pa = new A;  
#   
#   void* pv = reinterpret_cast <A*> (pa);  
#   
#   // pv 现在指向了一个类型为B的对象,这可能是不安全的  
#   
#    ...  
#   
# } 
posted @ 2010-02-11 09:04 SimonHan 阅读(436) | 评论 (0)编辑 收藏

刚刚接触模式或者学习模式的人,经常会有这样的问题,为什么模式是成功的呢?很多人都会说模式是经验的积累,当然是正确的。可是经验为什么偏偏就证明了这 种模式是正确的呢?这其中起用作的就是面向对象的基本原则。正是因为模式都或多或少的符合了面向对象的基本原则,所以模式才成为我们面向对象的设计和编码 过程中不败的法则。那么什么是面向对象的基本原则呢?这就是我们将要一一讲到的问题。
单纯的讲到一个个的原则,就是那么的寥寥几句,非常的简单,但又是非常抽象的,难以理解。怎么办?
任何的理论,只要有生动的例子来讲解或证明,就能极大的帮助理解。所以我们准备从一个个的生动的例子来阐述我们的面向对象的基本原则。讲那些例子呢?上面我们说到,模式都是极大的遵从了这些原则的,那么我们把模式作为例子,来说明这些原则,不是我们信手拈来的吗?
现在我们说说其中的一个原则:对类的功能的扩展,要多用组合,少用继承
对于类的扩展,在面向对象的编程过程中,我们首先想到的是类的继承,由子类继承父类,从而完成了对子类功能的扩展。但是,面向对象的原则告诉我们,对类的功能的扩展要多用组合,而少用继承。其中的原因有以下几点:
第一、子类对父类的继承是全部的公有和受保护的继承,这使得子类可能继承了对子类无用甚至有害的父类的方法。换句话说,子类只希望继承父类的一部分方法,怎么办?
第二、实际的对象千变万化,如果每一类的对象都有他们自己的类,尽管这些类都继承了他们的父类,但有些时候还是会造成类的无限膨胀。
第三、 继承的子类,实际上需要编译期确定下来,这满足不了需要在运行内才能确定对象的情况。而组合却可以比继承灵活得多,可以在运行期才决定某个对象。
嗨!光说这么多一二三有什么用,我们就是想看看实际情况是不是像上面说的那样呢?还是来看看实际的例子吧!
现在我们需要这样一个HashMap,它除了能按常规的Map那样取值,如get(Object obj)。还能按位取值,像ArrayList那样,按存入对象对的先后顺序取值。
对于这样一个问题,我们首先想到的是做一个类,它继承了HashMap类,然后用一个ArrayList属性来保存存入的key,我们按key的位来取值,代码如下:
Java代码
  1. public class ListMap extends HashMap {  
  2. private List list;  
  3. public ListMap() {  
  4.          super();  
  5.           this.list = new ArrayList();  
  6. }  
  7. public Object put(Object key,Object value)  
  8. {  
  9.          if(list.contains(key))  
  10.           {  
  11.                  list.remove(key);  
  12.           }  
  13.          this.list.add(key);  
  14.           return super.put(key,value);  
  15. }  
  16. public Object getKey(int i)  
  17. {  
  18.           return this.list.get(i);  
  19. }  
  20. public Object getValue(int i)  
  21. {  
  22.           return this.get(getKey(i));  
  23. }  
  24. public int size()  
  25. {  
  26.           return this.list.size();  
  27. }  
  28. }  
  29. 这个ListMap类对HashMap作了一定的扩展,很简单就实现了上面我们所要求的功能。然后我们对该类做一下测试:  
  30. ListMap map = new ListMap();  
  31.          map.put("a","111");  
  32.          map.put("v","190");  
  33.          map.put("d","132");  
  34.           for(int i=0;i<map.size();i++)  
  35.           {  
  36.                  System.out.println(map.getValue(i));  
  37.           }  
测试结果为:
111
190
132
正是我们所需要看到的结果。如此说来,这个ListMap类就可以放心的使用了吗?有实现了这样功能的类,你的同事或朋友也可能把这个类拿来使用一下,他可能写出来如下的代码:
Java代码
  1. ListMap map = new ListMap();  
  2.          map.put("a","111");  
  3.          map.put("v","190");  
  4.          map.put("d","132");  
  5.          String[] list = (String[])map.values().toArray(new String[0]);  
  6.           for(int i=0;i<list.length;i++)  
  7.           {  
  8.                  System.out.println(list[i]);  
  9.           }  
运行的结果如下:
132
111
190
哎哟,怎么回事啊?与上面的顺序不对了。你朋友过来找你,说你写的代码怎么不对啊?你很吃惊,说把代码给我看看。于是你看到了上面的代码。你大骂道,混蛋,怎么不是用我的getValue方法啊?你朋友搔搔头道,values方法不是一样的吗?你也没告诉我不能用啊?
通过上面的例子,我们看到了继承的第一个危害:继承不分青红皂白的把父类的公有和受保护的方法统统继承下来。如果你的子类没有对一些方法重写,就 会对你的子类产生危害。上面的ListMap类,你没有重写继承自HashMap类的values方法,而该方法仍然是按HashMap的方式取值,没有 先后顺序。这时候,如果在ListMap类的对象里使用该方法取得的值,就没有实现我们上面的要求。
接上面的那个例子,你听了朋友的抱怨,摇摇头,想想也是,不能怪他。你只得把values方法在ListMap类重写一遍,然后又嘀咕着,我是不是该把HashMap类的公有方法在ListMap类里全部重写?很多方法根本没有必要用到啊?……
对了,很多方法在ListMap里根本不必用到,但是你用继承的话,还不得不在ListMap里重写它们。如果用组合的话,就没有上面的烦恼了:
Java代码
  1. public class MyListMap {  
  2. private HashMap map;  
  3. private List list;  
  4. public MyListMap()  
  5. {  
  6.          this.map = new HashMap();  
  7.           this.list = new ArrayList();  
  8. }  
  9. public Object put(Object key,Object value)  
  10. {  
  11.          if(list.contains(key))  
  12.           {  
  13.                  list.remove(key);  
  14.           }  
  15.          this.list.add(key);  
  16.           return this.map.put(key,value);  
  17. }  
  18. public Object getKey(int i)  
  19. {  
  20.           return this.list.get(i);  
  21. }  
  22. public Object getValue(int i)  
  23. {  
  24.           return this.map.get(getKey(i));  
  25. }  
  26. public int size()  
  27. {  
  28.           return this.list.size();  
  29. }  
  30. }  
这样,你的朋友就只能使用你的getKey和getValue方法了。如果他向你抱怨没有values方法,你尽可以满足他的要求,给他添加上那个方法,而不必担心可能还有方法没有被重写了。
我们来看Adapter模式,该模式的目的十分简单:我手里握有一些实现了WhatIHave接口的实现,可我觉得这些实现的功能不够用,我还需要从Resource类里取一些功能来为我所用。Adapter模式的解决方法如下:
Java代码
  1. public interface WhatIHave  
  2. {  
  3.           public void g();  
  4. }  
  5. public class Resource  
  6. {  
  7.           public void f()  
  8.           {  
  9.                ……  
  10.           }  
  11.           public void h()  
  12.           {  
  13.                ……  
  14.           }  
  15. }  
上面是两个基础类,很明显,我们所要的类既要有g()方法,也要有f()和h()方法。
Java代码
  1. Public class WhatIWant implements WhatIHave  
  2. {  
  3.           private Resource res;  
  4.           public WhatIWant()  
  5.           {  
  6.                  res = new Resource();  
  7. }  
  8. public void g()  
  9. {  
  10.        ……  
  11. }  
  12. public void f()  
  13. {  
  14.          this.res.f();  
  15. }  
  16. public void h()  
  17. {  
  18.          this.res.h();  
  19. }  
  20. }  
上 面就是一个Adapter模式最简单的解决问题的思路。我们主要到,对于Resource类,该模式使用的是组合,而不是继承。这样使用是有多个原因:第 一,Java不支持多重继承,如果需要使用好几个不同的Resource类,则继承解决不了问题。第二,如果Resource类还有一个方法:k(),我 们在WhatIWant类里使用不上的话,继承就给我们造成多余方法的问题了。
如果说Adapter模式对组合的应用的目的十分简单明确,那么Decorator模式对组合的应用简直就是令人叫绝。
让我们还是从Decorator模式的最佳例子说起,咖啡店需要售卖各种各样的咖啡:黑咖啡、加糖、加冰、加奶、加巧克力等等。顾客要买咖啡,他可以往咖啡任意的一种或几种产品。
这个问题一提出来,我们最容易想到的是继承。比如说加糖咖啡是一种咖啡,满足ia a的句式,很明显,加糖咖啡是咖啡的一个子类。于是,我们马上可以赋之行动。对于咖啡我们做一个咖啡类:Coffee,咖啡加 糖:SugarCoffee,咖啡加冰:IceCoffee,咖啡加奶:MilkCoffee,咖啡加巧克力:ChocolateCoffee,咖啡加糖 加冰:SugarIceCoffee……
哎哟,我们发现问题了:这样下去我们的类好多啊。可是咖啡店的老板还不放过我们,他又逼着我们增加蒸汽咖啡、加压咖啡,结果我们发现,每增加一种新的类型,我们的类好像是成几何级数增加,我们都要疯了。
这个例子向我们展示了继承的第二个缺点,会使得我们的子类快速的膨胀下去,达到惊人的数量。
怎么办?我们的Decorator模式找到了组合来为我们解决问题。下面我们来看看Decorator模式是怎么来解决这个问题的。
首先是它们的共同接口:
Java代码
  1. package decorator;  
  2.   
  3. interface Product {  
  4. public double money();  
  5. }  
  6.   
  7. //咖啡类:  
  8. class Coffee implements Product {  
  9. public double money() {  
  10.     return 12;  
  11. }  
  12. }  
  13.   
  14. //加糖:  
  15. class Sugar implements Product {  
  16. private Product product;  
  17.   
  18. public Sugar(Product product) {  
  19.     this.product = product;  
  20. }  
  21.   
  22. public double money() {  
  23.     return product.money() + 2;  
  24. }  
  25. }  
  26.   
  27. //加冰:  
  28. class Ice implements Product {  
  29. private Product product;  
  30.   
  31. public Ice(Product product) {  
  32.     this.product = product;  
  33. }  
  34.   
  35. public double money() {  
  36.     return product.money() + 1.5;  
  37. }  
  38. }  
  39.   
  40. //加奶:  
  41. class Milk implements Product {  
  42. private Product product;  
  43.   
  44. public Milk(Product product) {  
  45.     this.product = product;  
  46. }  
  47.   
  48. public double money() {  
  49.     return product.money() + 4.0;  
  50. }  
  51. }  
  52.   
  53. //加巧克力:  
  54. class Chocolate implements Product {  
  55. private Product product;  
  56.   
  57. public Chocolate(Product product) {  
  58.     this.product = product;  
  59. }  
  60.   
  61. public double money() {  
  62.     return product.money() + 5.5;  
  63. }  
  64. }  
  65. public class DecoratorModel{  
  66. public static void main(String [] args){  
  67.     Product coffee = new Coffee();  
  68.     Product sugarCoffee = new Sugar(coffee);  
  69.     Product sugarmilkCoffee = new Milk(sugarCoffee);  
  70.     System.out.println("加糖咖啡:"+sugarCoffee.money());  
  71.     System.out.println("加糖加奶咖啡:"+sugarmilkCoffee.money());  
  72. }  
  73. }  

我们来看客户端的调用。
如果顾客想要黑咖啡,调用如下:
Product prod = new Coffee();
System.out.println(prod.money());
如果顾客需要加冰咖啡,调用如下:
Product prod = new Ice(new Coffee());
System.out.println(prod.money());
如果顾客想要加糖加冰加奶加巧克力咖啡,调用如下:
Product prod = new Chocolate(new Milk(new Ice(new Sugar())));
System.out.println(prod.money());
通过上面的例子,我们可以看到组合的又一个很优越的好处:能够在运行期创建新的对象。如上面我们的加冰咖啡,我们没有这个类,却能通过组合在运行期创建该对象,这的确大大的增加了我们程序的灵活性。
如果咖啡店的老板再要求你增加加压咖啡,你就不会再担心了,只给他增加了一个类就解决了所有的问题。
posted @ 2010-02-11 07:25 SimonHan 阅读(1461) | 评论 (0)编辑 收藏

OOD六大原则

文章分类:综合技术
面向对象设计的六大原则
1.开放封闭原则(复用性强,易扩展)
2.依赖倒转原则(依赖于抽象,而不是具体的实现,面向接口(抽象)编程)
3.里氏代换原则(子类型必须能够替换它的基类型。子类只能继承或重写父类的方法,不能有父类中没有定义的方法)
4.多用组合少用继承(适配器模式)
5.迪米特法则(最少知识原则,只和朋友通信,不跟陌生人打交道,门面模式)
6.接口隔离原则(接口不能臃肿,一个接口相当于一个角色,如果一个类实现一个接口时从中获取了不需要的方法,那么这个接口设计的不合理,应该被细分)


牢记原则,结合设计模式去体会!设计模式可以忘记,但原则不能忘记!
posted @ 2010-02-11 07:22 SimonHan 阅读(354) | 评论 (0)编辑 收藏

2010年1月7日 #

Please check this ordinary but interesting website to find what you like and what you definitely want for programming:

http://www.goingware.com/tips

enjoy~

posted @ 2010-01-07 09:50 SimonHan 阅读(424) | 评论 (0)编辑 收藏

2010年1月6日 #

C++为类中提供

类对象的构造顺序是这样的:
1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员
2.进入构造函数后在构造函数中执行一般计算

  1.类里面的任何
到此,我的问题解决。但是我还想趁机复习一下C++类初始化
  1.初始化列表:CSomeClass::CSomeClass() : x(0), y(1){}
  2.类外初始化:int CSomeClass::myVar=3;
  3.const常量定义必须初始化C++类里面使用初始化列表;
  4.C++类不能定义常量数组
 
关于const,复习一下常量指针: 
  如果const位于星号的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;如果const位于星号的右侧,const就是修饰指针本身,即指针本身是常量。

c++各种不同型成员根据是否static 、时候const型的初始化方法不尽相同,java的语法就没有这么复杂,怪的得那么多人都跑去学Java了。以前面试时被人问到这个问题回答不出来,写代码时也经常搞乱了,这里翻了下书,总结一下。

-----------------Test.h----------------------------

#pragma once

class Test
{
private :
      int   var1;
// int   var11= 4; 错误的初始化方法
      const int   var2 ;
   //const int   var22 =22222; 错误的初始化方法
      static int   var3;
// static int   var3333=33333; 错误,只有静态常量成员才能直接赋值来初始化
      static const int   var4=4444; //正确,静态常量成员可以直接初始化
      static const int   var44;
public:
Test(void);
~Test(void);
};

--------------------Test.cpp-----------------------------------

#include ".\test.h"

int Test::var3 = 3333333; //静态成员的 正确的初始化方法

//int Test::var1 = 11111;; 错误 静态成员才能初始化
//int Test::var2 = 22222; 错误
//int Test::var44 = 44444; // 错误的方法,提示重定义
Test::Test(void) :var1(11111),var2(22222)   //正确的初始化方法 , var3(33333) 不能在这里初始化
{
          var1 =11111; //正确, 普通变量也可以在这里初始化
          //var2 = 222222; 错误,因为常量不能赋值,只能在 “constructor initializer (构造函数的初始化列表)” 那里初始化
          
    var3 =44444;   //这个赋值时正确的,不过因为所有对象一个静态成员,所以会影响到其他的,这不能叫做初始化了吧
}

Test::~Test(void)
{
}

posted @ 2010-01-06 13:45 SimonHan 阅读(3683) | 评论 (0)编辑 收藏

模板就是实现代码重用机制的一种工具,它可以实现类型参数化,即把类型定义为参数, 从而实现了真正的代码可重用性。模版可以分为两类,一个是函数模版,另外一个是类模版。

1. 模板的概念

我们已经学过重载(Overloading),对重载函数而言,C++的检查机制能通过函数参数的不同及所属类的不同。正确的调用重载函数。例如,为求两个数的最大值,我们定义MAX()函数需要对不同的数据类型分别定义不同重载(Overload)版本。

//函数1.

int max(int x,int y);
{return(x>y)?x:y ;}

//函数2.
float max( float x,float y){
return (x>y)? x:y ;}

//函数3.
double max(double x,double y)
{return (c>y)? x:y ;}

但如果在主函数中,我们分别定义了 char a,b; 那么在执行max(a,b);时 程序就会出错,因为我们没有定义char类型的重载版本。

现在,我们再重新审视上述的max()函数,它们都具有同样的功能,即求两个数的最大值,能否只写一套代码解决这个问题呢?这样就会避免因重载函数定义不 全面而带来的调用错误。为解决上述问题C++引入模板机制,模板定义:模板就是实现代码重用机制的一种工具,它可以实现类型参数化,即把类型定义为参数, 从而实现了真正的代码可重用性。模版可以分为两类,一个是函数模版,另外一个是类模版。

2.   函数模板的写法

函数模板的一般形式如下:

Template <class或者也可以用typename T>

返回类型 函数名(形参表)
{//
函数定义体 }

说明: template是一个声明模板的关键字,表示声明一个模板关键字class不能省略,如果类型形参多余一个 ,每个形参前都要加class <类型 形参表>可以包含基本数据类型可以包含类类型.

请看以下程序:

//Test.cpp

#include <iostream>

using std::cout;

using std::endl;

//声明一个函数模版,用来比较输入的两个相同数据类型的参数的大小,class也可以被typename代替,

//T可以被任何字母或者数字代替。

template <class T>

T min(T x,T y)

{ return(x<y)?x:y;}

void main( )

{

     int n1=2,n2=10;

     double d1=1.5,d2=5.6;

     cout<< "较小整数:"<<min(n1,n2)<<endl;

     cout<< "较小实数:"<<min(d1,d2)<<endl;

     system("PAUSE");

}

程序运行结果: 

 

程序分析:main()函数中定义了两个整型变量n1 , n2 两个双精度类型变量d1 , d2然后调用min( n1, n2); 即实例化函数模板T min(T x, T y)其中T为int型,求出n1,n2中的最小值.同理调用min(d1,d2)时,求出d1,d2中的最小值.

3. 类模板的写法

定义一个类模板:

Template < class或者也可以用typename T >
class
类名{
//类定义......
};

说明:其中,template是声明各模板的关键字,表示声明一个模板,模板参数可以是一个,也可以是多个。

例如:定义一个类模板:

// ClassTemplate.h
#ifndef ClassTemplate_HH

#define ClassTemplate_HH

template<typename T1,typename T2>

class myClass{

private:

     T1 I;

     T2 J;

public:

     myClass(T1 a, T2 b);//Constructor

     void show();

};

//这是构造函数

//注意这些格式

template <typename T1,typename T2>

myClass<T1,T2>::myClass(T1 a,T2 b):I(a),J(b){}

//这是void show();

template <typename T1,typename T2>

void myClass<T1,T2>::show()

{

     cout<<"I="<<I<<", J="<<J<<endl;

}

#endif

// Test.cpp

#include <iostream>

#include "ClassTemplate.h"

using std::cout;

using std::endl;

void main()

{

     myClass<int,int> class1(3,5);

     class1.show();

     myClass<int,char> class2(3,'a');

     class2.show();

     myClass<double,int> class3(2.9,10);

     class3.show();

     system("PAUSE");

}

最后结果显示:

 

4.非类型模版参数

一般来说,非类型模板参数可以是常整数(包括枚举)或者指向外部链接对象的指针。

那么就是说,浮点数是不行的,指向内部链接对象的指针是不行的。


template<typename T, int MAXSIZE>

class Stack{

Private:

       T elems[MAXSIZE];

};

Int main()

{

       Stack<int, 20> int20Stack;

       Stack<int, 40> int40Stack;

};

posted @ 2010-01-06 13:30 SimonHan 阅读(388) | 评论 (0)编辑 收藏

C++中const用法总结

作者JuKevin

1. const修饰普通变量和指针

const修饰变量,一般有两种写法:

const TYPE value;

TYPE const value;

这两种写法在本质上是一样的。它的含义是:const修饰的类型为TYPE的变量value是不可变的。

对于一个非指针的类型TYPE,无论怎么写,都是一个含义,即value只不可变。

例如:

const int nValue         //nValueconst

int const nValue    // nValueconst

但是对于指针类型的TYPE,不同的写法会有不同情况,例如:

A. const char *pContent;

B. char * const pContent;

C. char const *pContent;

D. const char* const pContent;

 

对于前三种写法,我们可以换个方式,给其加上括号

A. const (char) *pContent;

B. (char*) const pContent;

C. (char) const *pContent;

这样就一目了然。根据对于const修饰非指针变量的规则,很明显,A=C.

 

- 对于A,C, const修饰的类型为char的变量*pContent为常量,因此,pContent的内容为常量不可变.

- 对于B, 其实还有一种写法: const (char*) pContent;

含义为:const修饰的类型为char*的变量pContent为常量,因此,pContent指针本身为常量不可变.

- 对于D, 其实是AB的混合体,表示指针本身和指针内容两者皆为常量不可变

 

总结:

(1)  指针本身是常量不可变

(char*) const pContent;

const (char*) pContent;

 

(2)  指针所指向的内容是常量不可变

const (char) *pContent;

(char) const *pContent;

 

(3)  两者都不可变

const char* const pContent;

 

还有其中区别方法:

沿着*号划一条线,

如果const位于*的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;

如果const位于*的右侧,const就是修饰指针本身,即指针本身是常量。

2. const修饰函数参数

const修饰函数参数是它最广泛的一种用途,它表示函数体中不能修改参数的值(包括参数本身的值或者参数其中包含的值)。它可以很好

void function(const int Var); //传递过来的参数在函数内不可以改变(无意义,因为Var本身就是形参)

void function(const char* Var); //参数指针所指内容为常量不可变

void function(char* const Var); //参数指针本身为常量不可变(也无意义, 因为char* Var也是形参)

 

参数为引用,为了增加效率同时防止修改。

修饰引用参数时:

void function(const Class& Var);//引用参数在函数内不可以改变

void function(const TYPE& Var); //引用参数在函数内为常量不可变

 

3. const 修饰函数返回值

const修饰函数返回值其实用的并不是很多,它的含义和const修饰普通变量以及指针的含义基本相同。

(1) const int fun1() 这个其实无意义,因为参数返回本身就是赋值。

(2) const int * fun2()

调用时 const int *pValue = fun2();

我们可以把fun2()看作成一个变量,那么就是我们上面所说的1.(1)的写法,即指针内容不可变。

(3) int* const fun3()

调用时 int * const pValue = fun2();

我们可以把fun2()看作成一个变量,那么就是我们上面所说的1.(2)的写法,即指针本身不可变。

4. const修饰类对象/对象指针/对象引用

const修饰类对象表示该对象为常量对象,其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。

const修饰的对象,该对象的任何非const成员函数都不能被调用,因为任何非const成员函数会有修改成员变量的企图。

例如:

class AAA

{
   void func1();

void func2() const;

}

const AAA aObj;

aObj.func1(); ×

aObj.func2(); 正确

 

const AAA* aObj = new AAA();

aObj->func1(); ×

aObj->func2(); 正确

 

5. const修饰成员变量

const修饰类的成员函数,表示成员常量,不能被修改,同时它只能在初始化列表中赋值。

 

class A

{

  

   const int nValue;       //成员常量不能被修改

  

   A(int x): nValue(x) {}; //只能在初始化列表中赋值

}

 

6. const修饰成员函数

const修饰类的成员函数,则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。

 

class A

{

  

void function()const; //常成员函数, 它不改变对象的成员变量. 也不能调用类中任何非const成员函数。

}

对于const类对象/指针/引用,只能调用类的const成员函数,因此,const修饰成员函数的最重要作用就是限制对于const对象的使用。

 

7. const常量与define宏定义的区别

(1) 编译器处理方式不同

define宏是在预处理阶段展开。

const常量是编译运行阶段使用。

(2) 类型和安全检查不同

define宏没有类型,不做任何类型检查,仅仅是展开。

const常量有具体的类型,在编译阶段会执行类型检查。

(3) 存储方式不同

define宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存。

const常量会在内存中分配(可以是堆中也可以是栈中)

posted @ 2010-01-06 13:04 SimonHan 阅读(537) | 评论 (0)编辑 收藏

引用是C++引入的新语言特性,是C++常用的一个重要内容之一,正确、灵活地使用引用,可以使程序简洁、高效。我在工作 中发现,许多人使用它仅仅是想当然,在某些微妙的场合,很容易出错,究其原由,大多因为没有搞清本源。故在本篇中我将对引用进行详细讨论,希望对大家更好 地理解和使用引用起到抛砖引玉的作用。

  引用简介

  引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。

  引用的声明方法:类型标识符 &引用名=目标变量名;

  【例1】:int a; int &ra=a; //定义引用ra,它是变量a的引用,即别名

  说明:

  (1)&在此不是求地址运算,而是起标识作用。

  (2)类型标识符是指目标变量的类型。

  (3)声明引用时,必须同时对其进行初始化。

  (4)引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,且不能再把该引用名作为其他变量名的别名。

   ra=1; 等价于 a=1;

  (5)声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。故:对引用求地址,就是对目标变量求地址。&ra与&a相等。

  (6)不能建立数组的引用。因为数组是一个由若干个元素所组成的集合,所以无法建立一个数组的别名。

  引用应用

  1、引用作为参数

引用的一个重要作用就是作为函数的参数。以前的C语言中函数参数传递是值传递,如果有大块数据作为参数传递的时候,采用的方案往往是指针,因为这样可以 避免将整块数据全部压栈,可以提高程序的效率。但是现在(C++中)又增加了一种同样有效率的选择(在某些特殊情况下又是必须的选择),就是引用。

  【例2】:

void swap(int &p1, int &p2) //此处函数的形参p1, p2都是引用
{ int p; p=p1; p1=p2; p2=p; }

  为在程序中调用该函数,则相应的主调函数的调用点处,直接以变量作为实参进行调用即可,而不需要实参变量有任何的特殊要求。如:对应上面定义的swap函数,相应的主调函数可写为:

main( )
{
 int a,b;
 cin>>a>>b; //输入a,b两变量的值
 swap(a,b); //直接以变量a和b作为实参调用swap函数
 cout<<a<< ' ' <<b; //输出结果
}

  上述程序运行时,如果输入数据10 20并回车后,则输出结果为20 10。

  由【例2】可看出:

  (1)传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。

(2)使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配 存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占 空间都好。

  (3)使用指针作为函数的参数虽然也能达到与使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使 用'*指针变量名'的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。而引用更容易使 用,更清晰。


  如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用

  2、常引用

  常引用声明方式:const 类型标识符 &引用名=目标变量名;

  用这种方式声明的引用,不能通过引用对目标变量的值进行修改,从而使引用的目标成为const,达到了引用的安全性。

  【例3】:

int a ;
const int &ra=a;
ra=1; //错误
a=1; //正确

  这不光是让代码更健壮,也有些其它方面的需要。

  【例4】:假设有如下函数声明:

string foo( );
void bar(string & s);

  那么下面的表达式将是非法的:

bar(foo( ));
bar('hello world');

  原因在于foo( )和'hello world'串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。

引用型参数应该在能被定义为const的情况下,尽量定义为const 。


  3、引用作为返回值

  要以引用返回函数值,则函数定义时要按以下格式:

类型标识符 &函数名(形参列表及类型说明)
{函数体}

  说明:

  (1)以引用返回函数值,定义函数时需要在函数名前加&

  (2)用引用返回一个函数值的最大好处是,在内存中不产生被返回值的副本。

  【例5】以下程序中定义了一个普通的函数fn1(它用返回值的方法返回函数值),另外一个函数fn2,它以引用的方法返回函数值。

#include <iostream.h>
float temp; //定义全局变量temp
float fn1(float r); //声明函数fn1
float &fn2(float r); //声明函数fn2
float fn1(float r) //定义函数fn1,它以返回值的方法返回函数值
{
 temp=(float)(r*r*3.14);
 return temp;
}
float &fn2(float r) //定义函数fn2,它以引用方式返回函数值
{
 temp=(float)(r*r*3.14);
 return temp;
}
void main() //主函数
{
 float a=fn1(10.0); //第1种情况,系统生成要返回值的副本(即临时变量)
 float &b=fn1(10.0); //第2种情况,可能会出错(不同 C++系统有不同规定)
 //不能从被调函数中返回一个临时变量或局部变量的引用
 float c=fn2(10.0); //第3种情况,系统不生成返回值的副本
 //可以从被调函数中返回一个全局变量的引用
 float &d=fn2(10.0); //第4种情况,系统不生成返回值的副本
 //可以从被调函数中返回一个全局变量的引用
 cout<<a<<c<<d;
}

  引用作为返回值,必须遵守以下规则:

  (1)不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了'无所指'的引用,程序会进入未知状态。

(2)不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题,可对于这种情况(返回函数内部new分配内存的引用),又面临其它尴尬局面。例如,被函数返回的引用只是作为一 个临时变量出现,而没有被赋予一个实际的变量,那么这个引用所指向的空间(由new分配)就无法释放,造成memory leak。

(3)可以返回类成员的引用,但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则(business rule)相关联的时候,其赋值常常与某些其它属性或者对象的状态有关,因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常 量引用(或指针),那么对该属性的单纯赋值就会破坏业务规则的完整性。

  (4)引用与一些操作符的重载:

  流操作 符<<和>>,这两个操作符常常希望被连续使用,例如:cout << 'hello' << endl; 因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括:返回一个流对象和返回一个流对象指针。但是对于返回 一个流对象,程序必须重新(拷贝)构造一个新的流对象,也就是说,连续的两个<<操作符实际上是针对不同对象的!这无法让人接受。对于返回一 个流指针则不能连续使用<<操作符。因此,返回一个流对象引用是惟一选择。这个唯一选择很关键,它说明了引用的重要性以及无可替代性,也许这 就是C++语言中引入引用这个概念的原因吧。 赋值操作符=。这个操作符象流操作符一样,是可以连续使用的,例如:x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值,以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

  【例6】 测试用返回引用的函数值作为赋值表达式的左值。

#include <iostream.h>
int &put(int n);
int vals[10];
int error=-1;
void main()
{
put(0)=10; //以put(0)函数值作为左值,等价于vals[0]=10;
put(9)=20; //以put(9)函数值作为左值,等价于vals[9]=10;
cout<<vals[0];
cout<<vals[9];
}
int &put(int n)
{
if (n>=0 && n<=9 ) return vals[n];
else { cout<<'subscript error'; return error; }
}

(5)在另外的一些操作符中,却千万不能返回引用:+-*/ 四则运算符。它们不能返回引用,Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect,因此,它们必须构造一个对象作为返回值,可选的方案包括:返回一个对象、返回一个局部变量的引用,返回一个new分配的对象的引用、返回一 个静态对象引用。根据前面提到的引用作为返回值的三个规则,第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。
4、引用和多态

  引用是除指针外另一个可以产生多态效果的手段。这意味着,一个基类的引用可以指向它的派生类实例。

  【例7】:

class  A;
class  B:public A{……};
B  b;
A  &Ref = b; // 用派生类对象初始化基类对象的引用

  Ref 只能用来访问派生类对象中从基类继承下来的成员,是基类引用指向派生类。如果A类中定义有虚函数,并且在B类中重写了这个虚函数,就可以通过Ref产生多态效果。

  引用总结

  (1)在引用的使用中,单纯给某个变量取个别名是毫无意义的,引用的目的主要用于在函数参数传递中,解决大块数据或对象的传递效率和空间不如意的问题。

  (2)用引用传递函数的参数,能保证参数传递中不产生副本,提高传递的效率,且通过const的使用,保证了引用传递的安全性。

  (3)引用与指针的区别是,指针通过某个指针变量指向一个对象后,对它所指向的变量间接操作。程序中使用指针,程序的可读性差;而引用本身就是目标变量的别名,对引用的操作就是对目标变量的操作。

  (4)使用引用的时机。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。
posted @ 2010-01-06 12:59 SimonHan 阅读(447) | 评论 (0)编辑 收藏

2009年11月19日 #


Linux中的一些常用符号含义其实不难理解,有些甚至和DOS是相通的。

一、通配符:“*”、“?”
和DOS下一样,当我们不知道确切的文件名时,可以用通配符来进行模糊操作。“*”可以代表任意长度的任意字符,“?”代表一个任意字符。

二、转义字符:“\”
和DOS的命名规则不同的是,通配符“*”、“?”是可以在文件名中使用的。

如果要操作的文件名中包含有这些特殊符号,我们可以结合“\”来表达。下面是通配符和正则表达式的一个简短列表:

* 匹配所有字符

? 匹配字串中的一个字符

\* 匹配“*”字符

\? 匹配“?”字符

\) 匹配“)”字符

三、目录:“/”、“~”、“.”、“..”
它们分别代表的意思是:

“/”:根目录(在中间使用表示路径)

“~”:用户根目录(用户登录时所在的目录)

“.”:当前目录

“..”:上级目录

四、后台执行:“&”
用户有时候执行命令要花很长时间,可能会影响做其他事情。最好的方法是将它放在后台执行。后台运行的程序在用户注销后系统还可以继续执行。当要把命令放在后台执行时,在命令的后面加上“&”。

五、管道和重导向:“|”、“>”、“>>”、“<”
重导向就是使命令改变它所认定的标准输出。“>”可将结果输出到文件中,该文件原有内容会被删除,“>>”则将结果附加到文件中,原文件内容不会被删除。“<”可以改变标准输入。如:

cat data1.txt>>data2.txt(将data1.txt文件的内容加在data2.txt文件的后面)

管道“|”可将命令的结果输出给另一个命令作为输入之用:

man mtools|grep mbadblocks (在mtools的帮助中搜索包含“mbadblocks”的句子)

man mtools|less(把输出用管道导入到一个叫做 less 的工具。less 是一个分页工具,它允许你一页一页地查看信息。)

六、连接符号:“;”
当有几个命令要连续执行时,我们可以把它们放在一行内,中间用“;”分开。

mkdir myfile;cp /tmp/myfile.txt myfile(先建立一个目录myfile,然后把myfile.txt拷贝到新建的目录中)
posted @ 2009-11-19 12:00 SimonHan 阅读(308) | 评论 (0)编辑 收藏

仅列出标题