C++博客-追梦无悔-文章分类-c++

const

HiHi..! — Fri, 16 Nov 2012 08:28:00 GMT

C++常类型(const)——Use const whenever you need
常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。因此，定义或说明常类型时必须进行初始化。
一般常量和对象常量
　　1. 一般常量
　　一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。如：
　　int const x=2;
　　或
　　const int x=2;
　　定义或说明一个常数组可采用如下格式：
　　<类型说明符> const <数组名>[<大小>]…
　　或者
　　const <类型说明符> <数组名>[<大小>]…
　　例如：
　　int const a[5]={1, 2, 3, 4, 5};
　　2. 常对象
　　常对象是指对象常量，定义格式如下：
　　<类名> const <对象名>
　　或者
　　const <类名> <对象名>
　　定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。
常指针和常引用
　　1. 常指针
　　使用const修饰指针时，由于const的位置不同，而含意不同。下面举两个例子，说明它们的区别。
　　下面定义的一个指向字符串的常量指针：
　　char * const prt1 = stringprt1;
　　其中，ptr1是一个常量指针。因此，下面赋值是非法的。
　　ptr1 = stringprt2;
　　而下面的赋值是合法的：
　　*ptr1 = "m";
　　因为指针ptr1所指向的变量是可以更新的，不可更新的是常量指针ptr1所指的方向(别的字符串)。
　　下面定义了一个指向字符串常量的指针：
　　const char * ptr2 = stringprt1;
　　其中，ptr2是一个指向字符串常量的指针。ptr2所指向的字符串不能更新的，而ptr2是可以更新的。因此，
　　*ptr2 = "x";
　　是非法的，而：
　　ptr2 = stringptr2;
　　是合法的。
　　所以，在使用const修饰指针时，应该注意const的位置。定义一个指向字符串的指针常量和定义一个指向字符串常量的指针时，const修饰符的位置不同。
      指向字符串的指针常量——const放在*后
      指向字符串常量的指针——const放在*前。
　　2. 常引用
　　使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：
　　const <类型说明符> & <引用名>
　　例如：
　　const double & v;
　　在实际应用中，常指针和常引用往往用来作函数的形参，这样的参数称为常参数。
在C++面向对象的程序设计中，指针和引用使用得较多，其中使用const修饰的常指针和常引用用得更多。使用常参数则表明该函数不会更新某个参数所指向或所引用的对象，这样，在参数传递过程中就不需要执行拷贝初始化构造函数，这将会改善程序的运行效率。
常成员函数
　　使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字说明的成员函数不能用来操作常对象。常成员函数说明格式如下：
　　<类型说明符> <函数名> (<参数表>) const；
其中，const是加在函数说明后面的类型修饰符，它是函数类型的一个组成部分，因此，在函数实现部分也要带const关键字。
常数据成员
      类型修饰符const不仅可以说明成员函数，也可以说明数据成员。
　　由于const类型对象必须被初始化，并且不能更新，因此，在类中说明了const数据成员时，只能通过成员初始化列表的方式来生成构造函数对数据成员初始化。
===============================================================================================
用途
1、用const修饰函数的参数
     对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率.例如将void Func(A a) 改为void Func(const A &a)；
     对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”.否则既达不到提高效率的目的，又降低了函数的可理解性。
2、用const修饰函数的返回值
     如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值
     如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值(即指针)的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针
     函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达
3、const成员函数
     任何不会修改数据成员的函数都应该声明为const类型.如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性
const赋值
[思考1]：以下的这种赋值方法正确吗？const A* c=new A();A* e = c;
这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针e指向的是一个常量，所以不正确；
[思考2]：以下的这种赋值方法正确吗？A* const c = new A();A* b = c;
这种方法正确，因为声明指针所指向的内容可变；
[思考3]：这样定义赋值操作符重载函数可以吗？const A& operator=(const A& a);
这种做法不正确；在const A::operator=(const A& a)中，参数列表中的const的用法正确，而当这样连续赋值的时侯，问题就出现了：A a,b,c:(a=b)=c;因为a.operator=(b)的返回值是对a的const引用，不能再将c赋值给const常量。
使用const的一些建议
1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
5 不要轻易的将函数的返回值类型定为const;6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

参考自：http://www.cppblog.com/mzty/archive/2005/11/09/1001.html

HiHi..! 2012-11-16 16:28 发表评论

volatile关键字

HiHi..! — Fri, 16 Nov 2012 07:33:00 GMT

volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

使用该关键字的例子如下：
int volatile nVint;
当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

例如：
volatile int i=10;
int a = i;
...
//其他代码，并未明确告诉编译器，对i进行过操作
int b = i;
volatile 指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。
注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：
首先，用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码：
#include
void main()
{
   int i=10;
   int a = i;
   printf("i= %d\n",a);
   //下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道
   __asm {
      mov dword ptr [ebp-4], 20h
   }

   int b = i;
   printf("i= %d\n",b);
}

然后，在调试版本模式运行程序，输出结果如下：

i = 10
i = 32

