上一节学习了C的函数：c++：-2，本节学习C的数组、指针和字符串
##数组
###定义和初始化
####定义
例如：int a[10];
表示a为整型数组，有10个元素：a[0]...a[9]
例如: int a[5][3];
表示a为整型二维数组，其中第一维有5个下标（04），第二维有3个下标（02），数组的元素个数为15，可以用于存放5行3列的整型数据表格。
####使用
- 必须先声明，后使用。
- 只能逐个引用数组元素，而不能一次引用整个数组
例如：a[0]=a[5]+a[7]-a[2*3]
例如：b[1][2]=a[2][3]/2
####存储
（1）一维数组的存储
数组元素在内存中顺次存放，它们的地址是连续的。元素间物理地址上的相邻，对应着逻辑次序上的相邻。
（2）二维数组的存储
按行存放
例如： float a[3][4];
可以理解为：
其中数组a的存储顺序为：
####初始化
（1）一维数组的初始化
* 在定义数组时给出数组元素的初始值。
* 列出全部元素的初始值
例如：static int a[10]={0,1,2,3,4,5,6,7,8,9};
* 可以只给一部分元素赋初值
例如：static int a[10]={0,1,2,3,4};
* 在对全部数组元素赋初值时，可以不指定数组长度
例如：static int a[]={0,1,2,3,4,5,6,7,8,9}
(2)二维数组的初始化
* 将所有初值写在一个{}内，按顺序初始化
例如：static int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12
* 分行列出二维数组元素的初值
例如：static int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
* 可以只对部分元素初始化
例如：static int a[3][4]={{1},{0,6},{0,0,11}};
* 列出全部初始值时，第1维下标个数可以省略
例如：static int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};
或：static int a[][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
* 注意：
如果不作任何初始化，内部auto型数组中会存在**垃圾数据**，static数组中的数据**默认初始化为0**；
如果只对部分元素初始化，剩下的未显式初始化的元素，将**自动被初始化为零**；
###传参
* 数组元素作实参，与单个变量一样。
* 数组名作参数，形、实参数都应是数组名（实质上是地址），类型要一样，传送的是数组首地址。
* **对形参数组的改变会直接影响到实参数组。**
###对象数组
####定义和访问
（1）定义对象数组
类名 数组名[元素个数]；
（2）访问对象数组元素
通过下标访问：数组名[下标].成员名
####初始化
* 数组中每一个元素对象被创建时，系统都会调用类**构造函数初始化**该对象。
* 通过初始化列表赋值。
例：Point a[2]={Point(1,2),Point(3,4)};
* 如果没有为数组元素指定显式初始值，数组元素便使用默认值初始化（调用**默认构造函数**）。
* 元素所属的类不声明构造函数，则采用默认构造函数。
* 各元素对象的初值要求为相同的值时，可以声明具有默认形参值的构造函数。
* 各元素对象的初值要求为不同的值时，需要声明带形参的构造函数。
* 当数组中每一个对象被删除时，系统都要调用一次**析构函数**。
###基于范围的for循环
####原for循环
```
#include "iostream"
using namespace std;
int main() {
int array[3] = {1, 2, 3};
int *p;
for (p = array; p < array + sizeof(array) / sizeof(int); ++p) {
*p += 2;
std::cout << *p << std::endl;
}
}
```
####新for循环
```
#include "iostream"
using namespace std;
int main() {
int array[3] = {1, 2, 3};
for(int & e : array)
{
e += 2;
std::cout<<e<<std::endl;
}
return 0;
}
```
##指针
（1）内存空间的访问方式
* 通过变量名访问
* 通过地址访问
（2）指针的概念
* 指针：内存地址，用于间接访问内存单元
* 指针变量：用于存放地址的变量
###定义
（1）例：
static int i;
static int* ptr = &i;
（2）例：
*ptr = 3;
（3）与地址相关的运算——“*”和“&”
* 指针运算符：*
* **地址运算符：&**
###初始化
（1）语法形式：存储类型 数据类型 *指针名＝初始地址；
例：int *pa = &a;
（2）注意事项
* 用变量地址作为初值时，该变量必须在指针初始化之前已声明过，且变量类型应与指针类型一致。
* 可以用一个已有合法值的指针去初始化另一个指针变量。
* 不要用一个内部非静态变量去初始化 static 指针。
###赋值
（1）语法形式：指针名=地址
注意：“地址”中存放的数据类型与指针类型必须相符
（2）向指针变量赋的值必须是**地址常量或变量**，不能是普通整数。例如：
* 通过地址运算“&”求得已定义的变量和对象的起始地址
* 动态内存分配成功时返回的地址
（3）例外：整数0可以赋给指针，表示**空指针**。
（4）允许定义或声明指向 **void 类型的指针**。该指针可以被赋予任何类型对象的地址。
例： void *general;
####指针空值nullptr
（1）以往用0或者NULL去表达空指针的问题：
C/C++的NULL宏是个被有很多潜在BUG的宏。因为有的库把其定义成整数0，有的定义成 (void*)0。在C的时代还好。但是在C++的时代，这就会引发很多问题。
（2）C++11使用`nullptr`关键字，是表达更准确，类型安全的空指针
####指向常量的指针
> 不能通过指向常量的指针改变所指对象的值，但指针本身可以改变，可以指向另外的对象。
例：
```
int a;
const int *p1 = &a; //p1是指向常量的指针
int b;
p1 = &b; //正确，p1本身的值可以改变
*p1 = 1; //编译时出错，不能通过p1改变所指的对象(常量)
```
####指针类型的常量
> 若声明指针常量，则指针本身的值不能被改变。
例：
```
int a;
int * const p2 = &a;
p2 = &b; //错误，p2是指针常量，不能改变
```
###运算
####算术运算
* 指针p加上或减去n
其意义是指针当前指向位置的前方或后方第n个数据的起始位置。
* 指针的++、--运算
意义是指向下一个或前一个完整数据的起始。
* 运算的结果值取决于指针指向的数据类型，总是指向一个完整数据的起始位置。
* 当指针指向连续存储的同类型数据时，指针与整数的加减运和自增自减算才有意义。
（1）指针与整数相加的意义
####关系运算
* 指向相同类型数据的指针之间可以进行各种关系运算。
* 指向不同数据类型的指针，以及指针与一般整数变量之间的关系运算是无意义的。
* 指针可以和零之间进行等于或不等于的关系运算。
例如：p==0或p!=0
###指针与数组
####用指针访问数组
> 数组是一组连续存储的同类型数据，可以通过指针的算术运算，使指针依次指向数组的各个元素，进而可以遍历数组。
（1）定义与赋值：
例：int a[10], *pa;
pa=&a[0]; 或 pa=a;
经过上述定义及赋值后：
*pa就是a[0]，*(pa+1)就是a[1]，... ，*(pa+i)就是a[i]。a[i], *(pa+i), *(a+i), pa[i]都是等效的。
（2）注意：
不能写 a++，因为a是数组首地址、是常量。
（3）举例：
设有一个int型数组a，有10个元素。用三种方法输出各元素：
方法1：使用数组名和下标
```
#include "iostream"
using namespace std;
int main() {
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
for (int i = 0; i < 10; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
```
方法2：使用数组名和指针运算
```
#include "iostream"
using namespace std;
int main() {
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
for (int i = 0; i < 10; i++)
cout << *(a+i) << " ";
cout << endl;
return 0;
}
```
方法3：使用指针变量
```
#include "iostream"
using namespace std;
int main() {
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
for (int *p = a; p < (a + 10); p++)
cout << *p << " ";
cout << endl;
return 0;
}
```
###指针与函数
####以指针作为函数参数
> 为什么需要用指针做参数？
* 需要**数据双向传递**时（引用也可以达到此效果）
* 用指针作为函数的参数，可以使被调函数通过形参指针存取主调函数中实参指针指向的数据，实现数据的双向传递
* 需要传递一组数据，只传首地址运行效率比较高
* 实参是数组名时形参可以是指针
####指针类型的函数
（1）不要将非静态局部地址用作函数的返回值
（2）例子
```
#include "iostream"
using namespace std;
int *search(int *a,int num)
{
for(int i=0;i<10;i++)
{
if(a[i]==0)
return &a[i];
}
}
int main()
{
int arr[10];
int *search(int *a,int num);
for(int i=0;i<10;i++){
cin >> arr[i];
}
int *zeroptr= search(arr,10);
return 0;
}
```
####指向函数的指针
（1）定义形式
存储类型 数据类型 (*函数指针名)();
（2）含义
函数指针指向的是程序代码存储区。
（3）用途
> 实现函数回调
* 通过函数指针调用的函数
* 例如将函数的指针作为参数传递给一个函数，使得在处理相似事件的时候可以灵活的使用不同的方法。
调用者不关心谁是被调用者
* 需知道存在一个具有特定原型和限制条件的被调用函数。
###对象指针
（1）定义
类名 *对象指针名；
（2）例
```
Point a(5,10);
Piont *ptr;
ptr=&a;
```
（3）通过指针访问对象成员
对象指针名->成员名
例：**ptr->getx()** 相当于** (*ptr).getx();**
（4）举例
```
#include <iostream>
using namespace std;
class Point {
public:
Point(int x = 0, int y = 0) : x(x), y(y) { }
int getX() const { return x; }
int getY() const { return y; }
private:
int x, y;
};
int main() {
Point a(4, 5);
Point *p1 = &a; //定义对象指针，用a的地址初始化
cout << p1->getX() << endl;//用指针访问对象成员
cout << a.getX() << endl; //用对象名访问对象成员
return 0;
}
输出：
4
4
```
####this指针
* 指向当前对象自己
* **隐含于类的每一个非静态成员函数中**
* 指出成员函数所操作的对象
当通过一个对象调用成员函数时，系统先将该对象的地址赋给this指针，然后调用成员函数，成员函数对对象的数据成员进行操作时，就隐含使用了this指针。
* 例如：Point类的getX函数中的语句：return x;
相当于： return this->x;
* 例
```
class Fred; //前向引用声明
class Barney {
Fred *x;
};
class Fred {
Barney y;
};
```
###动态内存分配
####分配与释放
（1）动态申请内存操作符 new
new 类型名T（初始化参数列表）
功能：在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值。
结果值：成功：T类型的指针，指向新分配的内存；失败：抛出异常。
（2）释放内存操作符delete
delete 指针p
功能：释放指针p所指向的内存。p必须是new操作的返回值。
（3）举例
```
#include <iostream>
using namespace std;
class Point {
public:
Point() : x(0), y(0) {
cout<<"Default Constructor called."<<endl;
}
Point(int x, int y) : x(x), y(y) {
cout<< "Constructor called."<<endl;
}
~Point() { cout<<"Destructor called."<<endl; }
int getX() const { return x; }
int getY() const { return y; }
void move(int newX, int newY) {
x = newX;
y = newY;
}
private:
int x, y;
};
int main() {
cout << "Step one: " << endl;
Point *ptr1 = new Point; //调用默认构造函数
delete ptr1; //删除对象，自动调用析构函数
cout << "Step two: " << endl;
ptr1 = new Point(1,2);
delete ptr1;
return 0;
}
输出：
Step one:
Default Constructor called.
Destructor called.
Step two:
Constructor called.
Destructor called.
```
####动态数组
####动态多维数组
###智能指针
* 显式管理内存在是能上有优势，但容易出错。
* C++11提供智能指针的数据类型，对垃圾回收技术提供了一些支持，实现一定程度的内存管理
* 三类：
unique_ptr ：不允许多个指针共享资源，可以用标准库中的move函数转移指针
shared_ptr ：多个指针共享资源
weak_ptr ：可复制shared_ptr，但其构造或者释放对资源不产生影响
###vector对象
（1）为什么需要vector？
封装任何类型的动态数组，自动创建和删除。
数组下标越界检查。
（2）vector对象的定义
vector<元素类型> 数组对象名(数组长度);
（3）例：
```
vector<int> arr(5)//建立大小为5的int数组
```
####vector对象的使用
（1）对数组元素的引用
与普通数组具有相同形式：vector对象名 [ 下标表达式 ]
（2）vector数组对象名不表示数组首地址
获得数组长度用`size`函数：数组对象名.size()
（3）举例：
```
#include <iostream>
#include <vector>
using namespace std;
//计算数组arr中元素的平均值
double average(const vector<double> &arr) //vector的引用
{
double sum = 0;
for (unsigned i = 0; i<arr.size(); i++)
sum += arr[i];
return sum / arr.size();
}
int main() {
unsigned n;
cout << "n = ";
cin >> n;
vector<double> arr(n); //创建数组对象
cout << "Please input " << n << " real numbers:" << endl;
for (unsigned i = 0; i < n; i++)
cin >> arr[i];
cout << "Average = " << average(arr) << endl;
return 0;
}
输出：
n = 5
Please input 5 real numbers:
1
2
3
4
6
Average = 3.2
```
###深拷贝
####浅层复制
实现对象间数据元素的一一对应复制。
举例：
```
#include <iostream>
#include <cassert>
using namespace std;
class Point {
//类的声明同例6-16
//……
};
class ArrayOfPoints {
//类的声明同例6-18
//……
};
int main() {
int count;
cout << "Please enter the count of points: ";
cin >> count;
ArrayOfPoints pointsArray1(count); //创建对象数组
pointsArray1.element(0).move(5,10);
pointsArray1.element(1).move(15,20);
ArrayOfPoints pointsArray2(pointsArray1); //创建副本
cout << "Copy of pointsArray1:" << endl;
cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
<< pointsArray2.element(0).getY() << endl;
cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
<< pointsArray2.element(1).getY() << endl;
pointsArray1.element(0).move(25, 30);
pointsArray1.element(1).move(35, 40);
cout<<"After the moving of pointsArray1:"<<endl;
cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
<< pointsArray2.element(0).getY() << endl;
cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
<< pointsArray2.element(1).getY() << endl;
return 0;
}
运行结果如下：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Copy of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
After the moving of pointsArray1:
Point_0 of array2: 25, 30
Point_1 of array2: 35, 40
Deleting...
Destructor called.
Destructor called.
Deleting...
接下来程序出现运行错误。
```
####深层复制
当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是**将指针所指对象进行复制**。
> 当返回的对象含有动态创建的空间时，需要用深层复制
```
#include <iostream>
#include <cassert>
using namespace std;
class Point { //类的声明同例6-16
};
class ArrayOfPoints {
public:
ArrayOfPoints(const ArrayOfPoints& pointsArray);
//其他成员同例6-18
};
ArrayOfPoints::ArrayOfPoints(const ArrayOfPoints& v) {
size = v.size;
points = new Point[size];//重新创建空间
for (int i = 0; i < size; i++)
points[i] = v.points[i];
}
int main() {
//同例6-20
}
程序的运行结果如下：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Default Constructor called.
Default Constructor called.
Copy of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
After the moving of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
Deleting...
Destructor called.
Destructor called.
Deleting...
Destructor called.
Destructor called.
```
###移动构造函数
> 在现实中有很多这样的例子，我们将钱从一个账号转移到另一个账号，将手机SIM卡转移到另一台手机，将文件从一个位置剪切到另一个位置……移动构造可以减少不必要的复制，带来性能上的提升。
* C++11标准中提供了一种新的构造方法——移动构造。
* C++11之前，如果要将源对象的状态转移到目标对象只能通过复制。在某些情况下，我们没有必要复制对象——只需要移动它们。
* C++11引入移动语义：源对象资源的控制权全部交给目标对象
####问题
当临时对象在被复制后，就不再被利用了。我们完全可以把临时对象的资源直接移动，这样就避免了多余的复制操作。
####移动构造
> 什么时候该触发移动构造？
有可被利用的临时对象
移动构造函数:class_name ( class_name && )
##字符串
###字符数组
* 字符串常量
例："program"
* 各字符连续、顺序存放，每个字符占一个字节，以‘\0’结尾，相当于一个隐含创建的字符常量数组
* “program”出现在表达式中，表示这一char数组的首地址
* 首地址可以赋给char常量指针：
const char *STRING1 = "program";
####缺点
* 执行连接、拷贝、比较等操作，都需要显式调用库函数，很麻烦
* 当字符串长度很不确定时，需要用new动态创建字符数组，最后要用delete释放，很繁琐
* 字符串实际长度大于为它分配的空间时，会产生数组下标越界的错误
###string
使用字符串类string表示字符串
string实际上是对字符数组操作的封装
####构造函数
（1）string(); //默认构造函数，建立一个长度为0的串
例：
string s1;
（2）string(const char *s); //用指针s所指向的字符串常量初始化string对象
例：
string s2 = “abc”;
（3）string(const string& rhs); //复制构造函数
例：
string s3 = s2;
####常用操作
* s + t 将串s和t连接成一个新串
* s = t 用t更新s
* s == t 判断s与t是否相等
* s != t 判断s与t是否不等
* s < t 判断s是否小于t（按字典顺序比较）
* s <= t 判断s是否小于或等于t （按字典顺序比较）
* s > t 判断s是否大于t （按字典顺序比较）
* s >= t 判断s是否大于或等于t （按字典顺序比较）
* s[i] 访问串中下标为i的字符
例：
```
string s1 = "abc", s2 = "def";
string s3 = s1 + s2; //结果是"abcdef"
bool s4 = (s1 < s2); //结果是true
char s5 = s2[1]; //结果是'e'
```
####getline
> 如何输入整行字符串？
用cin的>>操作符输入字符串，会以空格作为分隔符，空格后的内容会在下一回输入时被读取
* getline可以输入整行字符串（要包string头文件），例如：getline(cin, s2);
* 输入字符串时，可以使用其它分隔符作为字符串结束的标志（例如逗号、分号），将分隔符作为getline的第3个参数即可，例如：getline(cin, s2, ',');
##程序
###数组
####存放数组
> 求Fibonacci数列的前20项
```
#include <iostream>
using namespace std;
int main() {
int i;
int f[20] = {1,1}; //初始化第0、1个数
for (i = 2; i < 20; i++) //求第2～19个数
f[i] = f[i - 2] + f[i - 1];
for (i=0;i<20;i++) { //输出，每行5个数
if (i % 5 == 0) cout << endl;
cout.width(12); //设置输出宽度为12
cout << f[i];
}
return 0;
}
输出：
1 1 2 3 5
8 13 21 34 55
89 144 233 377 610
987 1597 2584 4181 6765
```
####统计正确率
> 循环从键盘读入若干组选择题答案，计算并输出每组答案的正确率，直到输入ctrl+z为止。每组连续输入5个答案，每个答案可以是'a','b','c','d'。
```
#include <iostream>
using namespace std;
int main() {
const char key[ ] = {'a','c','b','a','d'};
const int NUM_QUES = 5;
char c;
int ques = 0, numCorrect = 0;
cout << "Enter the " << NUM_QUES << " question tests:" << endl;
while(cin.get(c)) //cin.get(c)得到的是输出流，所以只需要一次输入
{
if(c != '\n') {
if(c == key[ques]) {
numCorrect++; cout << " ";
} else
cout<<"*";
ques++;
} else {
cout << " Score " << static_cast<float>(numCorrect)/NUM_QUES*100 << "%";
ques = 0; numCorrect = 0; cout << endl;
}
}
return 0;
}
输出：
Enter the 5 question tests:
abcda
**** Score 20%
abcad
** Score 60%
cabcd
** * Score 40%
ddaca
***** Score 0%
```
####使用数组名作为函数参数
> 主函数中初始化一个二维数组，表示一个矩阵，矩阵，并将每个元素都输出，然后调用子函数，分别计算每一行的元素之和，将和直接存放在每行的第一个元素中，返回主函数之后输出各行元素的和。
```
#include <iostream>
using namespace std;
void rowSum(int a[][4], int nRow) {
for (int i = 0; i < nRow; i++) {
for(int j = 1; j < 4; j++)
a[i][0] += a[i][j];
}
}
int main() { //主函数
//定义并初始化数组
int table[3][4] = {{1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6}};
//输出数组元素
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++)
cout << table[i][j] << " ";
cout << endl;
}
rowSum(table, 3); //调用子函数，传入的是数组名，计算各行和
//输出计算结果
for (int i = 0; i < 3; i++)
cout << "Sum of row " << i << " is " << table[i][0] << endl;
return 0;
}
输出：
1 2 3 4
2 3 4 5
3 4 5 6
Sum of row 0 is 10
Sum of row 1 is 14
Sum of row 2 is 18
```
####对象数组应用
```
//Point.h
#ifndef _POINT_H
#define _POINT_H
class Point { //类的定义
public: //外部接口
Point();
Point(int x, int y);
~Point();
void move(int newX,int newY);
int getX() const { return x; }
int getY() const { return y; }
static void showCount(); //静态函数成员
private: //私有数据成员
int x, y;
};
#endif //_POINT_H
//Point.cpp
#include <iostream>
#include "Point.h"
using namespace std;
Point::Point() : x(0), y(0) {
cout << "Default Constructor called." << endl;
}
Point::Point(int x, int y) : x(x), y(y) {
cout << "Constructor called." << endl;
}
Point::~Point() {
cout << "Destructor called." << endl;
}
void Point::move(int newX,int newY) {
cout << "Moving the point to (" << newX << ", " << newY << ")" << endl;
x = newX;
y = newY;
}
#include "Point.h"
#include <iostream>
using namespace std;
int main() {
cout << "Entering main..." << endl;
Point a[2];
for(int i = 0; i < 2; i++)
a[i].move(i + 10, i + 20);
cout << "Exiting main..." << endl;
return 0;
}
输出：
Entering main...
Default Constructor called.
Default Constructor called.
Moving the point to (10, 20)
Moving the point to (11, 21)
Exiting main...
Destructor called.
Destructor called.
```
###指针
####void指针
```
#include <iostream>
using namespace std;
int main() {
//!void voidObject; 错，不能声明void类型的变量
void *pv; //对，可以声明void类型的指针
int i = 5;
pv = &i; //void类型指针指向整型变量
int *pint = static_cast<int *>(pv); //void指针转换为int指针
cout << "*pint = " << *pint << endl;
return 0;
}
输出：
*pint = 5
```
####指针表示矩阵
```
#include "iostream"
using namespace std;
int main()
{
int line1[]={1,0,1};
int line2[]={1,0,1};
int line3[]={1,0,1};
//定义整型指针数组并初始化
int *pline[3]={line1,line2,line3};
cout <<"矩阵："<< endl;
//输出
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
cout <<pline[i][j]<<" ";
}
cout << endl;
}
return 0;
}
输出：
矩阵：
1 0 1
1 0 1
1 0 1
```
####指针做形参
> 读入三个浮点数，将整数部分和小数部分分别输出
```
#include "iostream"
using namespace std;
void splitFloat(float x, int *intPart, float *fracPart) {
*intPart = static_cast<int>(x); //取x的整数部分
*fracPart = x - *intPart; //取x的小数部分
}
int main() {
cout << "Enter 3 float point numbers:" << endl;
for(int i = 0; i < 3; i++) {
float x, f;
int n;
cin >> x;
splitFloat(x, &n, &f); //变量地址作为实参
cout << "Integer Part = " << n <<endl<< "Fraction Part = " << f << endl;
}
return 0;
}
```
> 指向常量的指针做形参
```
#include "iostream"
using namespace std;
const int N = 6;
void print(const int *p, int n);
int main() {
int array
;
for (int i = 0; i < N; i++)
cin>>array[i];
print(array, N);
return 0;
}
void print(const int *p, int n) {
cout << "{ " << *p;
for (int i = 1; i < n; i++)
cout << ", " << *(p+i);
cout << " }" << endl;
}
输出：
1
2
3
4
5
6
{ 1, 2, 3, 4, 5, 6 }
```
####函数指针
> 编写一个计算函数compute，对两个整数进行各种计算。有一个形参为指向具体算法函数的指针，根据不同的实参函数，用不同的算法进行计算。编写三个函数：求两个整数的最大值、最小值、和。分别用这三个函数作为实参，测试compute函数
```
#include <iostream>
using namespace std;
int compute(int a, int b, int(*func)(int, int))
{ return func(a, b);}
int max(int a, int b) // 求最大值
{ return ((a > b) ? a: b);}
int min(int a, int b) // 求最小值
{ return ((a < b) ? a: b);}
int sum(int a, int b) // 求和
{ return a + b;}
int main()
{
int a, b, res;
cout << "请输入整数a："; cin >> a;
cout << "请输入整数b："; cin >> b;
res = compute(a, b, & max);
cout << "Max of " << a << " and " << b << " is " << res << endl;
res = compute(a, b, & min);
cout << "Min of " << a << " and " << b << " is " << res << endl;
res = compute(a, b, & sum);
cout << "Sum of " << a << " and " << b << " is " << res << endl;
}
输出：
请输入整数a：12
请输入整数b：32
Max of 12 and 32 is 32
Min of 12 and 32 is 12
Sum of 12 and 32 is 44
```
####动态数组类
```
#include <iostream>
#include <cassert>
using namespace std;
class Point { //类的声明同例6-16 … };
class ArrayOfPoints { //动态数组类
public:
ArrayOfPoints(int size) : size(size) {
points = new Point[size];
}
~ArrayOfPoints() {
cout << "Deleting..." << endl;
delete[] points;
}
Point& element(int index) {
assert(index >= 0 && index < size);
return points[index];
}
private:
Point *points; //指向动态数组首地址
int size; //数组大小
};
int main() {
int count;
cout << "Please enter the count of points: ";
cin >> count;
ArrayOfPoints points(count); //创建数组对象
points.element(0).move(5, 0); //访问数组元素的成员
points.element(1).move(15, 20); //访问数组元素的成员
return 0;
}
运行结果：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Deleting...
Destructor called.
Destructor called.
```
####vector数组
```
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v = {1,2,3};
for(auto i = v.begin(); i != v.end(); ++i)
std::cout << *i << std::endl;
for(auto e : v)//带范围的for循环
std::cout << e << std::endl;
}
```
####移动构造
> 函数返回含有指针成员的对象
（1）先给出使用深层复制构造函数，返回时构造临时对象，动态分配将临时对象返回到主调函数，然后删除临时对象。
```
#include<iostream>
using namespace std;
class IntNum {
public:
IntNum(int x = 0) : xptr(new int(x)){ //构造函数
cout << "Calling constructor..." << endl;
}
//n是参数对象的引用；*n.xptr取值；xptr(new int(*n.xptr)是深拷贝
IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//复制构造函数
cout << "Calling copy constructor..." << endl;
};
~IntNum(){ //析构函数
delete xptr;
cout << "Destructing..." << endl;
}
int getInt() { return *xptr; }
private:
int *xptr;
};
//返回值为IntNum类对象
IntNum getNum() {
IntNum a;//新建一个局部对象，调用构造函数
return a; //返回一个对象，调用复制构造函数
}
int main() {
IntNum p=getNum();
cout<<p.getInt()<<endl;
return 0;
}
输出：
Calling constructor...
Calling copy constructor...
Destructing...
0
Destructing...
```
（2）使用移动构造函数，将要返回的局部对象转移到主调函数，省去了构造和删除临时对象的过程。
```
#include<iostream>
using namespace std;
class IntNum {
public:
IntNum(int x = 0) : xptr(new int(x)){ //构造函数
cout << "Calling constructor..." << endl;
}
IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//复制构造函数
cout << "Calling copy constructor..." << endl;
//注：•&&是右值引用；•函数返回的临时变量是右值
}
IntNum(IntNum && n): xptr( n.xptr){ //移动构造函数
n.xptr = nullptr;
cout << "Calling move constructor..." << endl;
}
~IntNum(){ //析构函数
delete xptr;
cout << "Destructing..." << endl;
}
int getInt() { return *xptr; }
private:
int *xptr;
};
//返回值为IntNum类对象
IntNum getNum() {
IntNum a;
return a;
}
int main() {
cout << getNum().getInt() << endl; return 0;
}
输出：
Calling constructor...
Calling move constructor...
Destructing...
0
Destructing...
```
>上面两个程序输出是有问题的，待解决！
###字符串
####string
```
#include <string>
#include <iostream>
using namespace std;
//根据value的值输出true或false
//title为提示文字
inline void test(const char *title, bool value)
{
cout << title << " returns "
<< (value ? "true" : "false") << endl;
}
int main() {
string s1 = "DEF";
cout << "s1 is " << s1 << endl;
string s2;
cout << "Please enter s2: ";
cin >> s2;
cout << "length of s2: " << s2.length() << endl;
//比较运算符的测试
test("s1 <= \"ABC\"", s1 <= "ABC");
test("\"DEF\" <= s1", "DEF" <= s1);
//连接运算符的测试
s2 += s1;
cout << "s2 = s2 + s1: " << s2 << endl;
cout << "length of s2: " << s2.length() << endl;
return 0;
}
输出：
s1 is DEF
Please enter s2: eqwe
length of s2: 4
s1 <= "ABC" returns false
"DEF" <= s1 returns true
s2 = s2 + s1: eqweDEF
length of s2: 7
```
####getline
```
#include <iostream>
#include <string>
using namespace std;
int main() {
for (int i = 0; i < 2; i++){
string city, state;
getline(cin, city, ',');
getline(cin, state);
cout << "City:" << city << ",State:" << state << endl;
}
return 0;
}
输出：
San Francisco,the United States
City:San Francisco,State:the United States
Beijing,China
City:Beijing,State:China
```
##习题
（1）以下关于地址和指针的叙述中正确的是
* 可以取变量的地址赋值给同类型的指针变量（对）
* 可以取常量的地址赋值给同类型的指针变量
* 可以取一个指针变量的地址赋给本指针变量，这样就使得指针变量指向自身
* 所有指针变量如果未赋初值，则自动赋空值NULL
解析：A选项正确。常量存储在编译文件中，不能取地址。B选项错误。一个指针变量的地址只能赋给指向这种类型的指针变量，与其本身类型不同，不能赋值，C选项错误。未赋初值的指针变量自动赋任意地址值，D选项错误。
（2）要定义一个引用变量p使之引用类MyClass的一个对象,正确的定义语句是
* MyClass p=MyClass;
* MyClass p=new MyClass;
* MyClass ＆p=new MyClass;
* MyClass a, ＆p=a;（对），别名
（3）在C++的动态存储分配，下列说法正确的是？
* new和delete是C++语言中专门用于动态内存分配和释放的函数
* 动态分配的内存空间也可以被初始化（对）
* 当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间
* 当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new
分析：选项A，错，**new 与delete是用于动态平衡分配与释放空间的运算符**，不是函数;选项C，错，要使用delete释放空间，系统会统一管理，而不用delete释放的空间，会造成内存泄漏，这种程序用的次数多，会造成内存耗尽;选项D，错，不成功，会返回0。
（4）C++11中，＆表示左值引用；**＆＆表示右值引用**——下列关于左值和右值的说法正确的是
* 表达式等号左边的是左值，等号右边的是右值
* 左值是指表达式结束后依然存在的持久对象（对）
* 右值是指表达式结束后依然存在的持久对象
* 可以对右值取地址
分析：左值和右值都是针对表达式而言的，**左值是指表达式结束后依然存在的持久对象**，**右值指表达式结束时就不再存在的临时对象**——显然右值不可以被取地址。
