数组

1、什么是数组

数组是一种数据格式，能够存储多个同类型的值。

数组的特点：

1. 数组中的元素按线性方式排列，可以通过编号来访问数组中的每个元素；
2. 每个值都存储在一个独立的数组元素中，计算机在内存中依次存储数组的各个元素；

 

2、数组的声明

要创建数组，可使用声明语句。数组声明应指出以下三点：

1. 存储在每个元素中的值的类型；
2. 数组名；
3. 数组中的元素个数；

格式为：数据类型 数组名[数组大小];

注意：数组大小必须是整数常量，不可以是变量。

 

3、数组的初始化

• C++ 允许在声明语句中初始化数组元素，只需提供一个用逗号分隔的值列表（初始化列表），并将它们用花括号括起来，可省略等号（=）；

  int arr[4] = {3, 6, 8, 10};
  int arr[4] {3, 6, 8, 10};	// C++11 新增
  

• 只有在定义数组时才能使用初始化，此后就不能使用了，也不能将一个数组赋给另一个数组；

  int arr[4] = {3, 6, 8, 10};	// 正确
  
  int hand[4];
  hand[4] = {3, 6, 8, 10};	// 错误
  hand = arr;	// 错误
  

• 初始化数组时，提供的值可以少于数组的元素数目。如果对数组的一部分进行初始化，则编译器将把其他元素设置成0。若想初始化数组为0，则只需要显式将第一个元素初始化为0即可；

  int arr[4] = {3, 6};	// 第1个元素3，第2个元素6，其他元素为0
  int arr[4] = {0};	// 所有元素初始化为0
  int arr[4] = {};	// C++11新增，所有元素初始化为0
  

• 如果初始化数组时方括号内（[]）为空，C++ 编译器将计算元素个数；

  int arr[] = {3, 6, 8, 10};	// 编译器会自动识别元素个数为4
  

• 列表初始化禁止缩窄转换；

  long plifs[] = {25, 92, 3.0};	// 错误，浮点数转换为整型是缩窄操作
  char slifs[4] = {'h', 'i', 1122011, '\0'};	// 错误，1122011超过了char变量的取值范围
  char tlifs[4] = {'h', 'i', 112, '\0'};	// 正确，虽然112是一个int值，但在char类型的取值范围
  

 

4、数组的访问

int arr[indx];；

其中 indx 为数组的索引（下标），范围为 0 ~ length-1；数组长度 length = sizeof(arr) / sizeof(int)。这里的 sizeof 之前的文章介绍过，它返回变量或数据类型的字节个数。因为 arr 为 int 型数组，里面每一个元素都是 int 类型，所以 sizeof(arr) 表示所有元素的字节数，sizeof(int) 表示一个元素的字节数，两者之商就是元素的个数。

注意：如果数组大小较大（大概 $10^6$ 级别），则需要将其定义在主函数外面，否则会使程序异常退出。因为函数内部申请的局部变量来自系统栈，允许申请的空间较小；而函数外部申请的全局变量来自静态存储区，允许申请的空间较大。

 

5、二维数组

1. 声明二维数组

数据类型 数组名[m][n];

m 表示二维数组有多少个一维数组，n 表示每个一维数组的元素个数。

2. 二维数组初始化

   创建二维数组时，可以初始化其所有元素，二维数组初始化是建立在一维数组初始化技术的基础之上：提供由逗号分隔的用花括号括起的值列表。

   int scores[3][4] = {
       {},
       {},
       {}
   };
   

   注意：二维数组的行数个数必须全部用大括号指定，不能省略，否则编译出错！【例如上面的 scores 数组，我省略三个大括号中的一个是不行的】

    

6、memset —— 给数组中每一个元素赋同样的值

给数组中每一个元素赋相同的值有两种方法：memset 和 fill；

memset 函数的格式为：memset(数组名, 值, sizeof(数组名));。需要引入 string.h 头文件。

只建议初学者为数组赋 0 或 -1。因为 memset 使用的是按字节赋值，并不是按元素赋值，很容易出错。如果想按元素赋值，可以使用 fill 函数，此时需要引入 algorithm 头文件。

 
 

字符串（字符数组）

• 字符串是存储在内存连续字节中的一系列字符，又可以称为字符数组；

• C++ 处理字符串有两种方式，一种是 C 语言风格，另一种是基于 string 类；

• 可以将字符串存储在 char 数组中，每个字符都位于自己的数组元素中；

• C 语言风格的字符串是以空字符结尾（空字符被写作 \0，ASCII 码为 0），用来标记字符串的结尾。处理字符串的函数都是根据空字符的位置，而不是数组长度来进行处理；

  存储字符串 “Kitty” 的情况为：char name[6] = {'K', 'i', 't', 't', 'y', '\0'};

• 字符数组初始化为字符串，可以使用双引号（""）将字符串内容括起来【仅限于初始化，程序其他位置不允许这样直接赋值整个字符串】；

  char name[16] = "Hello Kitty";
  char name[] = "Kitty";
  

