C++博客-Design&Art

[ZZ]C++中const总结

安帛伟 — Fri, 10 Apr 2009 16:51:00 GMT

一、对于基本声明

1.const int r=100; //标准const变量声明加初始化，因为默认内部连接所以必须被初始化，其作用域为此文件，编译器经过类型检查后直接用100在编译时替换。

2.extend const int r=100; //将const改为外部连接，作用于扩大至全局，编译时会分配内存，并且可以不进行初始化，仅仅作为声明，编译器认为在程序其他地方进行了定义。

3.const int r[ ]={1,2,3,4};

struct S {int a,b;};
const S s[ ]={(1,2),(3.4)}; //以上两种都是常量集合，编译器会为其分配内存，所以不能在编译期间使用其中的值，例如：int temp[r[2]];这样的编译器会报告不能找到常量表达式

二、对于指针
1.const int *r=&x; //声明r为一个指向常量的x的指针，r指向的对象不能被修改，但他可以指向任何地址的常量。

2.int const *r=&x; //与用法1完全等价，没有任何区别。

3.int * const r=&x; //声明r为一个常量指针，他指向x，r这个指针的指向不能被修改，但他指向的地址的内容可以修改。

4.const int * const r=&x; //综合1、3用法，r是一个指向常量的常量型指针。

三、对于类型检查
可以把一个非const对象赋给一个指向const的指针，因为有时候我们不想从这个指针来修改其对象的值；但是不可以把一个const对象赋值给一个非const指针，因为这样可能会通过这个指针改变指向对象的值，但也存在使这种操作通过的合法化写法，使用类型强制转换可以通过指针改变const对象：

const int r=100;
int * ptr = const_cast(&r); //C++标准，C语言使用：int * ptr =(int*)&r;

四、对于字符数组
如char * name = “china”; 这样的语句，在编译时是能够通过的，但是”china”是常量字符数组，任何想修改他的操作也能通过编译但会引起运行时错误，如果我们想修改字符数组的话就要使用char name[ ] = “china”; 这种形式。

五、对于函数
1.void Fuction1 ( const int r ); //此处为参数传递const值，意义是变量初值不能被函数改变

2.const int Fuction1 (int); //此处返回const值，意思指返回的原函数里的变量的初值不能被修改，但是函数按值返回的这个变量被制成副本，能不能被修改就没有了意义，它可以被赋给任何的const或非const类型变量，完全不需要加上这个const关键字。但这只对于内部类型而言（因为内部类型返回的肯定是一个值，而不会返回一个变量，不会作为左值使用），对于用户自定义类型，返回值是常量是非常重要的，见下面条款3。

3.Class CX; //内部有构造函数，声明如CX(int r =0)

CX Fuction1 () { return CX(); }

const CX Fuction2 () { return CX(); }

如有上面的自定义类CX，和函数Fuction1()和Fuction2(),我们进行如下操作时：

Fuction1() = CX(1); //没有问题，可以作为左值调用

Fuction2() = CX(1); //编译错误，const返回值禁止作为左值调用。因为左值把返回值作为变量会修改其返回值，const声明禁止这种修改。

4.函数中指针的const传递和返回：

int F1 (const char * pstr); //作为传递的时候使用const修饰可以保证不会通过这个指针来修改传递参数的初值，这里在函数内部任何修改*pstr的企图都会引起编译错误。

const char * F2 (); //意义是函数返回的指针指向的对象是一个const对象，它必须赋给一个同样是指向const对象的指针。

const char * const F3(); //比上面多了一个const，这个const的意义只是在他被用作左值时有效，它表明了这个指针除了指向const对象外，它本身也不能被修改，所以就不能当作左值来处理。

5.函数中引用的const传递：

void F1 ( const X& px); //这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的，他禁止对引用的对象的一切修改，唯一不同的是按值传递会先建立一个类对象的副本，然后传递过去，而它直接传递地址，所以这种传递比按值传递更有效。

