c++：-3

上一节学习了C++的函数：c++：-2，本节学习C++的数组、指针和字符串

数组

定义和初始化

定义

例如：int a[10];
表示a为整型数组，有10个元素：a[0]...a[9]

例如: int a[5][3];
表示a为整型二维数组，其中第一维有5个下标（0_{4），第二维有3个下标（0}2），数组的元素个数为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的存储顺序为：

\[a00,a01,a02,a03,a10,a11,a12,a13,a20,a21,a22,a23 \]

初始化

（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[]=

(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[N];
    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中，＆表示左值引用；＆＆表示右值引用——下列关于左值和右值的说法正确的是
• 表达式等号左边的是左值，等号右边的是右值
• 左值是指表达式结束后依然存在的持久对象（对）
• 右值是指表达式结束后依然存在的持久对象
• 可以对右值取地址
  分析：左值和右值都是针对表达式而言的，左值是指表达式结束后依然存在的持久对象，右值指表达式结束时就不再存在的临时对象——显然右值不可以被取地址。