• 注意字符常量和字符串常量的区别；

  'S' 是字符常量，"S" 是字符串常量，存储的是 ['S', '\0']。

 

1、string.h 头文件

1.1 strlen()

strlen(字符数组)：获得字符数组中第一个 \0 之前的字符个数。

1.2 strcmp()

strcmp(字符数组1, 字符数组2)：返回两个字符串大小的比较结果，比较规则是字典序。

1. 字符数组1 < 字符数组2：返回一个负整数；
2. 字符数组1 < 字符数组2：返回一个正整数；
3. 字符数组1 < 字符数组2：返回0；

1.3 strcpy()

strcpy(字符数组1, 字符数组2)：把字符数组2复制到字符数组1，覆盖复制，这里的复制还包括结束符 \0。

1.4 strcat()

strcat(字符数组1, 字符数组2)：把字符数组2拼接到字符数组1后面，两者之间的结束符会被覆盖。

 
 

string 类简介

除了使用字符数组之外，还可以使用 string 来存储字符串，而且 string 使用起来会比字符数组要简单。

要使用 string，必须包含头文件 string。

 

1、C++11 字符串初始化

C++11 允许将列表初始化用于 C 风格字符串和 string 对象：

char first_data[] = {"Hello World"};
char second_data[] = {"The Elegant Plate"};
string third_data = {"Hello World"};
string third_data {"Hello World"};

string str = {'h', 'e', 'l', 'l', 'o'};
string str = "hello world";

 

2、赋值、拼接和附加

• 不能将一个数组直接赋给另一个数组，但是可以将一个 string 对象直接赋给另一个 string 对象；

  char ch[20] = "hello";
  string str = "world";
  
  char ch1[20];
  ch1 = ch;	// 错误！！
  string str1;
  str1 = str;	// 正确！！
  

• string 简化了合并操作，可以使用运算符 + 来将两个 string 对象合并起来，还可以使用 += 运算符。

  string str2 = str + str2;
  string str += str2;
  

 

3、string 头文件

虽然 string 类也可以使用 C 中的头文件 string.h，但是 C++ 为了更好地使用 string，也提供了自己的 string 操作函数。

3.1 string 中内容的访问

1. 直接像数组那样通过下标访问 string；

   string str = "abc";
   cout << str[0] << endl;	// 要读入或输出整个字符串，只能使用 cin 和 cout
   
   // 还可以用 c_str() 将 string 类型转换为字符数组，然后用 printf 输出
   printf("%s\n", str.c_str());
   

2. 通过迭代器访问；

   string str = "abc";
   string::iterator it = str.begin();
   // 上一句为了简便，还可以写成：
   auto it = str.begin();
   

3.2 string 的比较

两个 string 类型可以直接使用 关系运算符 进行比较，比较规则是字典序！

3.3 length()/size()

str.length()/str.size()：返回字符串 str 的长度，即存放的字符数；

3.4 insert()

1. str.insert(pos, string)：在字符串 str 的 pos 号位置插入字符串 string；
2. str.insert(it, it1, it2)：it 为原字符串欲插入的位置，it1 和 it2 为待插字符串的首尾迭代器，用来表示子串 [it1, it2) 将被插入到 it 的位置上；

3.5 erase()

1. str.erase(it)：删除迭代器 it 所在位置的元素；
2. str.erase(begin, end)：删除一个区间 [begin, end) 内的所有元素；
3. str.erase(pos, length)：pos 为开始删除的其实位置，length 为删除的字符个数；

3.6 clear()

str.clear()：清空 string 中的数据；

3.7 substr()

str.substr(pos, length)：返回从 pos 号位开始、长度为 length 的子串；

3.8 string::npos

一个常数，其本身的值为 -1，但由于是 unsigned_int 类型，因此实际上也可以被认为是 unsigned_int 类型的最大值。string::npos 用来作为 find 函数失配时的返回值。

3.9 find()

1. str.find(str1)：当 str1 是 str 的子串时，返回其在 str 中第一次出现的位置；如果不是，则返回 string::npos；
2. str.find(str1, pos)：从 str 的 pos 号位开始匹配 str1，返回值与上相同；

3.10 replace()

1. str.replace(pos, length, str1)：把 str 从 pos 号位开始、长度为 length 的子串转换为 str1；
2. str.replace(it1, it2, str1)：把 str 的迭代器 [it1, it2) 范围的子串替换为 str1；

 
 

结构体

结构体是由一批不同类型数据组合而成的一种新的数据类型，组成结构体数据的每个数据称为结构体的“成员”（域、元素），通常用来表示类型不同但是又相关的若干数据。

 

1、结构体的定义和使用

struct 结构体名字 {
    char name[20];	// 一些基本的数据结构或者自定的数据类型
    int age;
    ...
}[结构体变量1, 结构体变量2, ...];	// [] 中的是可选项

结构体里面可以定义除了自己之外的任何数据类型，因为定义自己本身会引起循环定义的问题，但是可以定义自身类型的指针变量。

