常用的几种数据类型：
| 类型标识符 | 说明 | 字节 | 值的范围 | |
| int | 整型 | 4 | –2,147,483,648 到 2,147,483,647 | VC++中为long int类 |
| short | 短整型 | 2 | –32,768 到 32,767 | |
| long | 长整型 | 4 | –2,147,483,648 到 2,147,483,647 | |
| bool | 布尔型 | 1 | false 或 true | |
| char | 字符型 | 1 | -128 到 127 | |
| float | 单精度浮点型 | 4 | 3.4E +/- 38（7 位数） | |
| double | 双精度浮点 | 8 | 1.7E +/- 308（15 位数） | |
| string | 字符串 | -- | #include | |
在数值类型前加unsigned 标识符，则该类型为无符号数据型，如: unsigned int, unsigned short…
可以用 typeid 来对数据类型进行判断：
int a=10;
if (typeid(a)==typeid(int)) cout << "is int type" << endl;
详细的数据类型参见MSDN 中Virtual C++ 数据类型范围：
http://msdn.microsoft.com/zh-cn/library/s3f49ktz.aspx
数组
定义数组的一般形式为：
类型标识符 数组名[常量表达式][常量表达式]…
int a[10], b[2*5];
int a[n*2]; //假设前面已定义了n为常变量 float a[3][4], b[5][10]; 使用指针创建动态数组:
int n; DATE *pd; // 假设pd是个结构类型n = 3;pd = new DATE[n]; pd[0].year = 2010; pd[1].year = 2011; pd[2].year = 2014; cout << pd[0].year << pd[2].year << endl; delete[] pd; // 及时释放内存 枚举
声明枚举类型的一般形式为：
enum 枚举类型名{枚举常量表列};
enum WEEKDAYS {sunDay, monDay, tueDay, wedDay, thuDay, friDay, satDay}
WEEKDAYS D; // 声明变量 D WEEKDAYS
D = sunDay; // 符值 if (D!=satDay) { cout<endl; }
结构
声明一个结构体类型的一般形式为：
struct 结构体类型名 {成员表列} [变量名表列];
struct BOOK{string title;float price; }; BOOK bk; // 声明 bk 为结构类BOOK bk.title = "标题"; // 引用结构体成员，并符值 bk.price = 12.23; 指针
指针是指向一个变量的地址。我们将一个变量的地址称为该变量的指针。认真理解好指针，在C++编程会有很好的应用。主要学习了解好指针在指向类或数组时的关系。
定义指针变量的一般形式为：
基类型 *指针变量名;
int a, b; //定义变量
int *pa, *pb; //定义指针 定义指针用 * 指针符。
取 一个变量的地址用取地址运算符 &, 在运算中 * 是指针指向符，注意，这时*与定义指针变量时的 * 意义不同。定义指针变量时 如 int *n; 这时 * 只代表变量是个指针型变量，*是没意义的，只是一个告诉我们，这个变量n是指针型的。在运算时，如 *n=10; 或 a=*n; 这时的 * 是指向符，是个运算符，意思是指向 n 所在的数据。*n 取得的是内存中的数据。
& 取地址运算符。
* 指针运算符(或称间接访问运算符)。
-> 指针成员指向符
例如:
int a=3;
int *pa;pa = &a; // 将 a 的地址赋给指针变量 pa; 这时*pa的值等于a的值。 *pa = 123; // 在指针变量 pa前加上 * （指针运算符）即表示 *pa指向 a的实体值。 // 相当于a的一个指向表示符，与a等价。 cout << *pa << endl; 类与指针：
类名实际上是一个地址指向。可以通过指针运符 & 来取得这个指针地址。
使用指针指向类时。可以*指向符加指针变量名，如 *p. 来访问类的成员。使用->指针的成员指向符
CTest a; // 假定CTest是一个类。
CTest *pa; // 定义一个类的指针。
pa = &a; // 通过类名取地址，并将地址符给指针pa *pa->x = 10; // 假定 x 是类的一个变量成员。指针用 -> 引用这个变量。即 *pa->x 与 a.x 等价。 数组与指针
数组名实际上也是一个地址指向。（与类名同理）
如 int n[10] n是指向一串int型数据的首内存
数组[]符号，实妹是变址运算符。 [1] 是指这一串int数据内存中的第2个地址（[0]是第一个）。
对数组 n[1] 的理解是 先用[1]求地址，再用n[1]找出地址所指向的数据值。可以这样理解 n[1]是 n在地址 xxxx中的数据，而地址xxxx就是通过变址符[] 中[1]求得的。
再看指针与数据的关系。
指针 int *p中，p是一个地址。*p才是指针指向的数据。
数据 int n[10]中，m也是一个地址。m[0]才是指向第一个数据的。
可以看出。指针p 与数组变量m是一样的。都是地址。*p与m[0]一样。都是指向数据。这里[0]相当于*运算符。类似于 *(m0) 假设m0是指数据串中的第一个数据。
因些，指针以对应单个变更与数组变量时，指向意思是有不同的。
看例子
int n, m[10];
int *p;
p=n; 不对。因为p是指向地址的，n是指向数据的。这时要用取地址符&。p=&n;
p=m; 对。因为数组m[10]. m就是指向地址的是一串数据中的首地址。等同于 p=&m[0].
p=m[0]; 不对。这里 m[0]是指向地址的。相当于 n 一样，这时要用取地址符& p=&m[0]。
p++; *p++; (*p)++; 比较下这三者的不同。
p++是指地址下移。
*p++是指下移后的地址所指向的数据。即 *(p++)
(*p)++ 是指 p所指向的数据值加1.
p即然是指向地址的。那么p+1 实际是将地址移向下一个地址。等同于 m中的[0+1]。
p[0]实际同m[0]等价。
*(p++)与*(++p)作用不同。前者是先取*p值，然后使p加1。后者是先使p加1，再取*p。若p的初值为a(即&a[0])，输出*(p++)得到a[0]的值，而输出*(++p)则得到a[1]的值。
x=*(p++) 先进行“*”运算，得到a[i]，x=a[i]; 再使p+1，p指向a[i+1]了。
x=*(++p) 先使p自加1，再作*运算，得到a[i+1]。x=a[i+1] p也指向a[i+1]
数据指针的使用示例：
定义一个二组数据：
int M[2][12] = {{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, // 数据集1 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } //数据集2 }; int (*p)[12], *p1; p = &M[0]; p1 = &M[0][0]; (*p)[0] = 1; // 给M[0][0] 赋值 等价: (*p)[0] = 1; *(p[0]) = 1; p1[0] = 2; // 给M[0][0] 赋值 注意用法与 *p[0]的不同。这里的[0]实际是取址转向符. cout << *p << '/' << *p[0] << '/' << *p1 << '/' << p1[0] << endl; cout << p << '/' << p[0] << '/' << p1 << '/' << endl; 想取得数组中一组数据中的M[1] 与 M[2] 的数据集.
可以显性定义个数维指针 int (*P)[12]，并符值指针给P P = &M [1]; 或 P = &M [2];
取值或符值时，可以通过 (*P)[0] = 125; X = (*P)[0];
只有用心理解了数组与数组指针的关系。才能得心应手地使用好C++中字符串。
引用
引用是为一个变量起一个别名。用引用符号 & 来表示引用变量。（注：这里的&与指针变针符&的意义不同）
定义引用的一般形式为：
基类型 &引用变量名;
int a;
int &b = a; // 引用必须在声明指定他的对象。 不能写成 int &b; &b = a;
b = 10; // 即 a=10 这里 b就是a, 他们合体了。 // 再看下指针取址符 & int x; int *p; x=12; p = &x; // 注 引用 &b 跟 指针中取地址的&不同 b = *p; // &b=x; p = &b; // 这里不是将b的值赋给p,而是将 a的地址赋给p 现在 *p = a; 在声明一个引用类型变量时，必须同时使之初始化,并且不能再给其重新赋值。引用变量具有唯一指向性且要在初始化时指定其指向。在声明变量b是变量a的引用后，在它们所在函数执行期间，该引用类型变量b始终与其代表的变量a相联系，不能再作为其他变量的引用(别名)。
利用引用，可以方便地使指针型变量转化为实体变量。
CTest a; // CTest是一个类。
CTest *pa; // 声明一个类的指针
CTest &b=*pa; // 声明一个引用变量，并指向一个指针。 pa = &a; // 将 a 的地址赋予指针变量 pa, 这是可以用别名引用 b来指向a b.x = 10; // 相当于 a.x = 10 与 *pa->x // 这时b 是 *pa的引用别名。或者说 b 是 *pa指向的类的实体别名。b 与 a 等价。使用b相当于直接使用a。这里使用引用别名，主要是方便用类的成员符号 . 来代替指针的成员指向符号 ->。使代码更直观，书写更方便。
引用还常用于函数的参数传递。如:
void DoFunc(int &b)
{b++;
}// 注意：跟指针作下比较 void Dofunc(int *b) { *b++; }