2.const修饰指针

第一种情况：const int *ptr=&a; ptr为指向常量的指针，其所指的值不可修改，但是其所指向的地址可以修改。

第二种情况：int * const ptr=&a；ptr为常量指针，其所指的地址不可被修改，但是其所指的值可以被修改。

第三种情况：const int * const ptr=&a，ptr为指向常量的常量指针，其所指向的地址不可修改，其所指向的值也不可修改。

 1#include <iostream>
 2using namespace std ;
 3
 4int main()
 5{
 6
 7    int a=1;
 8    int b=2;
 9    int c=3;
10    int d=4;
11
12
13    //第一种情况:
14    const int * ptr_one=&a;
15
16    // *ptr_one=3; 错误ptr为指向常量的指针，其所指的值不能修改
17
18    ptr_one=&b;//正确，ptr所指向的地址可以修改
19
20
21    //第二种情况:
22    int *const ptr_two=&c;
23
24    //ptr_two=&d;//错误，ptr_two为常量指针，其所指的地址不可修改
25
26    *ptr_two=4;//正确，prt_two所指向的值可以修改
27
28
29    //第三种情况：
30    const int * const ptr_three=&a;
31
32    //*ptr_three=5; 错误：ptr_three为指向常量的常量指针，其所指向的值不可修改
33
34    //ptr_three=&b;  错误：ptr_three所指向的地址不可修改
35
36
37}

3.const 用于函数参数
直接看实例：

 1void fun_one(const int * r)
 2{
 3
 4//*r=1;//错误，不能在函数内改变r所指向的值
 5
 6}
 7
 8void fun_two(int * const r)
 9{
10
11//r=new int(1);//错误，不能改变r所指向的地址
12
13}
14
15void fun_three(const int r)
16{
17
18//r=1;//错误，不能改变r的值
19
20}

4.const 对于类

{1}对于const 修饰的类成员变量，只能在构造函数的参数初始化表里对其进行初始化，否则会引起编译错误。

（2）对于const 修饰的成员函数 ，如 int Fun（int a）const，这样声明之后任何企图在函数内部修改成员变量的值或者调用非const成员函数都会引起编译错误。

（3）对于const声明的用户自定义类的对象，如果调用这个类的非const成员函数，将会引起编译错误，编译器会保证在const对象的生命期内不被改变。

如果const对象一定要调用此函数的话，那就将此函数声明为const。
实例：

 1#include <iostream>
 2using namespace std ;
 3
 4class Test
 5{
 6public:
 7    
 8    Test():const_value(0)
 9    {
10        value=0;
11    }
12
13    
14
15    Test(int i,int m):const_value(m)
16    {
17        value=i;
18    }
19
20void    PrintValue() const
21    {
22    cout<<"\nValue的值为："<<value;
23    
24    }
25
26private:
27    int value;
28    const int const_value;
29
30};
31
32
33int main()
34{
35
36Test a(5,5);
37a.PrintValue();
38
39const Test b(6,6);
40b.PrintValue();
41
42}

原文网址:  http://blog.csdn.net/classfactory/archive/2004/08/29/87749.aspx

C++ 中的枚举类型继承于 C 语言。就像其他从 C 语言继承过来的很多特性一样，C++ 枚举也有缺点，这其中最显著的莫过于作用域问题——在枚举类型中定义的常量，属于定义枚举的作用域，而不属于这个枚举类型。例如下面的示例：

enum FileAccess {
    Read = 0x1,
    Write = 0x2,
};

FileAccess access = ::Read; // 正确
FileAccess access = FileAccess::Read; // 错误

C++枚举的这个特点对于习惯面向对象和作用域概念的人来说是不可接受的。首先，FileAccess::Read 显然更加符合程序员的直觉，因为上面的枚举定义理应等价于如下的定义（实际上，.NET 中的枚举类型便是如此实现的）：

class FileAccess {
    static const int Read = 0x1;
    static const int Write = 0x2;
};

其次，这导致我们无法在同一个作用域中定义两个同样名称的枚举值。也就是说，以下的代码是编译错误：

enum FileAccess {
    Read = 0x1,
    Write = 0x2,
};

enum FileShare {
    Read = 0x1, // 重定义
    Write = 0x2, // 重定义
};

如果这一点没有让你恼怒过的话，你可能还没写过多少 C++ 代码 :-)。实际上，在最新的 C++0x 标准草案中有关于枚举作用域问题的提案，但最终的解决方案会是怎样的就无法未卜先知了，毕竟对于象 C++ 这样使用广泛的语言来说，任何特性的增删和修改都必须十分小心谨慎。

当然，我们可以使用一些迂回的方法来解决这个问题（C++ 总是能给我们很多惊喜和意外）。例如，我们可以把枚举值放在一个结构里，并使用运算符重载来逼近枚举的特性：

struct FileAccess {
    enum __Enum {
        Read = 0x1,
        Write = 0x2
    };
    __Enum _value; // 枚举值

    FileAccess(int value = 0) : _value((__Enum)value) {}
    FileAccess& operator=(int value) {
        this->_value = (__Enum)value;
        return *this;
    }
    operator int() const {
        return this->_value;
    }
};

