此篇部落格來自http://www.runoob.com/cplusplus/cpp-variable-scope.html

感謝！！！

C++ 資料型別

使用程式語言進行程式設計時，需要用到各種變數來儲存各種資訊。變數保留的是它所儲存的值的記憶體位置。這意味著，當您建立一個變數時，就會在記憶體中保留一些空間。

您可能需要儲存各種資料型別（比如字元型、寬字元型、整型、浮點型、雙浮點型、布林型等）的資訊，作業系統會根據變數的資料型別，來分配記憶體和決定在保留記憶體中儲存什麼。

根據變數的型別指示記憶體大小和儲存內容。

1.基本的內建型別

C++ 為程式設計師提供了種類豐富的內建資料型別和使用者自定義的資料型別。下表列出了七

一些基本型別可以使用一個或多個型別修飾符進行修飾：

• signed
• unsigned
• short
• long

下表顯示了各種變數型別在記憶體中儲存值時需要佔用的記憶體，以及該型別的變數所能儲存的最大值和最小值。

注意：不同系統會有所差異。

從上表可得知，變數的大小會根據編譯器和所使用的電腦而有所不同。

下面例項會輸出您電腦上各種資料型別的大小。

//例項
#include<iostream>  
#include<string>  
#include <limits>  
using namespace std;  
  
int main()  
{  
    cout << "type: \t\t" << "************size**************"<< endl;  
    cout << "bool: \t\t" << "所佔位元組數：" << sizeof(bool);  
    cout << "\t最大值：" << (numeric_limits<bool>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<bool>::min)() << endl;  
    cout << "char: \t\t" << "所佔位元組數：" << sizeof(char);  
    cout << "\t最大值：" << (numeric_limits<char>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<char>::min)() << endl;  
    cout << "signed char: \t" << "所佔位元組數：" << sizeof(signed char);  
    cout << "\t最大值：" << (numeric_limits<signed char>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<signed char>::min)() << endl;  
    cout << "unsigned char: \t" << "所佔位元組數：" << sizeof(unsigned char);  
    cout << "\t最大值：" << (numeric_limits<unsigned char>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<unsigned char>::min)() << endl;  
    cout << "wchar_t: \t" << "所佔位元組數：" << sizeof(wchar_t);  
    cout << "\t最大值：" << (numeric_limits<wchar_t>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<wchar_t>::min)() << endl;  
    cout << "short: \t\t" << "所佔位元組數：" << sizeof(short);  
    cout << "\t最大值：" << (numeric_limits<short>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<short>::min)() << endl;  
    cout << "int: \t\t" << "所佔位元組數：" << sizeof(int);  
    cout << "\t最大值：" << (numeric_limits<int>::max)();  
    cout << "\t最小值：" << (numeric_limits<int>::min)() << endl;  
    cout << "unsigned: \t" << "所佔位元組數：" << sizeof(unsigned);  
    cout << "\t最大值：" << (numeric_limits<unsigned>::max)();  
    cout << "\t最小值：" << (numeric_limits<unsigned>::min)() << endl;  
    cout << "long: \t\t" << "所佔位元組數：" << sizeof(long);  
    cout << "\t最大值：" << (numeric_limits<long>::max)();  
    cout << "\t最小值：" << (numeric_limits<long>::min)() << endl;  
    cout << "unsigned long: \t" << "所佔位元組數：" << sizeof(unsigned long);  
    cout << "\t最大值：" << (numeric_limits<unsigned long>::max)();  
    cout << "\t最小值：" << (numeric_limits<unsigned long>::min)() << endl;  
    cout << "double: \t" << "所佔位元組數：" << sizeof(double);  
    cout << "\t最大值：" << (numeric_limits<double>::max)();  
    cout << "\t最小值：" << (numeric_limits<double>::min)() << endl;  
    cout << "long double: \t" << "所佔位元組數：" << sizeof(long double);  
    cout << "\t最大值：" << (numeric_limits<long double>::max)();  
    cout << "\t最小值：" << (numeric_limits<long double>::min)() << endl;  
    cout << "float: \t\t" << "所佔位元組數：" << sizeof(float);  
    cout << "\t最大值：" << (numeric_limits<float>::max)();  
    cout << "\t最小值：" << (numeric_limits<float>::min)() << endl;  
    cout << "size_t: \t" << "所佔位元組數：" << sizeof(size_t);  
    cout << "\t最大值：" << (numeric_limits<size_t>::max)();  
    cout << "\t最小值：" << (numeric_limits<size_t>::min)() << endl;  
    cout << "string: \t" << "所佔位元組數：" << sizeof(string) << endl;  
    // << "\t最大值：" << (numeric_limits<string>::max)() << "\t最小值：" << (numeric_limits<string>::min)() << endl;  
    cout << "type: \t\t" << "************size**************"<< endl;  
    return 0;  
}