然后，在release版本模式运行程序，输出结果如下：

i = 10
i = 10

输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。下面，我们把 i的声明加上volatile关键字，看看有什么变化：
#include
void main()
{
   volatile int i=10;
   int a = i;
   printf("i= %d\n",a);
   __asm {
      mov dword ptr [ebp-4], 20h
   }
   int b = i;
   printf("i= %d\n",b);
}

分别在debug版本和release版本运行程序，输出都是：

i = 10
i = 32

这说明这个关键字发挥了它的作用！

参考自：http://www.cppblog.com/mzty/archive/2006/08/08/10959.html

HiHi..! 2012-11-16 15:33 发表评论

extern

HiHi..! — Fri, 16 Nov 2012 07:23:00 GMT

1、extern可以置于变量声明前；
2、extern也可以置于函数声明前；通过这种行为它告诉编译器：该变量/函数的定义已经存在在某个地方了，让编译器到其他的模块去寻找它的定义。
3、extern “C” 使用extern“C”主要是因为C++语言在编译的时候为了实现多态，会将函数名和函数结合起来形成另外一种函数名（总之就是说编译后的函数名与你之前自己声明时的函数名会不一样），而C语言中无多态的概念当然也就不会有这种奇异的名字变化问题。这是问题就出现了，当你要在C++中调用C函数时，由于名字的不同，所以它会找不到所调用的这个函数的定义，因而会出错。为了解决这一C与C++的矛盾冲突，就有了extern “C”。

参考自：http://www.cppblog.com/mzty/archive/2006/07/14/9834.html

HiHi..! 2012-11-16 15:23 发表评论

using 实例

HiHi..! — Fri, 16 Nov 2012 07:20:00 GMT

class CBase
{
   public print();
};
如果子类私有或保护继承自基类，那么此时子类的对象是不能调用基类公有的成员的。
class CChild : private CBase
{
}
void main()
{
   CChild child;
   child.print();//此时的print()为私有的，child 就不能调用
}
=====================================================
但是用using在子类中声明基类的公有成员后，此成员在子类中认为共有，可以访问。
class CChild : private CBase
{
public：
   using CBase::print();
}
void main()
{
   CChild child;
   child.print();
}

HiHi..! 2012-11-16 15:20 发表评论

虚函数理解

HiHi..! — Sat, 14 Jan 2012 04:34:00 GMT

      C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。然后在运行时决定选用父类函数还是子类函数。
   虚函数是通过一张虚函数表来实现的。虚函数表是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，反应了类中虚函数的真实对应关系。
   C++的编译器保证虚函数表的指针存在于对象实例中最前面的位置，这是为了保证取到虚函数表的有最高的性能。这意味着我们通过对象实例的地址得到虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。关于这些，下面有个清晰的说明。
   定义Base和Derive：

class Base
{
public:
    virtual void func1()
    {
        cout<<"base1()"<<endl;
    }
    virtual void func2()
    {
        cout<<"base2()"<<endl;
    }
};

class Derive : public Base
{
public:
    virtual void func1()
    {
        cout<<"derive1()"<<endl;
    }
};

int main()
{
    //定义函数指针Fun
    typedef void(*Function)(void);

    //定义Base对象
    Base base;

    Function pFunction = NULL;

    //验证虚函数表的指针存在于对象实例中最前面的位置
        pFunction = (Function)*((int*)*(int*)(&base));
    pFunction();//输出base1(),即pFunction为func1(),说明了虚函数表的指针存在于对象实例中最前面的位置.

    //同理
    pFunction = (Function)*((int *)*(int *)(&base)+1);
    pFunction();//输出base2();

    //同样的方法访问derive中的函数
    Derive derive;
    int** pVtab = (int**)&derive;
    pFunction = (Function)pVtab[0][0];
    pFunction();//由于被子类func1覆盖，输出derive1();
    pFunction = (Function)pVtab[0][1];
    pFunction();//输出base2();

    return 0;
}

虚函数表：

下面介绍下多重继承。
无覆盖：

子类实例中的虚函数表：

1)每个父类都有自己的虚表。
2)子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

有覆盖：
在子类中覆盖了父类的f()函数
子类实例中的虚函数表：

一些特别的说明：
通过父类型的指针访问子类自己的虚函数
在正上方这个图中，我们无法这样访问g1：
Base1 *b1 = new Derive();

b1->g1(); //编译出错

但是我们可以采用下面的方法，通过指针的方式访问虚函数。

Base *b = new Derive();
pFunction = (Function)*((int *)*(int *)(b) + 1);
pFunction();//Derive:g1();

通过子类类型的指针访问父类自己的私有虚函数

class Base {
private:
       virtual void f()
       {
          cout<< "Base::f"  << endl;
       }
};

class Derive : public Base
{
};

调用

Derive d;
Function  pFunction = (Function)*((int*)*(int*)(&d)+0);
pFunction();

参考自http://blog.csdn.net/liufei_learning/article/details/5443282

HiHi..! 2012-01-14 12:34 发表评论