C++primer 第三章笔记-标准库类型string-迭代器-数组

Myth丶恋晨 2022-05-23 00:49 185阅读 0赞

C++标准库string

## 定义和初始化 ##

<table style="border:1px solid #C0C0C0;color:rgb(0,0,0);font-family:palatino, georgia, verdana, arial, sans-serif;font-size:13.5px;background-color:rgb(255,255,255);"> 
 <thead> 
  <tr> 
   <th style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">string s1</th> 
   <th style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">默认初始化，s1是一个空串</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">string s2(s1)</td> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">s2是s1的副本</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">string s2 = s1</td> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">等价于s2(s1)，s2是s1的副本</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">string s3("value")</td> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">s3是字面值"value"的副本，除了字面值最后的那个空字符外</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">string s3 = "value"</td> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">等价于s3("value")，s3是字面值"value"的副本</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">string s4(n, 'c')</td> 
   <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">把s4初始化为由连续n个字符c组成的串</td> 
  </tr> 
 </tbody> 
</table>

#include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
    	string s1;//默认初始化,空字符串
    	string s2("haha");//直接初始化
    	string s3 = "haha";//拷贝初始化
    	string s4(10,'a');//直接初始化
    	cout << s1 << endl
    		<< s2 << endl
    		<< s3 << endl
    		<< s4 << endl;
    
    	system("pause");
    	return 0;
    }

程序输出结果

haha
    haha
    aaaaaaaaaa
    请按任意键继续. . .

### 读写string对象 ###

*  写入一个字符串。

#include <iostream>
    #include <string>
    using namespace std;
    //读写string对象
    //在执行读取操作时,string对象会自动忽略开头的空白(空白符,换行符,制表符)并从第一个真正的字符开始读起,直到遇见下一处空白为止
    int main()
    {
    	string s;
    	cin >> s;
    	cout << s << endl;
    
    	system("pause");
    	return 0;
    }
    //如上述所示,如果程序输入的是hello world   则输出将是hello

程序输出结果

hello world
    hello
    请按任意键继续. . .

写入两个字符串。
    #include<iostream>
    #include<string>
    using namespace std;
    int main()
    {
        string s1, s2;
        cin >> s1 >> s2;
        cout << s1 << s2 << endl;
        system("pause");
        return 0;
    }

程序输出结果

hello world
    helloworld
    请按任意键继续. . .

*  读取未知数量的string对象

#include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
    	string word;
    	while (cin >> word)
    	{
    		cout << word << endl;
    	}
    
    	system("pause");
    	return 0;
    }

程序输出结果

hi
    hi
    visual
    visual
    studio
    studio ^Z
    请按任意键继续. . .

使用ctrl + Z结束输入。

### 使用getline读取一整行 ###

保留字符串中的空白符，从给定的输入流中读入内容，直到遇到换行符位置，然后把所读的内容存入到string对象中。

#include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
    	string line;
    	while (getline(cin,line))
    	{
    		cout << line;
    	}
    
    	system("pause");
    	return 0;
    }

程序输出结果

hello hi !!!
    hello hi !!!
    wooohhh woc
    wooohhh woc
    ^Z
    请按任意键继续. . .

getline

C++中有两个getline函数，一个是在string头文件中，定义的是一个全局的函数，函数声明是istream& getline ( istream& is, string& str, char delim )与istream& getline ( istream& is, string& str );

另一个则是istream的成员函数，函数声明是istream& getline (char\* s, streamsize n )与istream& getline (char\* s, streamsize n, char delim );注意第二个getline是将读取的字符串存储在char数组中而不可以将该参数声明为string类型，因为C++编译器无法执行此默认转换。

getline函数大致流程：

1、首先判断istream的failbit位是否为1，为1的话意味着输入流的状态有错误，则不进行读操作，getline函数结束执行  
  
2、从当前位置开始从输入流中依次读取单个字符并拷贝到缓冲区，直到遇到下列条件满足时，循环结束。  
  
(1)遇到文件尾时停止读操作，并设置流对象的结束标记为1  
  
(2)读到调用者指定的分隔符时，此时将分隔符之前的字符拷贝到缓冲区中，但分隔符本身不拷贝进去，并且下次读操作将从分隔符后的下一个字符开始。  
  
(3)已经读了n-1个字符(n是调用者传入的第二个实参\_Count的初值)，此时要把流对象的错误标志位置1