本例項使用了 endl，這將在每一行後插入一個換行符，<< 運算子用於向螢幕傳多個值。我們也使用 sizeof() 函式來獲取各種資料型別的大小。（猜想：/t 是空格的意思，目測是4個空格）

當上面的程式碼被編譯和執行時，它會產生以下的結果，結果會根據所使用的計算機而有所不同：

type:         ************size**************
bool:         所佔位元組數：1    最大值：1        最小值：0
char:         所佔位元組數：1    最大值：        最小值：?
signed char:     所佔位元組數：1    最大值：        最小值：?
unsigned char:     所佔位元組數：1    最大值：?        最小值：
wchar_t:     所佔位元組數：4    最大值：2147483647        最小值：-2147483648
short:         所佔位元組數：2    最大值：32767        最小值：-32768
int:         所佔位元組數：4    最大值：2147483647    最小值：-2147483648
unsigned:     所佔位元組數：4    最大值：4294967295    最小值：0
long:         所佔位元組數：8    最大值：9223372036854775807    最小值：-9223372036854775808
unsigned long:     所佔位元組數：8    最大值：18446744073709551615    最小值：0
double:     所佔位元組數：8    最大值：1.79769e+308    最小值：2.22507e-308
long double:     所佔位元組數：16    最大值：1.18973e+4932    最小值：3.3621e-4932
float:         所佔位元組數：4    最大值：3.40282e+38    最小值：1.17549e-38
size_t:     所佔位元組數：8    最大值：18446744073709551615    最小值：0
string:     所佔位元組數：24
type:         ************size**************

2.typedef 宣告

您可以使用 typedef 為一個已有的型別取一個新的名字。下面是使用 typedef 定義一個新型別的語法：

typedef type newname; 

例如，下面的語句會告訴編譯器，feet 是 int 的另一個名稱：

typedef int feet;

現在，下面的宣告是完全合法的，它建立了一個整型變數 distance：

typedef int feet;
feet distance;

3.列舉型別

列舉型別(enumeration)是C++中的一種派生資料型別，它是由使用者定義的若干列舉常量的集合。

如果一個變數只有幾種可能的值，可以定義為列舉(enumeration)型別。所謂"列舉"是指將變數的值一一列舉出來，變數的值只能在列舉出來的值的範圍內。

建立列舉，需要使用關鍵字 enum。列舉型別的一般形式為：

enum 列舉名{ 
     識別符號[=整型常數], 
     識別符號[=整型常數], 
... 
    識別符號[=整型常數]
} 列舉變數;    

如果列舉沒有初始化, 即省掉"=整型常數"時, 則從第一個識別符號開始。

例如，下面的程式碼定義了一個顏色列舉，變數 c 的型別為 color。最後，c 被賦值為 "blue"。

enum color { red, green, blue } c;
c = blue;

預設情況下，第一個名稱的值為 0，第二個名稱的值為 1，第三個名稱的值為 2，以此類推。但是，您也可以給名稱賦予一個特殊的值，只需要新增一個初始值即可。例如，在下面的列舉中，green 的值為 5。

enum color { red, green=5, blue } c;

在這裡，blue 的值為 6，因為預設情況下，每個名稱都會比它前面一個名稱大 1，但 red 的值依然為 0。

C++ 變數型別

變數其實只不過是程式可操作的儲存區的名稱。C++ 中每個變數都有指定的型別，型別決定了變數儲存的大小和佈局，該範圍內的值都可以儲存在記憶體中，運算子可應用於變數上。

變數的名稱可以由字母、數字和下劃線字元組成。它必須以字母或下劃線開頭。大寫字母和小寫字母是不同的，因為 C++ 是大小寫敏感的。

基於前一章講解的基本型別，有以下幾種基本的變數型別，將在下一章中進行講解：

C++ 也允許定義各種其他型別的變數，比如列舉、指標、陣列、引用、資料結構、類等等，這將會在後續的章節中進行講解。

下面我們將講解如何定義、宣告和使用各種型別的變數。

1.C++ 中的變數定義

變數定義就是告訴編譯器在何處建立變數的儲存，以及如何建立變數的儲存。變數定義指定一個數據型別，幷包含了該型別的一個或多個變數的列表，如下所示：

type variable_list;

在這裡，type 必須是一個有效的 C++ 資料型別，可以是 char、wchar_t、int、float、double、bool 或任何使用者自定義的物件，variable_list 可以由一個或多個識別符號名稱組成，多個識別符號之間用逗號分隔。下面列出幾個有效的宣告：

int i, j, k;
char c, ch; 
float f, salary; 
double d;

行 int i, j, k; 宣告並定義了變數 i、j 和 k，這指示編譯器建立型別為 int 的名為 i、j、k 的變數。

變數可以在宣告的時候被初始化（指定一個初始值）。初始化器由一個等號，後跟一個常量表達式組成，如下所示：

type variable_name = value;

下面列舉幾個例項：