**另外只有引用的const传递可以传递一个临时对象，因为临时对象都是const属性，且是不可见的，他短时间存在一个局部域中，所以不能使用指针，只有引用的const传递能够捕捉到这个家伙。

六、对于类
1.首先，对于const的成员变量，只能在构造函数里使用初始化成员列表来初始化，试图在构造函数体内进行初始化const成员变量会引起编译错误。初始化成员列表形如：
2.X:: X ( int ir ): r(ir) {} //假设r是类X的const成员变量

2.const成员函数。提到这个概念首先要谈到const对象，正象内置类型能够定义const对象一样（const int r=10;），用户自定义类型也可以定义const对象(const X px(10);)，编译器要保证这个对象在其生命周期内不能够被改变。如果你定义了这样的一个const对象，那么对于这个对象的一切非const成员函数的调用，编译器为了保证对象的const特性，都会禁止并在编译期间报错。所以如果你想让你的成员函数能够在const对象上进行操作的话，就要把这个函数声明为const成员函数。假如f( )是类中的成员函数的话，它的声明形如：
int f( ) const; //const放在函数的最后，编译器会对这个函数进行检查，在这个函数中的任何试图改变成员变量和调用非const成员函数的操作都被视为非法
注意：类的构造和析构函数都不能是const函数。

3.建立了一个const成员函数，但仍然想用这个函数改变对象内部的数据。这样的一个要求也会经常遇到，尤其是在一个苛刻的面试考官那里。首先我们要弄清楚考官的要求，因为有两种方法可以实现，如果这位考官要求不改变原来类的任何东西，只让你从当前这个const成员函数入手，那么你只有使用前面提到的类型强制转换方法。实例如下：

//假如有一个叫做X的类，它有一个int成员变量r，我们需要通过一个const成员函数f( )来对这个r进行++r操作，代码如下

void X::f( ) const

{ (const_cast(this)) -> ++r; } //通过this指针进行类型强制转换实现

另外一种方法就是使用关键字：mutable。如果你的成员变量在定义时是这个样子的：

mutable int r ;

那么它就告诉编译器这个成员变量可以通过const成员函数改变。编译器就不会再理会对他的检查了。

安帛伟 2009-04-11 00:51 发表评论

VC6调试时，如何查看vector中的内容？

安帛伟 — Wed, 04 Mar 2009 06:42:00 GMT

在VC6中，如何查看以下代码中vec里的内容？

    vector<int> vec;
    vec.push_back(1);
    vec.push_back(14);

如果在Watch窗口中直接输入vec，则会出现如下内容：

众所周知，vector使用的是线性连续存储空间，上图中的_First和_Last分别指向配置得来的连续空间中目前已被使用的范围，而_End指向整块连续空间的尾端。
因此，我们可以用如下方式来查看vector里的内容：
vec._First[0]
vec._First[1]

同理，对于嵌套的vector(如下代码中的vv)

    vector<int> vec;
    vec.push_back(1);
    vec.push_back(14);
    vector< vector<int> > vv;
    vv.push_back(vec);
    vec.push_back(15);
    vv.push_back(vec);

我们可以这样查看：
vv._First[1]._First[2]

安帛伟 2009-03-04 14:42 发表评论

正确使用stl map的erase方法

安帛伟 — Thu, 22 Jan 2009 05:33:00 GMT

STL的map表里有一个erase方法用来从一个map中删除掉指令的节点
eg:

map<string,string> mapTest;
typedef map<string,string>::iterator ITER;

ITER iter=mapTest.find(key);
mapTest.erase(iter);

像上面这样只是删除单个节点,map的形为不会出现任务问题,
但是当在一个循环里用的时候,往往会被误用,那是因为使用者没有正确理解iterator的概念.
像下面这样的一个例子就是错误的写法,
eg:

for(ITER iter=mapTest.begin();iter!=mapTest.end();++iter)
{
cout<<iter->first<<":"<<iter->second<<endl;
mapTest.erase(iter);
}

