备忘：C++基础 -- 数据类型的学习总结

常用的几种数据类型：

在数值类型前加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<<D<<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++;
}