const 的用法總結

一、const用在函數中：

注意：const 類型隻能指派給const類型

如下幾種運用方式

                 A& operator=(const A& a); 

                void fun0(const A* a ); 

                void fun1( ) const; // fun1( ) 為類成員函數 

                const A fun2( );

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就不可以複制。

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定義的常量在記憶體中有 

  若幹個拷貝。

本文轉自 神迹難覓 51CTO部落格，原文連結：http://blog.51cto.com/ji123/1916799，如需轉載請自行聯系原作者