我们现在可以按照希望的方式使用这个枚举类型：

FileAccess access = FileAccess::Read;

并且，因为我们提供了到 int 类型的转换运算符，因此在需要 int 的地方都可以使用它，例如 switch 语句：

switch (access) {
    case FileAccess::Read:
        break;
    case FileAccess::Write:
        break;
}

当然我们不愿意每次都手工编写这样的结构。通过使用宏，我们可以很容易做到这一点：

#define DECLARE_ENUM(E) \
struct E \
{ \
public: \
    E(int value = 0) : _value((__Enum)value) { \
    } \
    E& operator=(int value) { \
        this->_value = (__Enum)value; \
        return *this; \
    } \
    operator int() const { \
        return this->_value; \
    } \
\
    enum __Enum {

#define END_ENUM() \
    }; \
\
private: \
    __Enum _value; \
};

我们现在可以按如下的方式定义前面的枚举，并且不比直接写 enum 复杂多少。

DECLARE_ENUM(FileAccess)
    Read = 0x1,
    Write = 0x2,
END_ENUM()

DECLARE_ENUM(FileShare)
    Read = 0x1,
    Write = 0x2,
END_ENUM()

--------------指针----------------
int a=10;
int *p=&a;

-------------指针的指针-----------
int b=20;
int *p=&b;
int **p2p=&p;

-------------简单数组-----------------
int c[10];//整数数组，含有10个整数元素
也就是说每一个元素都是整数

--------------指针数组--------------------
int *p[10];//指针数组，含有10个指针元素
也就是说每一个元素都是指针

--------------数组指针--------------------
int (*p)[10];//数组指针，这个指针能够用来指向
含有10个元素的整数数组

------------函数指针---------------------

int (*p)( ); // 指向函数的指针...这里声明了一个指针p，该指针指向返回值是整型（即函数类型为整型）的函数！

----------------指针函数---------------------------

int *p(int a,float b); //返回值为指针的函数...该函数返回指向整型变量的指针！

即该函数的类型为int *, p和上例不同，他是函数名！上例中是指针！

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

C/C 中函数指针的含义

作者：管宁

　　函数存放在内存的代码区域内，他们同样有地址，我们如何能获得函数的地址呢？

　　假如我们有一个int test(int a)的函数，那么，他的地址就是函数的名字，这一点如同数组相同，数组的名字就是数组的起始地址。

　　定义一个指向函数的指针用如下的形式，以上面的test()为例：

int (*fp)(int a);//这里就定义了一个指向函数的指针

　　函数指针不能绝对不能指向不同类型，或是带不同形参的函数，在定义函数指针的时候我们很容易犯如下的错误。

int *fp(int a);//这里是错误的，因为按照结合性和优先级来看就是先和()结合，然后变成了一个返回整形指针的函数了，而不是函数指针，这一点尤其需要注意！

　　下面我们来看一个具体的例子：

#include <iostream>
#include <string>
using namespace std;

int test(int a);

void main(int argc,char* argv[])
{
cout<<test<<endl;//显示函数地址
int (*fp)(int a);
fp=test;//将函数test的地址赋给函数学指针fp
cout<<fp(5)<<"|"<<(*fp)(10)<<endl;
//上面的输出fp(5),这是标准c 的写法,(*fp)(10)这是兼容c语言的标准写法,两种同意,但注意区分,避免写的程式产生移植性问题!
cin.get();
}

int test(int a)
{
return a;
}

　　typedef定义能够简化函数指针的定义，在定义一个的时候感觉不出来，但定义多了就知道方便了，上面的代码改写成如下的形式：

#include <iostream>
#include <string>
using namespace std;

int test(int a);

void main(int argc,char* argv[])
{
cout<<test<<endl;
typedef int (*fp)(int a);//注意,这里不是生命函数指针,而是定义一个函数指针的类型,这个类型是自己定义的,类型名为fp
fp fpi;//这里利用自己定义的类型名fp定义了一个fpi的函数指针!
fpi=test;
cout<<fpi(5)<<"|"<<(*fpi)(10)<<endl;
cin.get();
}

int test(int a)
{
return a;
}

　　函数指针同样是能够作为参数传递给函数的，下面我们看个例子，仔细阅读您将会发现他的用处，稍加推理能够很方便我们进行一些复杂的编程工作。

//-------------------该例以上一个例子作为基础稍加了修改-----------------------------
#include <iostream>
#include <string>
using namespace std;

int test(int);

int test2(int (*ra)(int),int);

void main(int argc,char* argv[])
{
cout<<test<<endl;
typedef int (*fp)(int);
fp fpi;
fpi=test;//fpi赋予test 函数的内存地址

cout<<test2(fpi,1)<<endl;//这里调用test2函数的时候,这里把fpi所存储的函数地址(test的函数地址)传递了给test2的第一个形参
cin.get();
}

int test(int a)
{
return a-1;
}

int test2(int (*ra)(int),int b)//这里定义了一个名字为ra的函数指针
{
int c=ra(10) b;//在调用之后,ra已指向fpi所指向的函数地址即test函数
return c;
}