这是一种错误的写法,会导致程序行为不可知.究其原因是map 是关联容器,对于关联容器来说，如果某一个元素已经被删除，那么其对应的迭代器就失效了，不应该再被使用；否则会导致程序无定义的行为。
可以用以下方法解决这问题:
正确的写法
1.使用删除之前的迭代器定位下一个元素。STL建议的使用方式

for(ITER iter=mapTest.begin();iter!=mapTest.end();)
{
cout<<iter->first<<":"<<iter->second<<endl;
mapTest.erase(iter++);
}

2. erase() 成员函数返回下一个元素的迭代器

for(ITER iter=mapTest.begin();iter!=mapTest.end();)
{
cout<<iter->first<<":"<<iter->second<<endl;
iter=mapTest.erase(iter);
}

安帛伟 2009-01-22 13:33 发表评论

OO设计原则

安帛伟 — Tue, 27 May 2008 19:11:00 GMT

开闭原则（OCP）：对扩展开放，对修改封闭
里氏代换原则（LSP）：子类可替换父类，反之不行
依赖倒置原则（DIP）：依赖于抽象而不是依赖与具体
接口隔离原则（ISP）：多个专门接口比一个总接口好
合成/聚合复用原则（CARP）：尽量使用合成/聚合，而不是继承
迪米特法则（LoD）：不要和陌生人说话

安帛伟 2008-05-28 03:11 发表评论

GMOS模型

安帛伟 — Tue, 18 Dec 2007 12:40:00 GMT

GMOS击键模型

GMOS（goals/objects/methods/slecetion rules）

基本操作时间

名称和助记	典型值	含义
击键（Keying），K	0.2秒	敲击键盘上的一个键所需要的时间
指向（Pointing），P	1.1秒	用户指向显示屏上某一位置所需要的时间
归位（Homing），H	0.4秒	用户将手从键盘移动到鼠标或者从鼠标移动到键盘需要的时间
心理准备（Mentally preparing），M	1.35秒	用户进入下一步所需要的心理准备时间
响应（Responding），R

插入删除心理准备活动的规则

规则0 候选M的初始插入	在所有的K之前插入M。在所有用于选择命令的P之前插入M。但是对于选择命令参数的P，不要插入M。
规则1 预期M的删除	如果M前面的操作符号能完全预期M后边的一个操作符，则将该M删除。例如移动鼠标并点击目标，就需要删除按规则0插入的M，变PMK为PK。
规则2 认知但愿内M的删除	如果一串MK属于同一个认知单元，则删除除了第一个以外的所有M。例如连续输入一个单词或者多个数字。
规则3 连续终结符之前M的删除	如果K是一个认知单元后面的多余分隔符，如命令的分隔符后面紧跟着参数的分隔符，则将之前的M删除。
规则4 作为命令终结符的M的删除	如果K是一个分隔符，且后面紧跟着一个常量字符串，则将之前的M删除。
规则5 重叠M的删除	不要记入任何与R重叠的M。

举例：

设计一个软件可以完成如下功能，可以把摄氏温度转换成华氏温度，也可以把华氏温度转换成摄氏温度。

界面一如下：

缺省选项没有选中

HPKHKKKKK

HMPMKMHMKMKMKMKMK

HMPKHMKKKKMK

2H3M1P6K = 2*0.4 + 3*1.35 + 1.1 + 6*0.2 = 7.15秒

缺省选项选中

MKKKKMK

2M5K = 2*1.35 + 5*0.2 = 3.7秒

取两者的平均值（7.15 + 3.7）/2 =5.4秒

安帛伟 2007-12-18 20:40 发表评论

21种代码的“坏味道”

安帛伟 — Mon, 26 Nov 2007 09:09:00 GMT

选自 Martin Fowler的《Refactoring，Improving the design of the existing code》一书

1．Duplicated Code
　　代码重复几乎是最常见的异味了。他也是Refactoring 的主要目标之一。代码重复往往来自于copy-and-paste 的编程风格。与他相对应OAOO 是一个好系统的重要标志。

