const 的用法總結

一、const用在函數中：

注意：const 類型只能賦值給const類型

如下幾種運用方式

                 A& operator=(const A& a); 
                void fun0(const A* a ); 
                void fun1( ) const; // fun1( ) 為類成員函數 
                const A fun2( );

1. const 用在函數的返回類型中，一般情況下，不用這種返回類型。

   const A fun2( );
   

2.類的成員函數后面加 const，表明這個函數不會對這個類對象的數據成員（準確地說是非靜態數據成員）作任何改變。 void fun1( ) const;

在設計類的時候，一個原則就是對于不改變數據成員的成員函數都要在后面加 const，而對于改變數據成員的成員函數不能加 const。所以 const 關鍵字對成員函數的行為作了更加明確的限定：有 const 修飾的成員函數（指 const 放在函數參數表的后面，而不是在函數前面或者參數表內），只能讀取數據成員，不能改變數據成員；沒有 const 修飾的成員函數，對數據成員則是可讀可寫的。

除此之外，在類的成員函數后面加 const 還有什么好處呢？那就是常量（即 const）對象可以調用 const 成員函數，而不能調用非const修飾的函數。

#include<iostream>

using namespace std;

class A{

public:

A(int a=0 ,int b=0 );

const A& operator=(const A& a);

friend ostream& operator<<(ostream &os, const A& a);

friend const A operator+(const A& a, const A& b);

void setA(int ,int );

int getb()const{ return b; }//一般情況不修改數據成員的函數都要修飾成cosnt

int getc()const{ return c; }

private:

int b, c;

};

const A operator+(const A &x, const A& y){//這里聲明返回類型中加上const目的

//防止a+b=c.這種情況通過

A m;

m.b = x.b + y.b;

m.c = x.c + y.b;

return m;

}

ostream& operator<<(ostream &os, const A& a){

os << a.b << endl;

os << a.c << endl;

return os;

}

A::A(int m, int n){ setA(m, n); }

void A::setA(int m,int n){

b = m;

c = n;

}

const A& A::operator =(const A& a){//一般不加const

b = a.b;

c = a.c;

return *this;

}

const A& max(const A& v1, const A& v2){//這里參數都被聲明為const引用。所以返回值也為

//const 修飾的類，只能調用const修飾的函數！

if (v1.getb()>v2.getb()){ return v1; }

else

{

return v2;

}

}

int main(){

const int s = 2;//聲明一個變量時必須進行初始化

//const int d;報錯must be initialed if not extern;

A a(2,3), b, c;

c=b=a;

//(c = b) = a;錯誤的因為（c=b）返回一個const值無法在被賦值。

cout <<"第一次\n"<< a<<b<<c<<endl;

b.setA(10, 5);

c = max(b, c);

cout << "第二次\n"<<a << b << c << endl;

c = a + b;

//a + b = c;這里a+b返回類型被聲明為const A ,所以創建的對象不可以被賦值。

system("pause");

return 0;

}

二、const 用在變量中

1.const 修飾的全局變量是具有內部鏈接性！在這點上與static 修飾全局變量相似。

2.const修飾變量一般有兩種方式：const T *a，或者 T const *a

看*號的位置：const T *a 指一個指針a 指向 const修飾的 T類型變量。

a可以被賦值但是 *a就不可以復制。

#include<iostream>

using namespace std;

int main(){

const int v1 = 3;

//int * p1 = &v1;錯誤的，因為不能修改，你用一個指向可以修改的int型的指針肯定不可以

int v2 = 3;

const int *p2 = &v2;

//很微妙，不可以用*p2修改v2。

//*p2 = 2;錯誤

v2 = 4;//正確；

const int v3 = 3;

const int *p3 = &v3;//這種情況下通過*p3 或v3都無法修改v3的值。

//v3 = 4;錯誤

//*p3 = 4;錯誤

p3 = p3 + 1;//這個卻可以編譯通過

const int v4 = 3;

const int * const p4 = &v4;

//p4 = p4 + 1;invalid p4指針的指向 不允許改變

}

3.const 變量聲明時必須初始化。

但是若是在類里聲明的注意：因為類可以創建多個對象，不同的對象其const數據成員的值可以不同。所以不能在類聲明中初始化const數據成員

class A 
{ 
const int size = 100;    //錯誤 

int array[size];        //錯誤，未知的size 

} 

三、 const 的好處：

  可以避免不必要的內存分配 
  #define STRING "abcdefghijklmn\n" 
  const char string[]="abcdefghijklm\n"; 
  ... 
  printf(STRING);  //為STRING分配了第一次內存 
  printf(string);  //為string一次分配了內存，以后不再分配 
  ... 
  printf(STRING);  //為STRING分配了第二次內存 
  printf(string); 
  ... 
  由于const定義常量從匯編的角度來看，只是給出了對應的內存地址， 
  而不是象#define一樣給出的是立即數，所以，const定義的常量在 
  程序運行過程中只有一份拷貝，而#define定義的常量在內存中有 
  若干個拷貝。