• 假设结构体名字为 student，依次创建结构体类型的变量：

  struct student stu, *stup;	// stu 为结构体变量，stup 为结构体指针变量，两者访问变量方式不同
  student stu;
  

• 访问结构体类型变量成员：

  cout << stu.name;	// 普通变量的访问方式
  cout << stup->name;	// 指针变量的访问方式
  

 

2、结构体变量的初始化

使用逗号分隔值列表，并将这些值用花括号括起来，值之间用逗号分开：

student stu = {"cat", 19};
student stu {"dog", 18};
student stu {};

 

3、结构体数组

• 可以创建元素为结构体的数组，方法和创建基本类型数组完全相同：

  student stus[20];
  cin >> stus[0].name;
  cout << stus[19].age << endl;
  

• 结构体数组初始化：

  student stus[2] = {
      {"cat", 19},
      {"dog", 18}
  };
  

 
 

共用体

1、什么是共用体

共用体（联合体）是一种数据格式，它能够存储不同的数据类型，但只能同时存储其中的一种类型。例如一个共用体中定义了 int 和 double 类型的变量，存储了 int 型数据之后，再存储 double 型数据，此时 int 型数据会丢失。

union one4two
    {
        int id_int;
        long id_long;
    };

    one4two pail;
    pail.id_int = 3;
    cout << pail.id_int << endl;	// 3
    pail.id_long = 3000;
    cout << pail.id_long << endl;	// 3000
    cout << pail.id_int << endl;	// 3000

共用体的句法与结构体相似，但是含义不同，共用体的长度为其最大成员的长度：

union one4all
{
    char char_val;
    short short_val;
    int int_val;	// one4all 的长度就是 int 类型的长度
};

 

2、共用体的用途

共用体的用途之一是，当数据项使用两种或更多种格式（但不会同时使用）时，可节省空间。

假设管理一个小商品目录，其中有一些商品的ID为整数，而另外一些的ID为字符串：

struct widget
{
    char brand[20];
    int type;
    union id
    {
        long id_num;
        char id_char[20];
    } id_val;
};
...
widget prize;
...
if (prize.type == 1) {
    cin >> prize.id_val.id_num;
} else {
    cin << prize.id_val.id_char;
}

匿名共用体（anonymous union）没有名称，其成员将成为位于相同地址处的变量。显然，每次只有一个成员是当前的成员：

struct widget
{
    char brand[20];
    int type;
    union
    {
        long id_num;
        char id_char[20];
    };
};
...
widget prize;
...
if (prize.type == 1) {
    cin >> prize.id_num;
} else {
    cin >> prize.id_char;
}

由于共用体是匿名的，因此 id_num 和 id_char 被视为 prize 的两个成员，它们的地址相同，所以不需要用中间标识符 id_val 。程序员负责确定当前哪个成员是活动的。

共用体常用于（但并非只能用于）节省内存。

 
 

枚举

前文提到过符号常量，使用 const 和 #define 进行定义。C++ 的枚举类型 enum 提供了另一种创建符号常量的方式，可以代替 const，它还允许定义新类型。

 

1、枚举的定义

enum 枚举名 {枚举量1, 枚举量2, ...};

// 例子如下：red为0，依此类推，数值加1。即 orange 为1，yellow 为2，...
enum colors {red, orange, yellow, green, blue, purple};

 

2、枚举的使用

// 使用枚举名声明该类型的变量
colors band;

// 只能将定义枚举时使用的枚举量赋值给这种枚举的变量
band = red;
// band = 5;	// 错误！！

// 可以通过强制类型转换，将有效的 int 值转换成枚举量
band = colors(4);

// 枚举量是整型，可被提升为 int 类型，但 int 类型不能自动转换为枚举类型
int col = blue;
col = 3 + red;

 

3、设置枚举量的值

• 可以使用赋值运算符来显式地设置枚举量地值，指定地值必须是整数：

  enum bits{one = 1, two = 2, four = 4, eight = 8};
  

• 也可以只显式地定义其中一些枚举量的值：

  enum bigstep{first, second = 100, third};	// first 为0，third 为101
  

  first 默认情况下为0，后面没有初始化的枚举量的值比其前面的枚举量大1，third 的值为 101。

• 可以创建多个值相同的枚举量：

  enum{zero, null = 0, one, numero_uno = 1};	// 这里 zero 也为0，one 也为1
  

   

4、枚举的取值范围

• 每个枚举都有取值范围，通过强制类型转换，可以将取值范围中的任何整数赋值给枚举变量，即使这个值不是枚举值：

  enum bits{one = 1, two = 2, four = 4, eight = 8};
  bits myflag = bits(6);
  

• 枚举取值范围：

  • 上限：寻找第一个大于枚举量最大值的2的幂次方，上限就是这个值减1；

    例如最大枚举量为 101，第一个大于它的是 $2^7=128$，所以上限就是 $128-1=127$。

  • 下限：枚举量最小值为0，则下限为0；否则寻找第一个小于它的2的幂次方，加上1；

    例如最小枚举量为 -6，第一小于它的是 $-2^3=-8$，因此下限为 $-8+1=-7$。