那么如果把getline（）作为while的判断语句会怎么样呢？

让我们一起来分析一下while(getline(cin,line))语句

注意这里默认回车符停止读入,按Ctrl+Z或键入EOF回车即可退出循环。

在这个语句中，首先getline从标准输入设备上读入字符，然后返回给输入流cin，注意了，是cin，所以while判断语句的真实判断对象是cin，也就是判断当前是否存在有效的输入流。在这种情况下，我想只要你的电脑不中毒不发神经你的输入流怎么会没有效？所以这种情况下不管你怎么输入都跳不出循环，因为你的输入流有效，跳不出循环。

然而有些同学误以为while判断语句的判断对象是line（也就是line是否为空），然后想通过直接回车（即输入一个空的line）跳出循环，却发现怎么也跳不出循环。这是因为你的回车只会终止getline()函数的读入操作。getline()函数终止后又进行while（）判断（即判断输入流是否有效，你的输入流当然有效，满足条件），所以又运行getline()函数，所以，你懂了吧。。。

#include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
    	string line;
    	while (getline(cin,line))
    	{  
    		// 只输出超过10个字符的行
    		if (!line.empty() && (line.size()>10)) // 只输出非空的行
    		{
    			cout << line;
    		}
    		
    	}
    
    	system("pause");
    	return 0;
    }

#include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
    	//string对象相加
    	string s1 = "hell0";
    	string s2 = "world\n";
    	string s3 = s1 + s2;
    	string s4 = s1 + "hha\n";//正确，字面值可以和string对象相加
    	cout << s3 << endl
    		<< s4 << endl;
    
    	system("pause");
    	return 0;
    }

程序运行结果

hello world
    
    hello haha
    
    请按任意键继续. . .

## 处理string对象中的字符 ##