extern int d = 3, f = 5; // d 和 f 的宣告 
int d = 3, f = 5; // 定義並初始化 d 和 f 
byte z = 22; // 定義並初始化 z 
char x = 'x'; // 變數 x 的值為 'x'

不帶初始化的定義：帶有靜態儲存持續時間的變數會被隱式初始化為 NULL（所有位元組的值都是 0），其他所有變數的初始值是未定義的。

2.C++ 中的變數宣告

變數宣告向編譯器保證變數以給定的型別和名稱存在，這樣編譯器在不需要知道變數完整細節的情況下也能繼續進一步的編譯。變數宣告只在編譯時有它的意義，在程式連線時編譯器需要實際的變數宣告。

當您使用多個檔案且只在其中一個檔案中定義變數時（定義變數的檔案在程式連線時是可用的），變數宣告就顯得非常有用。您可以使用 extern關鍵字在任何地方宣告一個變數。雖然您可以在 C++ 程式中多次宣告一個變數，但變數只能在某個檔案、函式或程式碼塊中被定義一次。

變數可以多次宣告，但只能被定義一次！

例項

嘗試下面的例項，其中，變數在頭部就已經被宣告，但它們是在主函式內被定義和初始化的：

#include <iostream>
using namespace std;
 
// 變數宣告
extern int a, b;
extern int c;
extern float f;
  
int main ()
{
  // 變數定義
  int a, b;
  int c;
  float f;
 
  // 實際初始化
  a = 10;
  b = 20;
  c = a + b;
 
  cout << c << endl ;
 
  f = 70.0/3.0;
  cout << f << endl ;
 
  return 0;
}

當上面的程式碼被編譯和執行時，它會產生下列結果：

30
23.3333

同樣的，在函式宣告時，提供一個函式名，而函式的實際定義則可以在任何地方進行。例如：

// 函式宣告 
int func(); 
int main() 
{   // 函式呼叫 
    int i = func(); 
} // 函式定義 
int func() 
{ 
    return 0; 
}

3.C++ 中的左值（Lvalues）和右值（Rvalues）

C++ 中有兩種型別的表示式：

• 左值（lvalue）：指向記憶體位置的表示式被稱為左值（lvalue）表示式。左值可以出現在賦值號的左邊或右邊。
• 右值（rvalue）：術語右值（rvalue）指的是儲存在記憶體中某些地址的數值。右值是不能對其進行賦值的表示式，也就是說，右值可以出現在賦值號的右邊，但不能出現在賦值號的左邊。

變數是左值，因此可以出現在賦值號的左邊。數值型的字面值是右值，因此不能被賦值，不能出現在賦值號的左邊。下面是一個有效的語句：

int g = 20;

但是下面這個就不是一個有效的語句，會生成編譯時錯誤：

10 = 20;

C++ 變數作用域

作用域是程式的一個區域，一般來說有三個地方可以定義變數：

• 在函式或一個程式碼塊內部宣告的變數，稱為區域性變數。

• 在函式引數的定義中宣告的變數，稱為形式引數。

• 在所有函式外部宣告的變數，稱為全域性變數。

我們將在後續的章節中學習什麼是函式和引數。本章我們先來講解什麼是區域性變數和全域性變數。

1.區域性變數

在函式或一個程式碼塊內部宣告的變數，稱為區域性變數。它們只能被函式內部或者程式碼塊內部的語句使用。下面的例項使用了局部變數：

例項

#include <iostream>
using namespace std;
 
int main ()
{
  // 區域性變數宣告
  int a, b;
  int c;
 
  // 實際初始化
  a = 10;
  b = 20;
  c = a + b;
 
  cout << c;
 
  return 0;
}

2.全域性變數

在所有函式外部定義的變數（通常是在程式的頭部），稱為全域性變數。全域性變數的值在程式的整個生命週期內都是有效的。

全域性變數可以被任何函式訪問。也就是說，全域性變數一旦宣告，在整個程式中都是可用的。下面的例項使用了全域性變數和區域性變數：

例項

#include <iostream>
using namespace std;
 
// 全域性變數宣告
int g;
 
int main ()
{
  // 區域性變數宣告
  int a, b;
 
  // 實際初始化
  a = 10;
  b = 20;
  g = a + b;
 
  cout << g;
 
  return 0;
}

在程式中，區域性變數和全域性變數的名稱可以相同，但是在函式內，區域性變數的值會覆蓋全域性變數的值。下面是一個例項：

#include <iostream>
using namespace std;
 
// 全域性變數宣告
int g = 20;
 
int main ()
{
  // 區域性變數宣告
  int g = 10;
 
  cout << g;
 
  return 0;
}

當上面的程式碼被編譯和執行時，它會產生下列結果：

10

3.初始化區域性變數和全域性變數

當區域性變數被定義時，系統不會對其初始化，您必須自行對其初始化。定義全域性變數時，系統會自動初始化為下列值：

正確地初始化變數是一個良好的程式設計習慣，否則有時候程式可能會產生意想不到的結果。