2．Long method
　　它是传统结构化的“遗毒“。一个方法应当具有自我独立的意图，不要把几个意图放在一起。

3．Large Class
　　大类就是你把太多的责任交给了一个类。这里的规则是One Class One Responsibility。

4．Divergent Change
　　一个类里面的内容变化率不同。某些状态一个小时变一次，某些则几个月一年才变一次；某些状态因为这方面的原因发生变化，而另一些则因为其他方面的原因变一次。面向对象的抽象就是把相对不变的和相对变化相隔离。把问题变化的一方面和另一方面相隔离。这使得这些相对不变的可以重用。问题变化的每个方面都可以单独重用。这种相异变化的共存使得重用非常困难。

5．Shotgun Surgery
　　这正好和上面相反。对系统一个地方的改变涉及到其他许多地方的相关改变。这些变化率和变化内容相似的状态和行为通常应当放在同一个类中。

6．Feature Envy
　　对象的目的就是封装状态以及与这些状态紧密相关的行为。如果一个类的方法频繁用get 方法存取其他类的状态进行计算，那么你要考虑把行为移到涉及状态数目最多的那个类。

7．Data Clumps
　　某些数据通常像孩子一样成群玩耍：一起出现在很多类的成员变量中，一起出现在许多方法的参数中…..，这些数据或许应该自己独立形成对象。

8．Primitive Obsession
　　面向对象的新手通常习惯使用几个原始类型的数据来表示一个概念。譬如对于范围，他们会使用两个数字。对于Money，他们会用一个浮点数来表示。因为你没有使用对象来表达问题中存在的概念，这使得代码变的难以理解，解决问题的难度大大增加。
　　好的习惯是扩充语言所能提供原始类型，用小对象来表示范围、金额、转化率、邮政编码等等。

9．Switch Statement
　　基于常量的开关语句是 OO 的大敌，你应当把他变为子类、state 或strategy。

10． Parallel Inheritance Hierarchies
　　并行的继承层次是shotgun surgery 的特殊情况。因为当你改变一个层次中的某一个类时，你必须同时改变另外一个层次的并行子类。

11． Lazy Class
　　一个干活不多的类。类的维护需要额外的开销，如果一个类承担了太少的责任，应当消除它。

12． Speculative Generality
　　一个类实现了从未用到的功能和通用性。通常这样的类或方法唯一的用户是testcase。不要犹豫，删除它。

13． Temporary Field
　　一个对象的属性可能只在某些情况下才有意义。这样的代码将难以理解。专门建立一个对象来持有这样的孤儿属性，把只和他相关的行为移到该类。最常见的是一个特定的算法需要某些只有该算法才有用的变量。

14． Message Chain
　　消息链发生于当一个客户向一个对象要求另一个对象，然后客户又向这另一对象要求另一个对象，再向这另一个对象要求另一个对象，如此如此。这时，你需要隐藏分派。

15． Middle Man
　　对象的基本特性之一就是封装，而你经常会通过分派去实现封装。但是这一步不能走得太远，如果你发现一个类接口的一大半方法都在做分派，你可能需要移去这个中间人。

16． Inappropriate Intimacy
　　某些类相互之间太亲密，它们花费了太多的时间去砖研别人的私有部分。对人类而言，我们也许不应该太假正经，但我们应当让自己的类严格遵守禁欲主义。

17． Alternative Classes with Different Interfaces
　　做相同事情的方法有不同的函数signature，一致把它们往类层次上移，直至协议一致。

18． Incomplete Library Class
　　要建立一个好的类库非常困难。我们大量的程序工作都基于类库实现。然而，如此广泛而又相异的目标对库构建者提出了苛刻的要求。库构建者也不是万能的。有时候我们会发现库类无法实现我们需要的功能。而直接对库类的修改有非常困难。这时候就需要用各种手段进行Refactoring。

19． Data Class
　　对象包括状态和行为。如果一个类只有状态没有行为，那么肯定有什么地方出问题了。

