1. 定義常量

1.1 C語言中定義常量的方法

在C語言從零開始這個系列中，我們講了C語言定義常量的方法。沒有看過的同學(xué)請參考：C語言從零開始（五）-常量&變量

為什么要定義常量我就不再贅述了，這里重點說說這么定義有什么不好。經(jīng)常有這樣的面試題：請寫出下面這段代碼的執(zhí)行結(jié)果：

#include <stdio.h>

#define SUM 5 + 1;

void main()
{
  int a = 2 * SUM;
  printf("%d", a);
}

經(jīng)常有人答12，其實結(jié)果是11。不信你用計算機運行一下試試。

為什么會錯呢，因為#define定義的常量是偽常量，它在參加編譯時做的是原樣字符替換。就是2 * SUM這句在編譯器看來應(yīng)該是

int a = 2 * 5 + 1；


如果你的本意是想得到12，那么定義中應(yīng)該這么寫：

#define SUM (5 + 1);


這樣的經(jīng)典錯誤很多人都犯過，雖然道理大家都知道，但是總會因為粗心大意掉進(jìn)這個坑里。

于是，C++引入const常量徹底解決了這個問題。后來部分C語言的編譯器也開始支持const的使用，這就充分說明了它的價值。

1.2 const常量

在C++中，我們用下面的形式定義常量：

const int MONTH = 12;
const int SUM = 5 + 1;

嚴(yán)格意義上講，const常量應(yīng)該叫做“常變量”，它定義了一個值不會被修改的變量。

為了代碼風(fēng)格統(tǒng)一，我們依然習(xí)慣把const常量用全大寫字母命名。

特點

const常量與普通常量最大的不同有兩點：

值不能改變
可以用作數(shù)組大小的定義
例如：

const int MAX = 10;
int arr[MAX] = {0};
for (int i = 0; i < MAX; i++)
{
  // Do something
}

1.3 作用范圍

const定義的常量的作用域類似與static，只能被當(dāng)前文件訪問。如果想在其他文件中使用該如何寫呢？

// file1
const int MAX = 10;
// file 2
extern const int MAX;

不過并不推薦這么使用，還是建議大家把const定義寫在頭文件中，在需要的文件中包含這個頭文件。

2. 指針與const

const的修飾特點是修飾離它最近的部分。它一般有兩種用法。

2.1 指向const變量的指針

讓指針指向一個const對象，防止指針修改所指向的值。

int age = 30;
const int* ptr = &age;

這段代碼定義了一個指針ptr，它指向一個const int類型的數(shù)據(jù)，不可修改。

  *ptr += 1;  // 報錯
  cin >> *ptr;  // 報錯

這兩種寫法都是非法的。

注意：依然可以用 age變量修改。

2.2 const指針

將指針本身聲明為一個常量，防止指針位置改變

int a = 3;
int* const p = &a;

p++; // 錯誤

注意：只有const指針能夠指向const變量，例如：

const int a = 9;
const int* p = &a;   // 正確
int* ptr = &a;     //錯誤

特殊使用：

const int* const p = &a;


這句話的意思是指針變量和指向的地址中的內(nèi)容都不可變

3. 函數(shù)與const

3.1 const參數(shù)

如果希望參數(shù)在函數(shù)內(nèi)部不被修改，可以用const修飾，如下：

void fun(const int a)
{
  a++; // 非法操作
}

由于a被const修飾為常變量，因此再對它進(jìn)行a++操作就會報錯。

這種寫法的目的只是為了限制參數(shù)在函數(shù)內(nèi)部的修改，如今越來越多的人喜歡這樣實現(xiàn)：

void fun(int a)
{
  const int& b = a;
  b++; // 非法操作 
}

效果是完全一樣的。

3.2 const返回值

如果函數(shù)返回值是一個基本數(shù)據(jù)類型，用const修飾是沒有意義的。比如：

const int fun()
{
  return 1;
}

fun()函數(shù)的返回值是不可能做“左值”再被修改的，因為沒人會這么使用：

fun() = 2;
編譯器也會把這種寫法先過濾掉。

一般，const只用來修飾返回值是一個類的對象的函數(shù)。例如：

class A
{
public:
  A()
  {
    m_i = 0;
  }

  A(int i) : m_i(i){}

  void Modify(int i)
  {
    m_i = i;
  }

private:
  int m_i;
};

A GetA()
{
  return A(1);
}

const A GetConstsA()
{
  return A(1);
}

void Update(A& a)
{
  a.Modify(2);
}

void Update2(const A& a)
{
  A m = a;
  m.Modify(2);
}

int main()
{
  GetA() = A(1);    // 正確
  GetA().Modify(5);  // 正確

  GetConstsA() = A(1);   // 報錯
  GetConstsA().Modify();  // 報錯

  Update(GetA());      // 正確
  Update(GetConstsA());  // 報錯
  Update2(GetConstsA());  // 正確

  return 0;
}

能看懂其中的奧秘嗎？總結(jié)一下，const修飾的返回值如果是類的對象，那么：

這個返回值不能做左值（放在等號左邊被賦值或者調(diào)用其成員函數(shù)）
這個返回值的別名必須也被const修飾

4. 舉一反三

知道了一般參數(shù)和返回值被const修飾的情況，我們應(yīng)該能夠推導(dǎo)出const修飾指針參數(shù)和返回值的情況。我們用一段代碼來看看容易出現(xiàn)的錯誤。

void fun1(int* p)
{
  // Do nothing
}

void fun2(const int* cp)
{
  *cp = 3; // 錯誤
  int i = *cp; 
  int* ip2 = cp; // 錯誤
}

const char* fun3()
{
  return "result of function fun3()";
}

const int* const fun4()
{
  static int i;
  return &i;
}

int main()
{
  int x = 0;
  int* p = &x;
  const int* cp = &x;

  fun1(p);
  fun1(cp); // 錯誤

  fun2(p);
  fun2(cp);

  char* cp = fun3();  // 錯誤
  const char* ccp = fun3();

  int* p2 = fun4(); // 錯誤
  const int* const ccp = fun4();
  const int* cp2 = fun4();
  *fun4() = 1; // 錯誤

  return 0;
}

這段程序的各種賦值其實完全符合第2部分中介紹的原則。在傳參和賦值的過程中需要注意：

指針內(nèi)容被const修飾時，*p不可修改
指針內(nèi)容被const修飾時，不能賦值給內(nèi)容非const的指針
指針變量和內(nèi)容都被const修飾時，只能給相同情況的指針賦值
說起來有些拗口，仔細(xì)想想其實和第二部分所講的內(nèi)容相似。

OK，今天就先到這里。

最新評論