C语言的指针和数组
指针和内存
指针变量也是个变量，不过保存的是另一个变量的地址。另外编译器还会记住指针所指向变量的类型，从而在指针运算时根据变量类型采取不同操作。
例如，char * a 定义了char 类型的指针变量 a，通过 *a 读取数据时，每次只会读一个字节（char 类型变量的长度）。而int * i 定义了 int 类型的指针变量 i，通过 *i 读取数据时，每次会读两个或四个字节（int 类型变量的长度跟编译器平台有关）。
#include <stdio.h>
int main()
{
int a = 666;
char c = 'a';
int * p1 = &a; // 相当于(int *) p1，表示 p1 是执行 int 类型的指针
char * p2; // 相当于(char *) p2，表示 p2 是执行 char 类型的指针
p2 = &c; // & 符号用于取变量的地址
printf("address of a is %#x, value of a is %d\n", p1, *p1);
printf("address of c is %#x, value of c is %c\n", p2, *p2);
}
输出：
address of a is 0x107900bc, value of a is 666
address of c is 0x107900bb, value of c is a
char 型指针显示多个字节的问题
#include <stdio.h>
int main()
{
float a = 1.2;
char * p = (char *)&a; // 这里的 p 指向有符号字符型变量，符号位为1时会打印4个字节
printf("%#x\n", *p);
}
输出：
0xffffff9a
要解决这个问题，把上面的 char * p = &a; 变成 unsigned char * p = &a; 即可。
指针类型转换
有时我们需要用 char * 按照字节大小读取数据，但是非 char 类型的指针当做 char 指针处理时会报错或警告。这时需要强制类型转换：
#include <stdio.h>
int main()
{
int a = 0x77777777;
char * p = (char *)&a;
printf("%#x\n", *p);
}
段错误
指针操作如有不慎，会经常看到 Segmentation Fault 段错误。这是因为指针指向了非法的内存，例如下面的代码执行的内存地址，操作系统是不允许访问的：
#include <stdio.h>
int main()
{
int a = 0x12345678;
int * p = &a;
p = 0x00000001;
printf("address of a is %#x, value of a is %d\n", p1, *p1);
}
内存除了用于存放程序运行时的数据外，还有一部分内存用于操作硬件。例如内存的某一段连续空间用于映射显存、I2C、USB 设备等。
大端存储、小端存储
对于单字节的 char 类型变量不存在这个问题。但多字节的变量，高字节存储在内存的高地址还是低地址，决定了采用哪种存储方式。
- 大端模式 Big-Endian：低地址存放高位，类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；和阅读习惯一致。
- 小端模式 Little-Endian：低地址存放低位，将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。
#include <stdio.h>
int main()
{
int a = 0x12345678;
unsigned char * p1 = &a;
printf("address of a is %#x, value of a is %#x\n", p1, *p1);
}
上面代码在 32 位平台上运行时，通过 char 类型的指针只读取第一个字节，如果输出 78 表示是小端存储（低地址存放低位），否则是大端存储。输出：
address of a is 0xbb483e84, value of a is 0x78
目前Intel的80x86系列芯片是唯一还在坚持使用小端的芯片，ARM芯片默认采用小端，但可以切换为大端。另外，对于大小端的处理也和编译器的实现有关，在C语言中，默认是小端（但在一些对于单片机的实现中却是基于大端，比如Keil 51C），Java是平台无关的，默认是大端。在网络上传输数据普遍采用的都是大端。
指针的修饰符
const
C 语言的 const 比较弱，很容易绕过去，例如通过指针。const 修饰的变量仍然存储在读写区，而非只读区。
- 指针可以指向任意变量，但是不可通过指针修改变量值。两种写法：
const char * p; // 推荐使用，相当于 const ((char *) p)
char const * p; // 不推荐
- 指针只能指向指定的变量，但是变量值可以任意修改。两种写法：
char * const p; // 推荐使用，相当于 (char *) (const p)
char * p const; // 不推荐
- 指针只能指向指定的变量，且不可通过指针修改变量值
const char * const p; // 相当于 const ((char *) (const p))
综合示例：
#include <stdio.h>
int main()
{
char * str1 = "hello\n"; // C 语言中字符串不可修改
char str2 [] = {"hello\n"};// 数组可以修改
//str1[0] = 'a'; // str1 修改会导致 segmentation fault
str2[0] = 'a';
printf("%s\n", str2);
}
上面代码中，字符串是不可修改的，所以可以用 const 限制，如果有代码则会在编译时报错：
int main()
{
char * str1 = "hello\n"; // C 语言中字符串不可修改
const char str2 [] = {"hello\n"};// 数组可以修改
str1[0] = 'a'; // str1 修改会导致 segmentation fault
str2[0] = 'a';
printf("%s\n", str2);
}
编译报错：
/code/main.c: In function ‘main’:
/code/main.c:9:2: error: assignment of read-only location ‘str2[0]’
str2[0] = 'a';
const 变量的绕过（越界）
#include <stdio.h>
int main()
{
int a = 0x66667777;
int b = 0x11111111;
int *p = &b;
*(p+1) = 0xffffffff;
printf("%#x\n", a);
}
volatile
编译器默认的优化是开启的。但有时候我们操作的内存是映射到硬件的，此时可能需要关闭优化。
volatile char * p = 0x20;
while (*p == 0x20) ...
typedef
指针可以指向任意类型的资源，例如 int、char、数组、函数。指定简明易读的别名可以提高代码可读性。
char * name_t;
typedef char * name_t;
name_t myVar;
指针的运算符
++、–、+、-
指针的加减操作，跟指针指向变量的具体类型有关。指针指向的变量占几个字节，指针每次加减一就是加减几个字节，确保刚好可以指向下一个同类型元素。
#include <stdio.h>
int main()
{
const char *p = {"hello\n"};
int *s = p;
printf("%c, %c, %c, %c, %#x\n", *p, *(p+1), *(p+2), *(p+3), *s);
}
[]
在数组中，保存的是相同类型的元素。通过下标可以访问到每一个元素，不需要我们在编程的时候关系元素占几个字节。这跟指针的加减运算是一样的。p[0] 等价于 *p，p[1] 等价于 *(p+1)，以此类推：
#include <stdio.h>
int main()
{
const char *p = {"hello\n"};
printf("%c, %c, %c, %c\n", *p, p[0], *(p+1), p[1]);
}
指针的逻辑运算
指针可以进行比较，>= 、<= 、== 、!= 四种。
- 跟特殊值 0x0 或 NULL 这个无效地址进行比较，相等则表示结束。
- 必须是同类型的指针，比较时才有意义。
多级指针
常用的是二维指针，二维以上基本上不用。
当在内存中有多个离散的变量时，为了放在一个变量中统一访问，就需要把这个用作访问入口的统一变量设计为数组，数组中的每个元素都是指针，执行原始变量。
语法的简单示例：
int 变量int a;
← int 变量的指针int * p = &a;
← int 变量的指针的指针int **p2 = &p;
bash 终端可以在命令后面带参数，编译器会把所有参数汇总到 main 函数的参数中：
#include <stdio.h>
int main(int argc, char ** argv)
{
int i;
for (i = 0; i < argc; i++) {
printf("argv[%d] is: %s\n", i, argv[i]);
}
i = 0;
while(argv[i] != NULL) {
printf("argv[%d] is: %s\n", i, argv[i++]);
}
return 0;
}
# ./build 666 hello world !
argv[0] is: ./build
argv[1] is: 666
argv[2] is: hello
argv[3] is: world
argv[4] is: !
argv[1] is: ./build
argv[2] is: 666
argv[3] is: hello
argv[4] is: world
argv[5] is: !
数组
数组的内存操作
数组是地址操作的一种形式，使用的时候跟指针几乎一样。通过数组分配的内存空间的特性如下：
- 大小：在定义的时候指定，可以通过 malloc 分配，也可以通过元素的类型及个数 int[10] 这种形式分配
- 读取方式：通过数组中的元素类型确定。例如 char 类型的数组，每次读取 1 个字节
int a[10]; // 分配 4*10Byte 的内存，a 是指向这个内存的标签，不可变，不是指针
C 语言只有指针的概念，并没有真正意义的数组，所以在用指针操作数组时，需要注意：不要越界。
#include <stdio.h>
int main(int argc, char ** argv)
{
char a[] = {"hello\n"};
char * p = {"hello\n"};
printf("a is: %s\n", a);
printf("p is: %s\n", p);
//a = "hello"; // a 是标签，数组不可变，否则编译报错
p = "world\n"; // p 是指针，可以变
printf("a is: %s\n", a);
printf("p is: %s\n", p);
}
字符空间和非字符空间
关于char、unsigned char 和 signed char 三种类型直接的差别，可以参考：http://bbs.chinaunix.net/thread-889260-1-1.html
内存中的数据空间可以分为两类：
- 字符空间：存储的数据是可读的字符串，以 \0 结束。用 char 来表示，例如
char a[10];。用 strcpy 复制数据，复制时以 \0 结束，或者用 strncpy 复制。 - 非字符空间：存储的是二进制数据，不可读。用 unsigned char 来表示，例如
unsigned char b[10]。用 memcpy 复制数据，复制时需要指定字节个数。
int buf[10];
int source[1000];
memcpy(buf, source, 10*sizeof(int));
数组的初始化
注意：C 语言中只有字符串常量。因为 C 语言没有字符串变量的概念，如果想修改字符串的值，必须将字符串存储为字符数组。所有字符串都以 \0 结尾。
- 声明数组时，同时赋值一个内存空间：
C 语言本身不支持空间赋值，通常是编译器自动对这种赋值转换为逐个元素赋值，可以反汇编查看一下。
char a[] = "hello\n"; // C 编译器看到双引号时，自动在末尾加 \0
char b[10] = {'h', 'e', 'l', 'l', 'o', '\n', '\0'}; // 未赋值的元素默认是0
char c[] = {"hello\n"}; // 因为双引号和大括号都用来划分存储空间，可省略大括号
int i[] = {12, 23, 666};
- 声明数组后，逐个元素赋值：
char a[10];
a[0] = 'h';
a[1] = 'e';
...
字符串数组和字符串指针的差异
字符串是 C 语言中需要特别注意的地方。字符串常量赋值到数组时，实际上会先创建一个数组变量，然后依次把每个字符拷贝到这个数组中，数组指向的变量跟字符串常量无关，可以修改。但字符串赋值到指针时，指针指向的就是这个字符串常量，此时指针指向的值不可修改。
char a[10] = {"hello"}; // 内存中分配了一个字符串常量空间和一个字符串变量空间，变量 a 指向这个变量空间，可以修改空间中的元素
a[2] = 'w'; // OK
char *p = "hello"; // 内存中只有一个字符串常量空间和一个指向该常量的指针变量，指针变量 p 指向常量，不可修改
p[2] = 'w'; // 报错 segmentation fault
数组名是个标签，不可赋值
C 语言中，数组中的每个元素可以修改，但是不可直接对数组名进行赋值。如果想再次赋值，只能逐个元素赋值。
int a[] = {2, 5, 6};
a = {3, 5}; // 编译报错，数组名类似函数名，是个常量标签，不可赋值
内存空间拷贝函数
内存空间逐一赋值操作很常见，所以 C 语言将其封装为字符串拷贝函数。可以在 Linux 下通过 man 3 strcpy 之类的命令查看函数定义。
strcpy 函数
strcpy 函数碰到 0 就停止拷贝。如果源字符串太长，strcpy 可能导致内存泄漏，一般不用。函数原型如下：
char *strcpy(char *dest, const char *src);
char a[] = "666";
strcpy(a, "hello world");
strncpy 函数
strncpy 函数可以限制拷贝的数量，防止发生越界。
char *strcpy(char *dest, const char *src, size_t n);
指针数组
数组中存在指针，构成指针数组。指针数组就是二级指针。
int *a[10]; // 开辟 10 个空间存放数组 a，a 中放 (int *) 类型的指针
int **a; // ((int *) *) a
将数组名保存为指针
C 语言中，一维数组的数组名变量中放的就是数组首元素的地址，可以直接赋值给指针，并用这个指针访问数组中的元素。但二维数组跟二维指针没有任何关系。
下面例子会报错，p2 指向指针数组，但 b 指向两个连续的内存块，每块内存由 5 个 int 类型变量组成
#include <stdio.h>
int main()
{
int a[10]; // a 是数组标签，表示一块由 10 个 int 元素组成的空间
int b[2][5]; // b 是数组标签，表示两块空间，各由 5 个 int 元素组成
int *p1 = a;
int **p2 = b; // 这一行会报错
int *p4 [5] = b; // 这一行会报错，这里 p4 是数组，其中的每一个元素都是 int 类型的指针
int (*p3)[5] = b; // 正常编译，这里 p3 是指针，指向一块由 5 个 int 元素组成的空间
printf("%d\n", a[5]);
printf("%d\n", b[1][1]);
printf("%d\n", p3[1][1]);
}
对于三维数组 int a[2][3][4];，可以用指针表示：
int (*p) [3][4];