20． Refused Bequest
　　超类传下来很多行为和状态，而子类只是用了其中的很小一部分。这通常意味着你的类层次有问题。

21． Comments
　　经常觉得要写很多注释表示你的代码难以理解。如果这种感觉太多，表示你需要Refactoring。

安帛伟 2007-11-26 17:09 发表评论

static

安帛伟 — Tue, 20 Nov 2007 17:10:00 GMT

摘要: C++的static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。
阅读全文

安帛伟 2007-11-21 01:10 发表评论

一小段代码

安帛伟 — Fri, 09 Nov 2007 12:00:00 GMT

在网上看到这样一小段有意思的代码：

int main()
{
    int i;
    int a[10];
    for(i=0; i<=10; i++)
    {
        a[i]=0;
        printf("%d ",a[i]);
    }
    return 0;
}

这段代码里的错误很明显，数组a在循环时越界了。不过在VC6下编译运行后的结果很有意思，是个无限循环，知道为什么吗？

安帛伟 2007-11-09 20:00 发表评论

[ZZ] c++中的错误处理

安帛伟 — Thu, 18 Oct 2007 07:38:00 GMT

摘要: 处理在程序的运行时刻发生的错误，对于任何一个程序设计者来讲都是不陌生的。对于错误的处理，我们有很多方法，本篇着重介绍的是C++中的错误异常处理。阅读全文

安帛伟 2007-10-18 15:38 发表评论

哲学

安帛伟 — Mon, 15 Oct 2007 07:31:00 GMT

在网上搜索“什么是哲学”，最后发现哲学没有明确的定义（至少中文的没找到）。
不过以我的理解，哲学就是思辩。思考会让人认识到以前未认识到的东西，辩论则会减少思考过程中的错误认识。通过这样的手段，人类得以发展出现代科学体系。
一切建立在思辩基础之上的学科都是哲学的衍生学科，这包括所有的自然科学。计算机科学是自然科学的一个分支，所以也是哲学，这也就是为什么英文里的Ph.D(Doctor of Philosophy Degree 博士学位)是指所有自然科学的博士而非特指哲学专业的博士的原因。
有一个老游戏“文明”，游戏中最先研究出“哲学”的国家将直接进入“黄金时代”，生产力大大提高。这一点设计得非常切合实际，也说明了哲学在人类发展史上的重要性。
就中国来说，显然哲学这个词被“马克思主义哲学”所误用，一提哲学好像都与马克思主义有关，其实不然。“坚持XXXX不动摇”这一类的言论其本身就不具有思辩的特性。我并不是说XXXX不正确，只是如果不去辩论，怎么能知道XXXX是否正确呢；如果XXXX本身是正确的，那么辩论不是可以更好的体现出它的正确性吗？
中国经历了二千年的封建制度，在这二千年里中国显然没有发展出哲学，所以自然科学体系没有在中国历史中产生也就很正常了。“勾股定理”、四大发明等，这些可能是中国历史上为数不多的与自然科学相关的成果了，但是没有哲学，一切成果也没有办法进一步发展成科学体系了。中国的封建制度显然发展到了一个很高的高度，该体系应该说是很完善的：“君贵民轻”的教育制度；儒家思想被统治阶段所利用；中央集权与军队的使用。所有这些都延长了封建制度的存在时间，不得不说，中国人还是很聪明的，只可惜聪明反被聪明误。那些封建制度不那么完善的地方，会更早地发现封建制度的缺点，也就更早的产生新的政治制度。而哲学，则是新制度产生的基础，通过思辨，我们可以发现“‘君’其实并不那么贵，‘民’也并不是那么轻”；当统治阶段想要灌输某种有利于他们统治的思想时，思辩会帮助我们明辨是非。
事实上中国并非没有思辩，只不过思辨的思想没有占据统治地位，这一点一直到现在也是这样，不然为什么会有人删除我们的帖子呢？:P

安帛伟 2007-10-15 15:31 发表评论