*  <table style="border:1px solid #C0C0C0;"> 
     <thead> 
      <tr> 
       <th style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">cctype头文</th> 
       <th style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isalnum(c)</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isalpha(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是字母，则返回true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">iscntrl(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是控制字符，则返回true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isdigit(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是数字，则返回true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isgraph(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c不是空格，但可打印，则为true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">islower(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是小写字母，则为true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isprint(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是可打印字符，则为true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">ispunct(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是标点符号，则为true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isspace（c）</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是空白是否，则为true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isupper（c）</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是大写字母，则为true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">isxdigit(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是十六进制的数，则为true</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">tolower(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是大写字母，返回其小写字母的形式，否则直接返回c</td> 
      </tr> 
      <tr> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">toupper(c)</td> 
       <td style="border-color:#C0C0C0;border-collapse:collapse;padding:3px;">如果c是小写字母，返回其大写字母的形式，否则直接返回c</td> 
      </tr> 
     </tbody> 
    </table>

#include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
    	string s1 = "some string";
    	cout << "method a" << endl;
    	for (auto c : s1)//通过使用auto关键字,让编译器来决定变量c的类型 每次迭代,s1的下一个字符被拷贝给c
    	{
    		cout << c << endl;
    	}
    	cout << "method b" << endl;
    	for (int i = 0; i < s1.size(); ++i)
    		cout << s1[i] << endl; // 通过下标索引
    	system("pause");
    	return 0;
    }

![70][]

#include <iostream>
    #include <string>
    using namespace std;
    //统计string对象中标点符号的个数
    int main()
    {
    	string s1 = "some,string!!!";
    	decltype(s1.size()) count = 0;
    	for (auto c : s1)
    	{
    		if (ispunct(c))
    		{
    			count++;
    		}
    	}
    	cout << s1 + "中共有" << count << "个标点符号" << endl;
    
    	system("pause");
    	return 0;
    }

![70 1][]

### 1 基本语法 ###

`decltype` 类型说明符生成指定表达式的类型。在此过程中，编译器分析表达式并得到它的类型，却不实际计算表达式的值。

语法为：

decltype( expression )

*  1

编译器使用下列规则来确定`expression` 参数的类型。

*  如果 `expression` 参数是标识符或类成员访问，则 `decltype(expression)` 是 `expression` 命名的实体的类型。如果不存在此类实体或 `expression` 参数命名一组重载函数，则编译器将生成错误消息。
 *  如果 `expression` 参数是对一个函数或一个重载运算符函数的调用，则 `decltype(expression)` 是函数的返回类型。将忽略重载运算符两边的括号。
 *  如果 `expression` 参数是右值，则 `decltype(expression)` 是 `expression`类型。如果 `expression`参数是左值，则 `decltype(expression)` 是对 左值引用 类型的`expression`。

给出如下示例代码：

int var;
    const int&& fx(); 
    struct A { double x; }
    const A* a = new A();

*  1
 *  2
 *  3
 *  4

<table style="border-spacing:0px;width:712px;text-align:center;color:rgb(51,51,51);font-family:'-apple-system', 'SF UI Text', Arial, 'PingFang SC', 'Hiragino Sans GB', 'Microsoft YaHei', 'WenQuanYi Micro Hei', sans-serif, SimHei, SimSun;font-size:14px;background-color:rgb(255,255,255);"> 
 <thead> 
  <tr> 
   <th align="left" style="margin:0px;vertical-align:middle;">语句</th> 
   <th align="left" style="margin:0px;vertical-align:middle;">类型</th> 
   <th align="left" style="margin:0px;vertical-align:middle;">注释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">decltype(fx());</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">const int &amp;&amp;</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">对左值引用的const int</code></td> 
  </tr> 
  <tr> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">decltype(var);</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">int</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;">变量&nbsp;<code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">var</code>&nbsp;的类型</td> 
  </tr> 
  <tr> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">decltype(a-&gt;x);</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">double</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;">成员访问的类型</td> 
  </tr> 
  <tr> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">decltype((a-&gt;x));</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;"><code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">const double&amp;</code></td> 
   <td align="left" style="margin:0px;vertical-align:middle;">内部括号导致语句作为表达式而不是成员访问计算。由于<code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">a</code>声明为&nbsp;<code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">const</code>指针，因此类型是对<code style="font-size:14px;line-height:22px;padding:4px 2px 0px;">const double</code>的引用。</td> 
  </tr> 
 </tbody> 
</table>

### 2 `decltype`和引用 ###

如果`decltype`使用的表达式不是一个变量，则`decltype`返回表达式结果对应的类型。但是有些时候，一些表达式向`decltype`返回一个引用类型。一般来说，当这种情形发生时，意味着该表达式的结果对象能作为一条赋值语句的左值：

// decltype的结果可以是引用类型
    int i = 42, *p = &i, &r = i;
    decltype(r + 0) b; // OK, 加法的结果是int，因此b是一个（未初始化）的int
    decltype(*p) c; // Error, c是int&， 必须初始化

*  1
 *  2
 *  3
 *  4

因为`r`是一个引用，因此`decltype(r)`的结果是引用类型，如果想让结果类型是`r`所指的类型，可以把`r`作为表达式的一部分，如`r+0`，显然这个表达式的结果将是一个具体的值而非一个引用。

另一方面，如果表达式的内容是解引用操作，则`decltype`将得到引用类型。正如我们所熟悉的那样，解引用指针可以得到指针所指对象，而且还能给这个对象赋值，因此，`decltype(*p)`的结果类型是`int&`而非`int`。

### 3 `decltype`和`auto` ###

*  处理顶层const和引用的方式不同（参考阅读：[C++ auto类型说明符][C_ auto]）

如果`decltype`使用的表达式是一个变量，则`decltype`返回该变量的类型（包括顶层`const`和引用在内）：

const int ci = 0, &cj = ci;
    decltype(ci) x = 0; // x的类型是const int
    decltype(cj) y = x; // y的类型是const int&，y绑定到变量x
    decltype(cj) z; // Error， z是一个引用，必须初始化

*  1
 *  2
 *  3
 *  4

*  `decltype`的结果类型与表达式形式密切相关

对于`decltype`所用的引用来说，如果变量名加上了一对括号，则得到的类型与不加括号时会有所不同。如果`decltype`使用的是一个不加括号的变量，则得到的结果就是该变量的类型；如果给变量加上了一层或多层括号，编译器就会把它当成是一个表达式。

decltype((i)) d; // Error, d是int&, 必须初始化
    decltype(i) e;   // OK, e是一个未初始化的int

*  1
 *  2

*  模板函数的返回类型   
    
    
     *  在 C++11 中，可以结合使用尾随返回类型上的 `decltype` 类型说明符和 `auto` 关键字来声明其返回类型依赖于其模板参数类型的模板函数。
     *  在 C++14 中，可以使用不带尾随返回类型的 `decltype(auto)` 来声明其返回类型取决于其模板参数类型的模板函数。

//下面给出一个使用迭代器运算符修改容器元素的代码示例：
    #include <iostream>
    #include <string>
    #include <vector>
    using namespace std;
    
    int main()
    {
    	vector<int> v(10,1);
    	int i = 1;
    	cout << "未修改前:";
    	for (auto v_quto : v)//通过使用auto关键字,让编译器来决定变量v_quto的类型 每次迭代,v的下一个字符被拷贝给v_quto
    	{
    		cout << v_quto << " ";
    	}
    	for (auto  v_quto : v)
    	{
    		cout << v_quto << " ";
    	}
    	//循环首先使用v.begin()来初始化v_quto 意味着v_quto指示着v中的第一个字符(如果有的话) 
    	//条件部分检查是否达到v的尾部,如果未达到 则将v解引用的结果传入isspace函数检查是否遇到了空白,每次迭代的最后,执行++v_quto令迭代器前移一个位置来访问v的下一个字符
    	for (auto v_quto = v.begin(); v_quto != v.end();++v_quto)
    	{
    		*v_quto += i;
    		++i;
    	}
    	cout << "\n====================修改后：===============\n" << endl;
    	for (auto v_quto : v)
    	{
    		cout << v_quto << " ";
    	}
    	system("pause");
    	return 0;
    }

迭代器的类型   
那些拥有迭代器的标准库类型都是使用：iterator和const\_iterator来表示迭代器的类型：

vector <int> ::iterator it;        //it能读写vector<int>的元素
        vector <int>::const_iterator it;  //it只能读vector<int>的元素，不可以修改vector<int>中的元素
    
        string::iterator s;               //s可以读写string对象中的元素
        string::const_iterator s;          //s只可以读string对象中的元素，不可以修改string对象中的元素

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

const\_iterator和常量指针一样，只可以读取但不可以修改所指的值。在c++11的新标准中，为了便于得到const\_iterator类型的返回值，引入两个新的函数，分别是cbegin和cend,功能类似于begin和end，只是返回的值类型为const\_iterator;

vector动态增长的限制：   
（1）：不能再范围for循环中向vector对象添加元素。   
（2）：任何一种可能改变vector容量的操作，比如push\_back,都会使该vector对象的迭代器失效。

迭代器的运算

iter+n           //迭代器加上一个整数值仍得到一个迭代器，迭代器指示的新位置向前移动了，指示可能是容器的一个元素或者是尾部的下一个位置
    iter-n          //相反，迭代器指示的位置向后移动了，指示可能是容器的一个元素或者是尾部的下一个位置
    iter1+=n   //等价于iter1+n
    iter1-=n    //等价于iter2-n
    iter1-iter2  //两个迭代器的距离，
    >，<,>=,<= //位置离begin近的较小

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

两个迭代器返回的值，在string和vector都为它定义了一个新的类型–difference\_type,它是一个带符号的整型。

迭代器相减可以得到两个迭代器指针的距离，即右边的迭代器移动多少个距离可以追上左侧的迭代器

得到的距离类型为difference\_type，是带符号整型

使用这个运算我们可以很容易得到对象中间位置的元素

auto mid = v.begin() + ( v.end() - v.begin() ) / 2;

#include <iostream>
    #include <string>
    #include <vector>
    #include<algorithm>
    using namespace std;
    
    int main()
    {
    	vector<int> v{1,20,10,5,6,7,90};
    	cout << "请输入需要查找的值:";
    	int temp = 0;
    	cin >> temp;
    	sort(v.begin(),v.end());//使用排序函数对容器vector中的元素进行排序
    
    	auto beg = v.begin();//数组首元素
    	auto end = v.end();//数组尾元素
    	//迭代器相减可以得到两个迭代器指针的距离，即右边的迭代器移动多少个距离可以追上左侧的迭代器
    	//得到的距离类型为difference_type，是带符号整型
    	//使用这个运算我们可以很容易得到对象中间位置的元素
    
    	auto mid = v.begin() + (end - beg) / 2;//迭代器加上一个整数值仍然是一个迭代器 迭代器的指示的位置与原来相比向前移动若干个元素
    
    	/*
    	二分查找法：
    	每次都拿中间的那个值和需要查找的值做比较，如果相等就退出查找
    	如果查找的值比中间那个值小，则向前查找
    	如果查找的值比中间那个值大，则向后查找
    	*/
    
    	while (mid !=end && *mid != temp)
    	{
    		if (temp < *mid)//查找的值比中间值小 向前查找 把中间值变成end
    		{
    			end = mid;
    		}
    		else//查找的值比中间值大 向后查找 把中间值变成beg
    		{
    			beg = mid + 1;//迭代器加1 指的是向前移动一个元素
    		}
    		mid = beg + (end - beg) / 2;//重新计算中间值
    	}
    	if (*mid == temp)
    		cout << "find" << endl;
    	else
    		cout << "Not find" << endl;
    	system("pause");
    	return 0;
    }

#include <iostream>
    #include <vector>
    #include <algorithm>
    
    using namespace std;
    
    int main()
    {
    	vector<int> v{ 1, 20, 10, 5, 6, 7, 90 };
    	//数组必须是有序
    	cout << "请输入需要查找的值:";
    	int temp = 0;
    	cin >> temp;
    	sort(v.begin(), v.end());//使用排序函数对容器vector中的元素进行排序
    
    	auto beg = v.begin();
    	auto end = v.end();
    	auto mid = v.begin() + (end - beg) / 2;
    	//当还有元素尚未检查并且我们还没有找到temp时,执行循环体
    	while (mid !=end && *mid != temp)
    	{
    		if (*mid > temp)//我们要找的元素在前半部分
    		{
    			//调整搜索范围 忽略掉后半部分
    			end = mid;
    		}//我们要找到的元素在后半部分
    		else
    		{
    			//在mid之后寻找
    			beg = mid + 1;
    		}
    		mid = beg + (end - beg) / 2;//新的中间点
    	}
    	if (*mid == temp)
    	{
    		cout << "v 中 found:" << *mid << endl;
    	}
    	else
    	{
    		cout << "v 中 unfound:" << temp << endl;
    	}
    	system("pause");
    	return 0;
    }

**第三章 05 数组**

# 定义和初始化 #

## 维度必须是常量 ##

数组维度必须是一个常量表达式，保证在编译时维度是已知的

unsigned cnt = 42;  
    constexpr unsigned sz = 42;  
    int arr[10];  
    //含有10个整数的数组  
    int *parr[sz];  
    //含有42个整型指针的数组  
    string bad[cnt];  
    //错误：cnt不是常量  
    string strs[ get_size() ];  
    //仅当get_size()是constexpr时正确

## 列表初始化 ##

使用列表初始化时，可以忽略维度，编译器会自动计算

int az[] = { 0, 1, 2 };

如果指明维度，需要保证列表中元素的个数小于维度

string a4[3] = { "hi", "bye" };

字符数组有一种额外的初始化形式，使用字符串初始化

char a2[] = "c++";  
    char a4[6] = "daniel";

此时要注意字符串末尾还有一个空字符，a2的维度是4，a4出错，因为没有位置存放空字符

## 复杂的声明 ##

int *ptrs[10];  
    int (*Parray)[10] = &arr;  
    int (&arrRef)[10] = arr;  
    int *(&arry)[10] = ptrs;

> 理解的方法还是从右到左，有圆括号时，括号优先

对于ptrs，从右向左，首先知道它的维度是10，然后它的名字是ptrs，然后知道数组中存放的是int \*，因此ptrs是含有10个整型指针的数组

对于Parray，括号优先，括号里面知道它是一个指针，然后从右向左，知道它指向一个维度为10的数组，再向左知道数组中元素是int类型，因此Parray是指向一个含有10个整数的数组

后面两个留给大家

# 数组元素的访问 #

1.  范围for
2.  下标
3.  迭代器（指针）

1和2与前面的用法一样

数组下标通常定义成size\_t类型，它是一种机器相关的无符号类型

## 指针也是迭代器 ##

指向数组元素的指针比普通指针拥有更多的功能，string和vector的迭代器支持的自动，它全支持

数组有两个特性，也是和迭代器相关的

1.  很多用到数组名的地方，都会自动地把数组名替换为一个指向数组首元素的指针，这个可以理解是为了方便得到起始位置
2.  通常来说尝试获取一个不存在的对象的地址是非法的，但是允许获取数组尾后元素的地址

对于第1点

string nums[] = { "one", "two" };  
    string *p = &nums[10];

p是指向数组首元素的指针，但还有更简单的写法

string *p = nums;

对于第2点

下面是一个看上去非法的语法

int arr[] = { 0, 1, 2 };  
    int *p = &arr[3];

尽管3这个下标已经越界了，仍允许我们这么多，为的就是获得尾后指针

有了起始位置和结束位置，以及递增和解引用等操作，指向数组元素的指针也能行使和迭代器一样的职责了

当然，c++总是在进步的**。c++11在iterator头文件中提供了两个函数begin和end**，可以方便安全的获得数组首尾迭代器

int *beg = begin( arr );  
    itn *last = end( arr );

## 指向数组元素的指针与下标运算 ##

int ia[] = { 0, 2, 4, 6, 8 };  
    int *p = &ia[2];  
    int j = p[1];  
    int k = p[-2];

p\[1\]等价于\*(p+1)  
p\[-2\]等价于\*(p-2)

# 数组与vector #

数组还可以用来初始化vector对象，只需要指明待拷贝区域的首尾元素地址就可以了

int arr[] = { 0, 1, 2, 3 };  
    vector<int> ivec( begin(arr), end(arr) );

> 建议：尽量使用vector和string，而非数组。数组和指针容易产生一些概念和理解上的错误

上面用数组来初始化vector的机制，有助于我们用vector来代替数组

那么，字符数组能否转换成string呢

允许使用以空字符结束的字符数组来初始化string对象或为string对象赋值

当然，如果需要也可以把string对象转换为指向字符的指针

const char *str = s.c_str();

多维数组其实就是数组的数组

int ia[3][4];

由内向外读：ia是含有3个元素的数组，它的每个元素都是含有4个整数的数组

初始化

int ia[3][4] = {  { 0, 1, 2, 3}, { 4, 5, 6, 7}, { 8, 9, 10, 11} };

本质上和一维数组的初始化没有区别，ia有3个元素，所以外层花括号里面有3个花括号，每个花括号分别用来初始化ia的一个元素

和一维数组一样，也可以只给出一部分初始值

int ix[3][4] = {  { 0}, { 4}, { 8} };  
    
    int ia[3][4] = {  0， 3， 6， 9 };

## 下标 ##

ia\[2\]\[3\] 返回ia第二个元素（数组）的第三个元素

ia\[1\] 返回ia的第一个元素（数组）

注意理解多维数组其实就是数组的数组就可以了

## 范围for ##

可以使用for循环和范围for来遍历多维数组

在使用范围for时，最好将控制变量都声明为引用类型

size_t cnt = 0;  
    for( auto &row : ia )  
    {   
        for( auto &col : row )  
        {   
            col = cnt;  
            ++cnt;  
        }  
    }

如果不声明为引用类型

for( auto row : ia )  
        for( auto col : row )

第一行取ia的每个元素，是数组类型，会被编译器转换为指向首元素的指针，第二行就会报错

因此，只有最内层的循环可以不使用引用类型

简单起见，最好都使用引用类型

## 指针和多维数组 ##

多维数组的数组名也会自动转换为指针

int ia[3][4];  
    auto p = ia;

理解过程：

1.  ia是一个含有3个元素的数组
2.  它的每个元素都是含有4个元素的数组。
3.  因此，它的首元素也是含有4个元素的数组
4.  指向首元素的指针就是指向含有4个元素的数组的指针

等价于

int (*p)[4] = ia;

遍历每个元素

for( auto p = ia; p != ia + 3; ++p )  
    {   
        for( auto q = *p; q != *p + 4; ++ q )  
        {   
            cout << *q << ' ';   
        }  
        cout << endl;  
    }

对p解引用可得到含有4个元素的数组，\*p是指向它的首元素的指针

也可以使用**begin和end函数**

for( auto p = begin(ia); p != end(ia); ++p )  
    {   
        for( auto q = begin(*p); q != end(*p); ++ q )  
        {   
            cout << *q << ' ';   
        }  
        cout << endl;  
    }

## 使用类型别名简化书写 ##

using int_array = int[4];  
    typedef int int_array[4];

别忘了，typedef的形式和变量声明类似

[70]: /images/20220523/80bc90123b644302b98573551a77f584.png
[70 1]: /images/20220523/b6689ca3c9494a88a72f4723d46be0fb.png
[C_ auto]: http://blog.csdn.net/yhl_leo/article/details/50864612