C++ Primer 笔记 第三章

之前对命名空间的使用都是以 namespace name + scope operator + object name 的形式进行使用，比如:

std::cin //using cin in namespace std;

#include<iostream>
using std::cin; //using declaration for cin in namespace std
int i;
cin >> i;

/*using declaration for 3 different names*/
using std::cin;
using std::cout;
using std::endl;
int i;
cin >>i;
cout << i << endl;

string是一个字符组成的，长度可变的序列。在C++中，使用string前需要：

#include <string> //string is a part of the library.
using std::string; //string is defined in std namespace.

string用string关键字定义。string的初始化有好几种方法，可以大致分为直接初始化和复制初始化。这两者的区别主要是看在初始化的时候有没有用上 “=” 运算符。举个例子：

string s0; //default initialization, s0 is empty.
string s1("good"); //direct initialization;
string s2(10, 'c'); //direct initialization; string is ten copies of char 'c';
string s3 = s0; //s3 is a copy of s0;
string s4(s0); //equivalent to s3 = s0;
string s5 = "good"; // copy initialization;

string 的读入操作有两种常用的方式：» 运算符和 getline 函数。
» 运算符遇到 whitespace (空格，换行，tabs等等）的时候会结束读取，因此读取只会保留 whitespace 以前的部分：比如读取”hello world“,打印出来就变成了”hello“。

因为 string 是左值，因此 stream 运算符在 string 中是可以连用的：

string s1, s2;
cin >> s1 >> s2;
cout << s1 << s2 << endl;

如果需要读取不确定数量的 string，可以使用之前的 while 循环加输入判定写法。判定为假的条件是 EOF / 或者输入不合法：

string word;
//false when hit the end of line or invalid input
while(cin >> word){
    cout << word << endl;
}

如果我们希望同时也读入 whitespace 字符,那么我们需要用 getline(). getline() 需要一个 stream 对象和一个 string 对象作为输入，并将 stream 内容的第一行存储到 string 中。当换行（遇到 \n）以后，getline 就会结束读取并返回读取的 string 到 stream 中。如果 stream 的第一个字符是 \n，那么 string 为空。

getline 返回的是 istream 对象，因此可以用于条件判断。 所以我们也可以通过以下代码来读取一个 string:

string line;
while (getline(cin, strLine)){
    cout << strLine << endl;
}

empy() 与 size() 两者都是 string 的成员函数。

empty() 判断当前的 string 是否为空，如果为空返回 bool 类型 ture，否则返回 false。比如：

while (getline(cin,string)) {
	if(!string.empty())
		cout << string << endl;
}

同样的，size() 也是 string 类的一个成员函数，用于计算 string 的长度。我们可以通过和访问 empty() 同样的方法去访问它。

不过需要注意的是，size() 返回的值并不是int，而是 string::size_type 类型。这个是一个 unsigned 的类型，所以要避免与 signed 的类型比较。该类型可以被 “视作” unsigned integer 类型, 但需要注意的是 size_type() 是一个固定值，而 unsigned integer 的字长会根据计算机的而浮动。

size_type() 类型的出现，是因为size() 需要有一个大小固定且足够大的类型来描述 string 的长度。大多数情况下 size_type 与 unsigned integer 用法相同；使用的时候需要注意以下几点：

• size_type 是无符号的，不能和带符号变量进行条件判断。
• 不能把 size_type 当成 int 类型理解。在定义 size_tpye 类型变量的时候，可以使用 auto 来获取类型。

String 之间的比较分为比较是否相等和比较大小两大类。比较是区分大小写的。

当比较相等的时候，使用 equality operator (== 和 !=)。两个 string 相等的条件是长度相同并且所包含的字符相同。

当比较大小的时候，使用 relational operator (<，≤，>，≥)。比较的过程如下：

• 如果两个 string 长度不相同，且长度较短的 string 内所有的字符与较长 string 对应位置上的字符都相同，那么较长的 string 比较大。
• 如果两个 string 对应位置上的字符不完全相同，那么该比较将会转化为对两个 string 上第一位不相同的字符的比较（ASCII 值）。

"Hello" vs "Hello World": "Hello" is shorter
"Hello" vs "Hiya" : "Hiya" is greater since i > e

• string 的赋值：将一个 string 拷贝给另外一个 string
• string 的相加：将两个 string 连接起来，将加号右边的 string 加到左边 string 的末尾
• string 与 literal 的混合相加：将 string 与 literal 连起来

string s1 = "hello", s2, s3, s4;
s2 = s1; //assignment;
s3 = s1 + s2; //adding two strings
s1 += s2; //adding s2 to the end of s1
s4 = s1 + ", " + s2; //adding literals and strings

string s2;
string s = "hello" + ", " + s2; //error, "hello" and ", " can't be added

C++ 通过头文件 cctype 中定义的下列函数来对单个字符进行操作：

C++11中提出了一种新的方法遍历string: range for。形式如下：

for (declaration : expression) 
    statement

string str ("hello world.");
for (auto c : str)
    cout <<  c << endl;

string s("Hello World!!!");
decltpye(s.size()) punct_cnt = 0;
for (auto c : s) {
	if (ispunct(c)) {
		++punct_cnt;
	}
	cout << punct_cnt << endl;
}

string str ("hello world.");
for (auto &c : str)// c is reference here
    c = toupper(c);

如果只想处理字符串中的某些字符，有两种方法：

第一种方法是使用下标（Subscript）来访问指定的元素。[] 下标操作符（Subscript operator）获取 string::size_type 类型的值来拿到我们想访问的字符，该操作返回对应位置字符的引用。下标的范围是[0, s.size() -1]。

因此，使用下标访问字符串之前，最好检查字符串是否是空字符串：

string s("xyz");
if (!s.empty()) {
	s[0] = toupper(s[0]);
}

string str ("hello world.");
for（decltype(s.size()) index = 0; 
	 index != s.size() && !isspace(s[index]; ++index) //if the index in range and not a space
	s[index] = toupper(s[index]); //then capitalize

Vector 是 C++ 标准库中提供的一种容器（Container），用于存储一系列的对象。每个对象都被给与了指定的目录用于访问。声明 vector 的方法如下：

#Include <vector> // must include the appropriate header in order to use vector
using std::vector;

vector<int> ivec; //ivec holds elements of type int.
vector<Sale_item> S_vec; // vector also can hold class;
vector<vector<string>> file; // and can hold vectors too;

vector<vector<string> > file; // old format, must have a space before the closing outter angle bracket.
vector<vector<string>> file; // ok in C++11.

• 由于我们能够很有效的在 runtime 期间对 vector 进行操作，所以最普遍的 vector 初始化方式就是定义一个空的 vector。
• 如果希望使用其他 vector 进行初始化，那么 initializer vector 必须与目标 vector 的类型相同。

vector<T> v1; //Default initialization, vector that holds objects of type T. v1 is empty.
vector<T> v2(v1); // v2 has copy of each element in v1.
vector<T> v2 = v1; // equivalent to v2(v1);
vector<T> v3(n, val); // v3 has n elements with value val.
vector<T> v4(n); //v4 has n elements with default value.
vector<T> v5{1,2,3,....} //List initialization, must comes with curly brace.
vector<T> v6 = { 1,2,3,....} // equivalent to v5.

vector listing initialization 是 C++ 11的新特性，允许我们用 list (大括号) 的形式对 vector 进行初始化：

vector<string> articles = {"a", "an", "the"};

vector<string> v1 ("a", "b", "c"); //error, too many initializers

如果需要创建指定元素个数的 vector，我们使用括号进行初始化：

vector<int> v1(10, 1); //vector has 10 elements with value 1

使用值对 vector 初始化的时候，可以只指定 vector 的大小。vector 会自动创建 value-initialized 元素来进行初始化。通常情况下，如果 vector 元素的类型是 Build-in type，那么初始值为 0；如果是类，那么初始值为类的默认初始化值。

值初始化有两种形式上的限制：

• 某些类在初始化的时候要求显式的给与 initializer；对于这种不能默认初始化的类，我们必须同时给与大小与初始值。
• 如果使用单个元素的值初始化，那么必须使用直接初始化形式（copy 形式的初始化必须提供元素个数）

需要注意的是，使用大括号的初始化意味着完全不同的意义：

vector<int> v1(10, 1); //vector has 10 elements with value 1.
vector<int> v2{10, 1}; //vector has 2 elements, 10 and 1.

vector<string> v7{10}; //10 elements with default value
vector<string> v8{10, "hi"}; //10 elements with value "hi"

Vector 由于其可以在 runtime 下修改的特性，往往用在比较 flexble 的场景中。C++ 中提供了非常多的函数用于对 vector 的数据进行操作。

C++ 使用 push_back() 成员函数对 vector 进行元素添加操作。该函数接收一个元素，并将该元素“推”到 vector 当前的最后一个位置上：

vector<int> v2; // empty vector
for (int i = 0; i != 100; ++i)
    v2.push_back(i); // append sequential integers to v2
// at end of loop v2 has 100 elements, values 0 . . . 99

string word;
vector<string> v;
while(cin >> word) {
    v.push_back(word); //append word to tex
}

除开 push_back()，C++ 还为 vector 提供了一些常用的操作：



值得提醒的是，size() 函数的返回值也是 size_type。如果需要定义该类型数据的 vector，必须指定该类型数据对应的类型：

vector<int>::size_type

• vector 在长度以及每个对应元素都相等的情况下相等
• 如果 vector 一场一短，短 vector 中元素与长 vector 中元素一一对应并相等，那么 长的 vector 比较大
• 否则比较第一个不同的元素
• 比较元素的前提是元素之间存在着大小关系。 vector 无法比较不存在 equality 和 relational 关系的元素。

当然，像 string 一样，也可以使用 range for 对 vector 进行遍历：

vector<int> v{1,2,3,4,5,6,7,8,9};
for (auto &i : v)
    i*=i;//square the element value
for (auto i : v)
    cout << i << endl;

与 string 类似，vector 也可以通过类型为 size_type 的下标对指定元素进行访问和修改。下面是一个例子：

/*
*给定一串 100 以内的数，将 100 分成 10 个相等区间，统计每个数出现在自己区域的出现次数。
*/
vector<unsigned> scores(11, 0); //11 containers for counters 0-9..90-99, 100
unsigned grade;
while (cin >> grade) {
    if (grade <= 100) {
    ++scores[grade / 10];
    }
}

vector<int> v; //empty vector;
for(decltype(v.size() ix = 0; ix != 10; ++ix)
    v[ix] = ix; //error!!

迭代器（Iterators）是 C++ 提供的一种与下标功能类似的，但更加通用的访问元素的方式。这种方式使用更加广泛，基本上 STL 中的所有容器都可以使用迭代器（string 不是容器，但支持很多容器的算法）。

迭代器类似于指针，代表了当前元素的位置与内容；同时迭代器通过自身的运算可以改变指向的元素，方便遍历。 与指针不同的是，迭代器并不直接使用地址来指向元素，而是使用成员函数 begin() 和 end() 来返回迭代器。begin() 返回指向容器第一个元素的迭代器，而 end() 返回的是容器最后一个元素下一个位置（one past the end）的迭代器。end.() 的返回的迭代器并不指向任何的有效元素，只是作为容器的边界使用（off-the-end-iterator）。因此如果容器是空的，那么 begin() 与 end.() 返回的迭代器都是 off-the-end-iterator。
<html>

</html>

迭代器支持一系列的操作：



利用迭代器性质判断容器是否为空：

string s("a string");
if(s.begin() != s.end()) {//if s is not empty
    auto it  = s.begin(); // we don't care about what kind of type that iterator has.
    *it = toupper(*it);//access the element like pointer
}

迭代器通过 ++ 运算来实现改变指向的元素。++ 的意思是 “将当前迭代器的位置推进到下个元素的位置”。我们可以利用该运算符来对整个容器进行迭代：

//alternative iterator approch for Q.3.2.3
string s = "Hello World";
for (auto it = s.begin(); it != s.end() && isspace(*it); ++it) {
	*it = toupper(*it);
}

迭代器的类型与之前提到过的 size_type 类似，我们往往不会知道其具体的类型。相比之下更重要的是我们需要知道 iterator 与 const_iterator 的区别：

vector<int>::iterator it; // can read and wirte int elements
vector<int>::const_iterator cit; //can read but not write int elements
string::iterator it2; //string ver
string::const_iterator cit2;

begin() 与 end() 返回的类型取决于被操作的对象是否是常量。如果是，那么他们返回 const_iterator，反之返回 iterator。

vector<int> v;
const vector<int> cv;
auto it1 = v.begin(); //iterator
auto it2 = cv.begin(); //const_iterator

auto it3 = v.cbegin(); //vector<int>::const_iterator

有时候我们会使用装载类的容器。这种情况下一个常见的操作是首先是先访问类（解应用 *），再访问类的成员函数。通常这种复合操作需要指定优先级，也就是括号：

(*it).empty(); //The brace ensures dereference happens first
*it.empty(); //empty() only applys to it, not *it

it->empty();

for (auto it = text.cbegin(); it != text.cend() && !it->empty(); ++it) {....;}

需要注意的是 vector 有导致迭代器无效的潜在危险。比如像已经确定范围的 vector 遍历过程中再对该 vector 添加新的元素，那么迭代器会有很大的概率会失效。因此，需要确保在使用迭代器循环的时候不能往其操作的容器中添加新的元素。

迭代器通常支持位移（++）运算，比较运算和关系运算。String 和 Vector 额外支持一次移动迭代器好几位的运算： 当迭代器进行算术运算的时候，参与运算的迭代器必须指向同一个容器内的元素，或者是指向容器最后一个元素的下一个位置（off-the-end-iterator）。下面一个例子使用了头部迭代器和 size 信息计算了容器中部的迭代器：

auto mid = vi.begin() + vi.size() / 2;

• 参与运算的迭代器有效
• 参与运算的迭代器处于同个容器的有效范围内

除此之外，两个满足上述要求的迭代器还能进行相减的操作。得到的结果是两个迭代器之间的距离；也就是一个迭代器要到达另外一个迭代器所在位置需要移动的单位数。相减得到的结果是一个有符号的、类型名为 difference_type 的类型。

一个比较经典的，使用迭代器的算法是二分查找法（Binary search）。

auto beg = text.begin(), end = text.end();
auto mid = text.begin() + (end - beg) / 2;

while (mid != end && *mid != sought) {
	if (sought < *mid){
		end = mid;
	}
	else {
		beg = mid + 1;
	}
	mid = beg + (end - beg) / 2;
}

数组（Arrays）是一种与 vector 相似的数据结构。与 vector 不同的是，数组的大小是固定的。在 run-time 期 数组的性能往往好于 vector，但这是以付出灵活性为代价的。

定义数组的形式是 arrayName[Dimentions]。数组必须在编译的时候确定大小，而数组的 Dimension 必须是个常量表达式。

int i = 10;
constexpr ci  = 10; 
int arr[10]; // ok
int *parr[ci]; //ok, 42 pointers
int bad[i]; // error, dimension of array must be a constant expression
string strs[get_size()];// ok only if get_size is const expression

1. Build-in type 类型的数组在函数内部的默认初始化结果与 build-in type 一致，都是 undefined.
2. 定义数组的时候必须指定类型，不能用 auto 去推断。
3. 数组装载的元素均为对象，因此不存在元素为引用的数组。

当采用 List 的方式初始化数组时，如果不设置 dimension, 编译器会根据初始化元素的个数推断dimension；如果初始化元素个数小于 dimension,那么编译器会自动对余下的位置进行值初始化，初始化的值根据元素的类型来决定：

const unsigned sz = 3;
int a1[sz] = {0,1,3}; //dimension = 3
int a2[] = {0,1,2}; //dimenstion = 3
int a3[5] = {0,1,2}; // two elements are value initialized, {0,1,2,0,0}

字符串是比较特别的一种数组。当使用字符串 literal 对字符串数组进行初始化的时候，字符串需要额外的一位空间来装载字符串的终止符 \0：

char a1[] ={'c', '+', '+' }; //no null
char a2[] ={'c', '+', '+', '\0'}; //mannally add null
char a3[] = "c++"; // has null
const char a4[3] = "Hey"; //error, can't add null

数组是无法通过另外一个数组来初始化的，也不能直接将一个数组赋值给另外一个数组：

int a[] = {1,2};
int b[] = a; //error
b = a; //error

数组也可以与复合类型一起使用，组成更复杂的类型。除了引用以外，数组可以与绝大部分类型一起使用，但是也更复杂。相较于之前从右往左看的识别方法，识别数组声明的类型是从内往外看的，比如下面例子的第三个定义：

int *ptrs[10]; //array of pointers to int
int &ptrs[10] = ??; //error, reference is not object
int (*Parray)[10] = &arr; //points to an array of ten ints
int (&arrRef)[10] = arr; //reference to an array of ten ints

1. 首先找到 变量名 Parray，发现 Parray 是一个指针类型的变量 *Parray。
2. 然后跳出括号看，左边是这个指针指向数组的大小，右边是这个数组的类型。
3. 因此 int (*Parray)[10] 是一个指向 int[10] 数组的指针。

再来看一个更复杂的例子 int *(&arry) [10] = ptrs，看看这个表达式是如何适配从里往外看的规律的：

1. 首先看到了括号，那么对括号里的内容进行分析，括号里从右往左看发现 arry 是一个引用
2. 接着往外看，*(&arry) 意味这该引用是 refer to 指针的引用
3. 再往外看，左边是 [10]，右边是 int，因此确定数组装载了 10 个指向 int 的指针
4. 那么这个例子定义的是一个引用，这个引用 refer to 一个数组，数组里装载了 10个指向 int 类型数据的指针。

我们可以用下标或者 Range for 来访问数组；下标的范围是[0, size-1]。数组的下标类型是 size_t，是一种机器指定的，保证有足够空间存储任何对象的类型。该类型被定义于 cstddef (c 语言中是 stddef.h 中。

使用下标访问数组与 vector 基本上类似，唯一的区别在于数组与 vector 声明的方式不一样。除此之外，[] 下标运算符虽然看上去一样，但在 vector 和数组中是不同的两种运算符。

除此之外，数组还能用 range for 遍历：

for (auto i : arry)
    cout << i <<endl;

不管是 string、vector 还是数组，保证下标的值在 [0 , size() -1] 的范围内都是极其重要的一件事。这种因为下标越界而带来的安全问题称为 Buff Overflow Bug。

在 C++ 中，指针与数组的联系非常紧密。总的来说，指针通过 address-of operator 来访问对象；由于数组的元素都是对象，因此指针也可以用来访问数组的元素：

string num[] ={"1", "2", "3"};
string *p = &num[0];

string *p2 = num; //equal string *p2 = &num[0], 注意这里 num 没有取地址

int arry[] = {0,1,2};
auto t(arry); // equivalent to auto t = arry; auto deduces that t is a int* type
t = 42; //error, can't assign a int to a pointer

auto t(&arry[0]); // t is pointer that points to the first element of arry

int ia[] ={1,1,1,1}
decltype(ia) ia2 = {1,2,3,4};
ia2[2] = 4; // ok, assgin int to an element in ia2

在数组中，可以将指针像在 vector 中使用迭代器一样使用：

int arr [] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;
++p; // p will points from arr[0] to arr[1]

int  arry[] = {0,1,2,3,4}
int *e = & arry[5];  //The max index is 4, e is the off-the-end ponter of arry
for (int *b = arry; b != e; ++b)
     cout << *b << endl;

尽管能通过下标得到 off-the-end pointer, 但这样做真的很容易犯错。幸好 C++ 11 为指针也提供了类似迭代器的 begin() 和 end()。这两个函数分别返回指向数组的第一个指针和 off-the-end 指针，于是上一小节的例子就可以写成：

int  arry[] = {0,1,2,3,4}
int *pBeg = begin(arry);
int *pEnd = end(arry);
for (p_beg; pBeg != pEnd; ++pBeg)
      statements;

#include <iterator>
using std::begin;
using std::end;

在数组中，指针可以进行一切迭代器可以进行的运算，意义也是一样的；使用迭代器的限制也同样应用于指针：

constexpr size_t sz = 5;
int arr[sz] = {1,2,3,4,5,6};
int *ip = arr;
int *ip2 = ip + 5; // a new pointer points the 5th element behind the first element
int *ip3 = ip + 6; //error, arr has 5 elements, ip3 has an undefined value
int *ip4 = arr + sz; //ok but do not dereference

int *b = arr;
int *e = arr + sz;
while (b < e) { 
    do sth....
    ++b;
}

指针与整型的加减会返回一个指针。如果想获取该指针对应的元素内容，需要使用括号确定指针的加减运算：

int a[] = {0,2,4,6,8};
int last = *(a + 4); // last = a[4];
last= *a + 4 // last = a[0] + 4;

使用下标访问数组实际上就是在对当前的指针进行计算，比如：

int ia = {0,2,4,6,8};
int i = ia[2];

int *p = ia; // p points to the first element of ia
ia[2] = *(p + 2);

int *p = &ia[2]; // p points to 3rd element of ia
int j = p[1]; // p[1] equal *(p + 1), a[3]
int k =p[-2] // p[-2] equal *(p - 2), a[0]

字符串 literal 并不是类型，而是一种继承自 c style string 的实例。这种结构实际上是一个以 /0 （null terminated) 为结尾的字符数组。通常我们使用指针来操作字符串 literal。

C 中有操作该类字符串的函数，定义于 string.h 内（C++ 中是 cstring）： 以上的函数均不会校验其收到的参数，因此需要特别注意参数的合法性。一个比较常见的错误就是将没有 null terminated 的字符串作为以上函数的参数：

char ca[] = {'C', '+', '+'}; // not null terminated
cout << strlen(ca) << endl; // disaster，undefined

不像 C++ string, C style string 并不能直接使用关系运算符比较大小：

char ca[] = "teststringa";
char cb[] = "teststringb";
if (ca > cb) // undefined

if (strcmp(ca, cb) < 0)

如果想将两个字符串连接起来，C++ 中使用 + 运算就可以。但在 C style string 中需要将 strcat 和 strcpy 配合使用才能达到同样的效果（直接相加会导致不同对象的指针相加）。在使用上述两个函数连接字符串时，用于存储的字符数组必须足够大到装下结果字符串以及 /0。

很多在 STL 出来之前的 C++ 程序，或是为 C 程序做的接口，都没有用上 vector 和 string。C++ 提供了一些功能用于衔接这些老程序和现代 C++。

首先，C style string，也就是 null-terminated char array，可以用于任何 string literal 适用的场景，比如：

• 使用 c-string 初始化 & 赋值 string
• 与 string 混用时，c-string 可以充当算子：比如 string 与 c-string 的相加。

需要注意的是，上述规则反过来用是不行的。如果在某些特定的情况下需要使用 string 作为 c-string 的初始值，那么可以用到 string 的成员函数 c_str 来实现：

const char *str = s.c_str();

C++ 中，vector 不能初始化数组，但反过来可以。vector 的初始化可以接收两个数组指针作为参数，来确定初始值：

int int_arr[] {0,1,2,3,4,5};
vector<int> ivec(begin(int_arr), end(int_arr));

vector<int> ivec2(int_arr + 1, int_arr + 4); //int_arr[1] to int_arr[3]

在多维数组的定义中，定义的实际是包含数组的数组。我们可以看到，多维数组的定义实际上是：

type array[sub_array1][sub_array2]...[elements];

我们再用list初始化的方法来看一看二维数组：

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

int ia[3][4] = { {0}, {4}, {8} };
//{0,0,0,0,4,0,0,0,8,0,0,0}

int ix [3][4] = {1,2,3,4}; 
//{1,2,3,4,0,0,0,0,0,0,0,0}

对于多维数组的遍历，外层循坏对应数组左边的 subscript, 内层循环对应数组右边的 subscript。所以对于二维数组的遍历，我们是在外层循环遍历行（以数组为单位的元素），内层循环则遍历该数组的内部元素。比如：

constexpr size_t rowCnt = 3, colCnt = 4;
int ia[rowCont][colCnt];
//for each row
for (size_t i = 0; i < rowCnt; ++i) {
	//for each elements (column)
	for (size_t j = 0; j < colCnt; ++j) {
		ia[i][j] = i * colCnt + j;
	}
}

C++ 11 允许使用 range for 访问多维数组：

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

for (const auto &row : ia) 
	for (auto col : row)
		cout << col << endl;

首先需要再次明确的是，当使用数组名的时候，数组会自动的转换成指向第一个元素的指针。因为多维数组是真正的包含数组的数组，因此该指针指向的对象实际上是第一个内层数组：

int ia[3][4];
int (*p)[4] = ia;// p is pointer points to an array with 4 ints
p = &ia[2]; //p points to the 3rd sub array in ia

int *p[4]; // array with 4 pointers that point to int
int (*p)[4]; // a pointer points to an array with 4 ints

for (auto p = ia; p ！= i  * a + 3； ++p) {
	for (auto q = *p; q != *p + 4; ++q)
		cout << *q << " ";
	cout << endl;
}

1. 首先需要获取内层数组。p 作为外层指针，指向的元素就是内层数组。因此，对 p 解引用则可获取内层数组。
2. 再次进行数组名到指针的转换。此处定义了 q，auto 判断 q 是指向内层数组第一个元素的指针类型
3. 再通过位移 q 完成对内层的循环。

当然，使用标准库函数 begin() 和 end() 会更加简单：

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

另一种方式是使用 type alias 简化数组的类型：

typedef int(*p)[4] int_arr;
using int_arr = int[4];
for (int_arr p = ia; p != ia +3; ++p) {
	for (int_arr q = *p; q != *p + 4; ++q) {
		cout << *q << endl;
	}
}