1.定义程序中频繁使用的常量
 
#include <iostream>
using namespace std;

const double PI=3.1415926;
int main()
{
        cout<<"圆的面积是:"<<PI*3*3<<endl;
        cout<<"周长是:"<<2*PI*3<<endl;
        return 0;
}
 
和define定义宏相比,这个具有运行时检验且是类型安全的。
 
2.用在类成员之前修饰:
 
#include <iostream>
using namespace std;

class Test
{
private:
        const int i;//注意这个是对象生命期内保持值不变
public:
        Test(int ii):i(ii){}
        void demo();

        void error();//error
};

void Test::demo()
{
        cout<<i*i<<endl;
}
void Test::error()
{
        i=0;//error:不能修改只读成员
}
int main()
{
        Test t1(10);
        t1.demo();

        Test t2(50);
        t2.demo();
        return 0;
}
 
这种const为我们提供了一种,为对象提供只读属性的方式,注意,const的成员是在成员初始化列表里初始化的。
 
3.如果是类的所有实例对象共用的常量,那么如下:
 
#include <iostream>

using namespace std;

class Test
{
private:
        static const int i=100;//所有类实例共用
public:
        Test(){};
        void demo();
};

void Test::demo()
{
        cout<<i<<endl;
}


int main()
{
        Test t1;
        t1.demo();//100

        Test t2;
        t2.demo();//100

        return 0;
}
 
注意这里初始化在定义处。
 
4.const和指针结合使用
 
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        const int *p=&a;
        cout<<*p<<endl;

        *p=456;//error:不能修改p执行的内存
        return 0;
}
 
这里我们发现p指向的内容是不允许修改的,是只读的。
于是这里可看作p指向的类型是"const int"的,换句话说*p是个const int是不可变,当然并没有const int的类型。
 
我们交换下int和const:
 
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        int const *p=&a;
        cout<<*p<<endl;

        *p=456;//error:不能修改p执行的内存
        return 0;
}
 
发现和上面一样,之所以这样是因为我们怎么改都是,处在*的左侧,改变不了p指向(*可以理解为指向)的数据是个int const的,不可变的。
 
好那就放在*右面
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        int* const p=&a;
        cout<<*p<<endl;//123

        *p=456;

        cout<<a<<endl;//456
        return 0;
}
 
现在是const p指向一个int类型的数据,这里const修饰的是指针p.
所以说是p的值不允许改变。
如:
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        int b=789;
        int* const p=&a;
        cout<<*p<<endl;//123

        *p=456;

        cout<<a<<endl;//456

        p=&b;//error:p不允许修改,只读指针
        return 0;
}
 
 
自然而然的大家就能理解下面的代码了:
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        int b=789;
        const int* const p=&a;
        cout<<*p<<endl;//123

        *p=456;//error
        p=&b;//error

        return 0;
}
 
5.const结合引用
 
引用大家可能不陌生
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        int &b=a;
        b=456;//b可以看作是a的别名,指向同一个内存

        cout<<a;//456
        return 0;
}
 
有点像const指针:
 
比较下
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        int &b=a;
        b=456;//b可以看作是a的别名,指向同一个内存

        int* const c=&a;
        *c=789;

        cout<<a;//789
        return 0;
}
 
不过引用因此了指针存储地址的特性,比较隐蔽,看作别名,在c++中可是大行其道啊。常常使用。
 
注意:引用定义时需要初始化,而且之后不能再引用其他变量。
 
看一下const和引用使用:
 
#include <iostream>
using namespace std;

int main()
{
        int a=123;
        const int &b=a;

        //b=456;//error:b引用的地方不可以修改

        a=456;//不过通过a是可以修改的,只是说不能由b修改
        return 0;
}
 
 
6.const与函数
 
看看这个
#include <iostream>
using namespace std;

void f(int i)
{
        cout<<i*i<<endl;
}
int main()
{
        int a=11;
        f(a);//121

        return 0;
}
 
这里我们的函数只是输出参数的计算值,传递参数的方式是copy方式。
 
接着换成引用方式:
#include <iostream>
using namespace std;

void f(int &i)
{
        cout<<i*i<<endl;
}
int main()
{
        int a=11;
        f(a);//121

        return 0;
}
换成了引用,结果没有什么变化。
但是如果参数的类型是个复杂的类型,比如自定义对象。那么引用可以节省不少在copy上所花的开销。
 
然而出现一个新的问题:
 
由于引用持有原实参同样的内存区,混参数副作用,我们的函数可能无意间修改了原对象,不仅危险而且出错时排错也比较困难,于是养成一个使用const的习惯,对于我们实现知道有些函数根本不应该修改实参时:
#include <iostream>
using namespace std;

void f(const int &i)
{
        cout<<i*i<<endl;
}
int main()
{
        int a=11;
        f(a);//121

        return 0;
}
 
于是
如果
void f(const int &i)
{
    i=12;//error
    cout<<i*i<<endl;
}
会报错的。
 
其实函数的返回值也可以用const限制的,什么,这个还需要吗?
 
看看下面的代码:
#include <iostream>
using namespace std;

int f(int &i)
{
        i=12;
        return i;
}
int main()
{
        int a=11;

        cout<<f(a);//12
        return 0;
}
 
没有什么特殊之处吧,接着改改:
#include <iostream>
using namespace std;

int& f(int &i)
{
        i=12;
        return i;
}
int main()
{
        int a=11;

        cout<<f(a);//12
        return 0;
}
 
返回引用,结果没什么变化吧。
但是现在f(a)返回了a的引用,可能会有被修改的危险!!!
 
#include <iostream>
using namespace std;

int& f(int &i)
{
        i=12;
        return i;
}
int main()
{
        int a=11;

        f(a)=33;

        cout<<a;//33
        return 0;
}
 
这里f(a)可以做左值,有时候我们并不希望这样的事情发生,于是const发挥了:
#include <iostream>
using namespace std;

const int& f(int &i)
{
        i=12;
        return i;
}
int main()
{
        int a=11;

        f(a)=33;//error
        return 0;
}
 
 
7.const对象和const 成员函数
 
#include <iostream>
using namespace std;

class Test
{
private:
        int i;
public:
        Test(int ii){i=ii;};
        void setVal(int i){this->i=i;}
        void echoVal(){cout<<i<<endl;}
};

int main()
{
        Test a(123);
        a.setVal(456);
        a.echoVal();//456
        return 0;
}
 
没有什么特殊之处吧.
 
但是如果我们想要const Test a(123);这样的常量对象,他的成员不允许修改,编译器可以实现这些,只需标识其成员只读即可。
然而怎么知道哪些函数可以安全调用呢,默认可能他认为所有方法对自己不利,不能调用,可是我们如果想调用一些方法(这些方法实际并不会带来什么危险)怎么办呢,于是需要和其他方法区别开来,于是有了const成员函数,
const对象只能调用const成员函数(构造析构函数除外):
 
#include <iostream>
using namespace std;

class Test
{
private:
        int i;
public:
        Test(int ii){i=ii;};
        void setVal(int ii){i=ii;}
        void echoVal()const{cout<<i<<endl;}
};

int main()
{
        const Test a(123);
        a.echoVal();//123
        return 0;
}