const 用法

第一 const的作用

   （1）可以定义const常量         例如：

             const int Max=100;

             int Array[Max];        

const对默认是定义它文件的局部变量，此变量只存在于该文件中不会被其他文件访问，通过制定const变量为extern,就可以在整个程序中使用const对象。

   （2）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。

        还是上面的例子，如果在函数体内修改了i，编译器就会报错；

        例如： 

             void f(const int i) { i=10;//error! }

   （3）修饰类的成员函数：

        const修饰符也可以修饰类的成员函数，格式如下：

            class ClassName 

         {

             public:

            　    　int Fun() const;

            　       .....

             }；

        这样，在调用函数Fun时就不能修改类里面的数据 

若在这种情况下，想要改变类的成员变量，只需用mutalbe 来修饰该成员变量   

   （4）修饰指针

        const int *A;   或  int const *A; //const修饰指向的对象，A可变，A指向的对象不可变

        int *const A; 　            //const修饰指针A，     A不可变，A指向的对象可变 

        const int *const A;      //指针A和A指向的对象都不可变

   （5）修饰引用

 　　     const double & v;      该引用所引用的对象不能被更新

　 （6）修饰函数的返回值：

        const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下：

            const int Fun1(); 

            const MyClass Fun2();

 

（8）放在类内部的常量有什么限制？

  

        class A

        {

         private:

           const int c3 = 7;               // err

           static int c4 = 7;               // err

           static const float c5 = 7;  // err

          ......

  };

 初始化类内部的常量

        1 初始化列表：

         class A

         {

          public:

                A(int i=0):test(i) {}

          private:

                const int i;

          }；

         2 外部初始化，例如：

         class A

         {

          public:

                A() {}

          private:

                static const int i;  

          }；

          const int A::i=3;  

另外一种方式：

        class A

         {

          public:

                A() {}

          private:

                static const int i=3;  

          };

(9)const 对象默认为文件的局部变量

 

第五题   const引用

 Const对象是指向const对象的引用。

const int ival=1024;

const int &refval=ival;//正确const引用用const对象来初始化

Int &ref2=ival;//错误，不能把const对象付给一个非const引用

const 引用可以初始化为不同类型的对象或者初始化为右值，如下所示：

int i=42;

const int &r=i;

const int &r2=r+i;

cout<<r2<<endl;

double dval=3.14;

const int &j=dval;

cout<<j<<endl;

非const引用只能绑定到与该引用同类型的对象

double  i=42.5;

const int &temp=i;

cout<<temp<<endl; 成功

double  i=42.5;

int &temp=i;

cout<<temp<<endl; 失败

第六题 const指针

1. 指向const对象的指针

 Const double *cptr;这里cptr是指向double类型的const指针。不能通过cpt改变所指对象的值，定义时不需要初始化。

Const int a=3;

Const double *cptr=&a;

*cptr=43;//这是错误的

Cptr一经赋值就不能改变其所指对象的值。允许把非const对象的地址赋给指向const对象的指针。

Doube dval=3.14

Const 形参

在调用函数时，如果该函数使用非引用的非const形参，则可以给该函数传递const实参，相当于用const实参来初始化非const对象

void func(int i)

{

 cout<<i<<endl;

}

int main()

{

const int a=3;

func(a);

getchar();

return 0;

}

如果形参是const 形参，则实参仍然既可以const对象，也可以是非const对象

void func(const int i)

{

 cout<<i<<endl;

}

int main()

{

int a=3;

func(a);

getchar();

return 0;

}

引用形参

普通的形参修改的仅是局部副本。

利用const引用避免复制，并且避免了改变值。

int func(const string &s1,const string &s2)

{

return s1.size()<s2.size()?1:-1;

}

int main()

{

string s1("hello"),s2("what");

int isShort=func(s1,s2);

cout<<isShort<<endl;

getchar();

return 0;

}

非const引用形参只能与完全同类型的非const对象关联。

void func(int &a)

{

cout<<a<<endl;

}

int main()

{

//short a=10; //error

int a=10; 

func(a);

getchar();

return 0;

}

应该将不需要修改的引用形参定义为const引用，普通的非const引用形参在使用时不太灵活，这样的形参既不能使用const对象初始化，也不能使用字面值或产生右值的表达式实参初始化。

void func(const int &a) //如果这儿是非const引用形参则会报错

{

cout<<a<<endl;

}

int main()

{

func(10);

getchar();

return 0;

}