指针跟内存地址有关，他表示的是一个内存地址。
指针操作符为*和&，其中&变量名为变量的内存地址，*变量名为该内存地址的值。
可以通过修改某内存地址的值，来使得其变量的值变化。
如代码：
#include<iostream>
int main()
{
using namespace std;
int a=1; //初始化变量a=1
int * b; //初始化变量*b，*b指某地址的值（*是指针操作符）
b = &a; //&a为变量a的内存地址，将其地址赋值给变量b（b为内存地址），这个时候*b即为该地址的值（注意，没加*是地址，加了*是值）
cout << a << endl; //显示变量a的值
cout << &a << endl; //显示变量a的地址
cout << b << endl; //显示变量b——是内存地址
cout << *b << endl; //显示该内存地址的值
cout << &b << endl; //显示储存变量a内存地址（该内存地址是一个值） 的内存地址（是一个地址），相当于该内存地址储存的值，是另外一个值的内存地址
cout << "————————" << endl;
*b = 5; //更改该内存地址的值为5
cout << a << endl; //显示变量a的值
cout << &a << endl; //显示变量a的地址
cout << b << endl; //显示变量b——是内存地址
cout << *b << endl; //显示该内存地址的值
cout << &b << endl; //显示储存变量a内存地址（该内存地址是一个值） 的内存地址（是一个地址）
system("pause");
return 0;
}
输出：
1 0031FE34 0031FE34 1 0031FE28 ———————— 5 0031FE34 0031FE34 5 0031FE28
注意：
①对于一个变量来说，带&则为其变量的内存地址，并且可以将该内存地址赋值给另外一个值。
②若在内存地址前加*，则为其内存地址的值。即a和*&a的值是相等的。
③可以通过给 表示该 内存地址值 的 变量 赋值，来给 该内存地址的 变量 赋值。即a=1;&a=b;*b=5;cout<<a; 的输出结果是a=5，原因就是a=*b都是同一个内存地址的值（但是表示方式不同），操作该内存地址的值将同时影响两个的值。
④在以上代码中，&a和b都是一个指针，指针表示的是一个地址。
⑤在以上代码中，a和*b是完全等价的，是一体两面，
⑥int * b中，*左右两边是有空格的，但也可以没有空格，或者只有一边有空格，结果是相同的。c程序员这么写int *b，强调*b是一个int类型的值，c++程序员这么写int* b，强调是指向int类型的指针。但两个都是一样的。
⑦在以上代码中：
a ——变量（值）；
&a和b ——地址（指针）；
*b ——该内存地址的值；
int a ——int类型的变量（也是值）；
int *b ——某内存地址储存了int类型的值（决定了该内存地址的宽度）；
（最后两个由于类型都是int，因此占用的内存地址的宽度相同，假如一个是int一个是double，那么在操作的时候就不一样了，特别是值比double大时）
⑧int *b; b=&a这两行代码，也可以写为int * b = &a;;但是不能写成int * b = a;也不能写成 int * b;*b = a;原因在于，初始化时，实际上可以理解为b是地址，int * b实际上是int*和b，int*的意思就是指向int类型的内存地址。而不是int 和*b。
int *b=&a;中，int *b整体，被声明为一个指针变量（因此*的存在，b是指针*b是指针变量）。而=&a;这一部分属于初始化部分（initializer)，用于初始化前面的变量（b）——推测是右边只影响变量，哪怕变量带运算符也跟运算符无关，因为运算符只是一个变量的修饰。因为b是一个指针，所以需要对指针进行初始化（即地址）。
⑨int * a, b;这行代码，创造的是指针a和int变量b，即a为地址，b为一个变量。
int * a, *b;这行代码，则是两个地址，分别是指针a和指针b。
int*a只能被初始化为地址，其中a是地址，int*a,b中，a为地址，b为int变量。
C++的声明，写成T D形式，T是类型名，D是变量名。T可以是各种各样的类型，如整型，浮点类型，数组，字符串，类等，但只是这些类型名，不包含任何符号。
而D是包含符号的各种变量名，符号例如&或者*都是修饰变量名的，例如*a就是指针变量，&b就是内存地址（值b的），像=1;或者=(int*)0x……;也是属于D部分的。
总之：int *a中，int*是类型，因为类型，所以a是指针（即地址），所以右边需要赋值地址。
（10）在创建指针的时候，最好将指针指向一个变量名的地址，而不是将指针所表示地址的值指向另外一个值，例如：
int*a;
int b=10;
a=&b;这是ok的，
*a=10;
或者
*a=b;这两个是错误的。
因为指针的关键是地址，运算符*a只不过表示该地址的值，不能先给该地址赋值（如*a=b就是将b的值赋给*a，*a=10就是给该地址赋值为10），因为编译器还不知道指针b到底在哪，因此就算赋值，他也不知道给哪个地址赋值。
而若先a=&b; //给指针a赋值地址
然后*a=5; //给指针a的值赋值5，这样是ok的。
因为编译器知道这个地址是哪里了，于是就可以给这个地址的值赋值。
给指针的地址赋值：
在给指针地址赋值时，我们可以通过int *a,b; b=&a;这样，将a的内存地址赋值给指针b。
也可以直接将地址赋值给指针b。例如：
int * a;
a = (int *)0x0037FCB8;
就是直接给指针a赋值地址，需要注意的是，不能直接写地址位置。
例如:
a =0x0037FCB8;
是不可行的，必须加上(int*)，表示这个是一个地址，不然编译器会误以为是一个值，而非地址。
另外，地址前面的0x也是不能省略的。
当这样赋值之后，*a显示的就是该内存地址，类型为int的值（注意，必须在之前声明类型即类似int *a，如int或者double，不然编译器不知道显示多长的内存的值）。
另外，内存地址前面的(int *)也不代表指针a的类型是int，指针类型主要靠int *a;这一行来声明。他的主要目的就是表明后面是一个内存地址，而不是一个值。
C++的赋值，要求类型匹配。若只是涉及像整型/浮点类型的转换，只是加了小数点或者省去小数部分，但是若涉及到例如 数组、字符串、结构等，就会产生类型不同，无法赋值。
(int*)是强制类型转换，比如0x0037FCB8是一个值（16进制的），只有加了强制类型转换，于是二者的类型才匹配，否则左边是内存地址，右边是一个值，虽然看起来一样，但本质上二者类型不同，是不能赋值的。
使用new来分配内存：
在使用变量名的时候，例如int a=1; 系统为变量名a，类型为int，值为1，分配了一个内存用于储存他们。可以通过调用变量名来调用这个值。
在使用指针的时候，例如int *b=&a; 则b储存了上面那个变量a所在的地址，而*b可以调用该地址的值。
除此之外，我们也可以不使用变量名，直接通过指针调用地址和值，这个时候，关键是使用new这个语句。标准格式为：
类型名 * 指针名=new 类型名;
上代码：
#include<iostream>
int main()
{
using namespace std;
int *a = new int; //创建一个指针a，系统为其分配一个类型为int的内存地址（int决定内存宽度）
*a = 10; //因为有内存地址了，因此可以给该内存地址赋值10
cout << *a << endl; //显示内存地址为a，类型为int的值
cout << a << endl; //显示内存地址a
*a = 100; //覆写内存地址a的值为100
cout << *a << endl;
cout << a << endl;
cout << endl;
double *b = new double; //创建一个指针b，系统为之分配一个类型为double的内存地址（double决定了内存宽度）
*b = 101.1; //为该内存地址赋值
cout << *b << endl; //显示内存地址b的值
cout << b << endl; //显示内存地址b
cout << *a << endl; //显示内存地址a的值
cout << a << endl; //显示内存地址a
cout << endl;
*a = *b; //将内存地址b的值（类型为double）写到内存地址a中（类型为int），因此小数部分被省略
cout << *a << endl; //显示内存地址a的值
cout << a << endl; //显示内存地址a
cout << endl;
cout << "sizeof(a) = " << sizeof(a) << endl; //内存地址a的宽度（单位字节）
cout << "sizeof(*a) = " << sizeof(*a) << endl; //值*a的宽度
cout << "sizeof(b) = " << sizeof(b) << endl; //内存地址b的宽度
cout << "sizeof(*b) = " << sizeof(*b) << endl; //值*b的宽度
system("pause");
return 0;
}
输出：
10 00730AB0 100 00730AB0 101.1 00731018 100 00730AB0 101 00730AB0 sizeof(a) = 4 sizeof(*a) = 4 sizeof(b) = 4 sizeof(*b) = 8 请按任意键继续. . .
注意：
①在使用new来分配内存地址的时候，具体地址如何，是随机的，如果想分配固定的内存地址，需要使用上面说的int *a=(int*)内存地址; 来进行——虽然个人感觉分配固定地址并不好。
②多个new之间，他们的地址都是不同的，不存在后面的new将前面new的内存地址覆写了（因为内存地址在分配的时候，由new后面的类型名决定了内存的宽度，再之后分配的时候，系统会避免在这段内存里分配内存）。
③在确定内存地址后，对带运算符的指针（即*a）进行操作，无论是覆写其他值，或者是对该值相加都只会在该内存地址进行。例如*a=10;然后再*a=100，都是在这个内存地址（类型为int）进行写入，不会影响其他内存地址。
④可以将其他内存地址的值赋给该内存地址，例如*a=*b; 就是将内存地址b的值101.1赋给内存地址a，但是由于类型不同（b是double，a是int），因此在显示的时候，由a内存地址声明时的类型（int）来决定显示数字——即忽略了*b的小数部分。
⑤*a和*b的宽度（sizeof）取决于声明时的类型，如int或者double。int类型的宽度为4，而double类型的宽度是8（在某些系统里会例外）。
也就是说，某个内存地址的值的宽度，和内存地址的宽度是不一样的——因为他们类型不一样，具体看下面：
（（1））int* 在C++中，是一个类型，这个类型是 指向整型变量的指针。
（（2））a是内存地址，也是int* 类型的变量。
（（3））sizeof()表示的是某种类型（如int、double，这里是int*）的内存宽度，如果括号里是变量，则显示该变量类型的内存宽度。
（（4））而sizeof(a)表示的是 int* 类型的内存宽度，因为a是int*类型。
（（5））因为int*类型的内存宽度是4，所以sizeof(a)输出的结果是4
⑥在使用new的时候，可以在声明的时候使用，也可以在声明后使用。
例如：
int *a=new int;
和
int *a; a = new int; //注意，需要使用a（即内存地址），而不是*a这样，类似int *a=内存地址这样
是一样的。这样可以在使用delete释放内存之后（但未删除指针），再次new一个内存地址。
使用delete释放内存：
在使用new请求内存之后，内存地址被占用。同样，也可以通过相反的方式释放内存，如delete。
标准的格式为：
delete 指针名;
注意，指针名前无* ，表示只是释放该内存地址的值，但指针仍然存在。
上代码：
#include <iostream>
int main()
{
using namespace std;
int *a = new int;
*a = 100;
cout << "显示指针a的值： " << *a << endl;
cout << "显示指针a的内存地址： " << a << endl;
delete a;
cout << endl;
//cout << "显示指针a的值： " << *a << endl; //注意，这行如果加入，会提示编译错误
cout << "显示指针a的内存地址： " << a << endl; //注意，这行的地址a和释放内存之前的地址是不同的。
cout << endl;
a = new int; //注意，内存地址已经被释放，因此需要使用new再分配给其一个内存地址
*a = 50; //该内存地址的值为50
cout << "显示指针a的值： " << *a << endl; //注意，这个时候的值是新内存地址的赋值（之前被赋值50）
cout << "显示指针a的内存地址： " << a << endl; //注意，这个时候内存地址已经和之前的内存地址不同了。
system("pause");
return 0;
}
输出：
显示指针a的值： 100 显示指针a的内存地址： 00450AB0 显示指针a的内存地址： 00008123 显示指针a的值： 50 显示指针a的内存地址： 00450710 请按任意键继续. . .
注意：
①在释放内存地址之后，如果要继续使用指针，就需要给指针new一个新的内存地址，方法是： 指针名=new 类型名； ，和之前new一个内存地址的方法相同，只不过不能再次int 指针名=new 类型名 了；
②释放内存地址后，如果要输出（也许还包括调用）该指针的值的话，会出错（因为b没有地址了，既然不存在地址，那么就不可能返回该地址的值；
③释放内存地址的时候，格式是 delete 指针名 即可；delete指针只能删除指针对象，不能删除非指针对象（如值，或加了运算符*的指针）；
④目前不太清楚，为什么在释放指针之后，显示指针的内存地址：（显示指针a的内存地址： 00008123）在多次调试之后，结果都是一样的0x0008123，按照解释，地址被释放后，微软为了更容易区分被释放的指针，给被释放的指针一个固定的地址，就是上面的那个。相对而言，指针地址变动是能理解的。
⑤指针释放再new的时候，地址是不同的，由系统自行分配。
⑥不要重复删除一个指针，会出错，例如delete a;delete a;这样，是不对的。
⑦new和delete要配对使用，即用一次new，后面只能用delete进行释放，而不能对一个指针连续new或者delete。
⑧教程说，对空指针使用delete是安全的，空指针指NULL和另外一个，而不是值为0的。
使用new来创建动态数组：
使用new和使用声明来创建变量，这二者的区别，在于是否在编译阶段占用内存。
例如int a=1; 在编译阶段时，为变量a分配内存空间，宽度为类型int。
而使用new的时候，在编译阶段则不为之分配内存空间，而是在程序运行的时候，根据需要决定是否为之分配内存空间，
假如需要，则分配；假如不需要，则不分配；假如分配了，也可以使用delete指针来释放内存空间。
这样的话，new相比声明类型变量，更加灵活，也更加节省内存（因为无需一直占用）。特别是面对大型数据（数组，字符串，结构）
使用声明类型变量，在编译时为之分配内存被称为静态联编（static binding)，意味着数组（或字符串，结构）是在编译时被加入内存的。
使用new，则被称为动态联编（dynamic binding），意味着数组（或其他）是在程序运行时被创建的。这种数组被称为动态数组（dynamic array）。
使用静态联编时，需要在编译阶段确定数组的长度，而动态联编，程序在运行时决定数组的长度。
创建动态数组的格式为：
类型名 *指针名=new 类型名[数组长度];
例如：创建一个包含5个double类型元素的动态数组办法为：
double *a = new double[5];
类似为指针new一个内存地址。只不过由于后面加了中括号，并且加入数组的元素个数。
同样，释放数组时，也需要使用delete，格式为 delete []指针名;
注意：这个时候，中括号里不加数字，则释放整个数组的内存空间。
上代码：
#include <iostream>
int main()
{
using namespace std;
double *a = new double[5]; //为数组double分配内存地址
a[0] = 1.1;
a[1] = 2.1;
a[2] = 3.1;
a[3] = 4.1;
a[4] = 5.1;
cout << a[0] << endl; //这个时候，输出的是数组第一个元素的值，而非地址
cout << a << endl; //这里输出的是数组的内存地址
cout << *a << endl; //这里输出的是数组第一个元素的值，而非整个数组的
cout << a[1] << endl; //输出数组中第二个元素的值
cout << a[2] << endl; //由于没有给数组第三个元素赋值，所以输出的并非是我们想要的值
a = a + 1; //此时,相当于整个数组括号里的数都减 1。例如原来数组是从a[0]～a[4]，-1后是a[-1]～a[3]
cout << "指针a=a+1，此时数组原来括号里的数字都自动减1.因此：" << endl;
cout << "a[-1] = " << a[-1] << endl;
cout << "a[1] = " << a[1] << endl;
cout << "*a 的值为： " << *a << endl;
cout << "指针a的地址为： " << a << endl;
cout << "a[2] = " << a[2] << endl;
cout << "a[1] + a[2] = " << a[1] + a[2] << endl;
//delete[0]a; 这种删除方法是错误的，中括号里不能有数字，即不能删除指针a中数组的某一个元素
a = a - 1; //在这行命令后，数组从a[-1]～a[3]又变回a[0]～a[4] 。只有这样，才能释放内存
delete[]a; //删除包含整个数组的指针a
cout << a << endl; //这个时候，地址并非是new时给指针分配的地址了
system("pause");
return 0;
}
输出为：
1.1 00560AB0 1.1 2.1 3.1 指针a=a+1，此时数组原来括号里的数字都自动减1.因此： a[-1] = 1.1 a[1] = 3.1 *a 的值为： 2.1 指针a的地址为： 00560AB8 a[2] = 4.1 a[1] + a[2] = 7.2 00008123 请按任意键继续. . .
我们可以从代码中得出结论：
①在使用动态数组时，可以用指针名代替数组名，即a为指针,a[0]为数组的第一个元素的值，而非第一个元素的地址
②显示指针地址的值*a时，显示的是数组第一个元素的值，而非数组全部元素的值。
③显示指针地址时，显示的是数组第一个元素的地址。
④在给指针+1时，指针的地址右移了（从B0到B8），而数组的位置没变，因此原本指向 a[0]的地址，在右移后（移动了一个double单位），指向了a[1]。这个时候，输出a[0]的命令，实际上输出的是a[1]。于是，想继续输出原本a[0]的话，就必须打a[-1]了。
⑤在移动指针之后，如果想delete指针释放内存，那么就需要将指针移动回来，例如之前是a=a+1; 那么移动回来就是a=a-1; 只有这样，才能正确释放指针。指针加1表示指针右移，减1表示指针左移，并不影响内存地址储存的值。
正因为右移和左移，所以叫指针才名副其实，因为正指的是指针指向的位置。
⑥创建指针时如果加了中括号，那么删除指针时也要加中括号。——有中括号代表数组。 只不过创建动态数组时需声明数组的元素个数，而删除的时候不用，删除只能删除整个动态数组。
⑦a[0]指的是指针所指当前位置内存地址所储存的值，a[1]指的是指针所指内存地址位置再右移（类似指针位置+1）的内存地址所储存的值。也这是为什么数组第一个元素是数组名，然后中括号里的数字为0了。因为0表示当前位置。
