6.22C++：复习常引用、数组类模板、数组类模板的使用、“输入一个数，输出比它小的质数”普通写法 =

1 复习常引用

C++引用
（1）&在此不是求地址运算，而是起标识作用。

（2）类型标识符是指目标变量的类型。

（3）声明引用时，必须同时对其进行初始化。

（4）引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。

ra=1; 等价于 a=1;

（5）声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。故：对引用求地址，就是对目标变量求地址。&ra与&a相等。

（6）不能建立数组的引用。因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名。

int a = 10;
const int &b = a;// b是a的常引用，不能通过b改变a

2 数组类模板

#ifndef ARRAY_H
#define ARRAY_H
#include <cassert>

template <class T>  //数组类模板定义
class Array {
private:
    T* list;        //用于存放动态分配的数组内存首地址
    int size;       //数组大小（元素个数）
public:
    Array(int sz = 50);     //构造函数
    Array(const Array<T>& a);   //复制构造函数
    ~Array();           //析构函数
    Array<T>& operator = (const Array<T>& rhs);    //重载"=“
    T& operator [] (int i); //重载"[]”，[]是双目运算符
    const T& operator [] (int i) const;     //重载"[]”常函数
    operator T* ();        //重载到T*类型的转换
    operator const T* () const;
    int getSize() const;        //取数组的大小
    void resize(int sz);        //修改数组的大小
};

template <class T> 
Array<T>::Array(int sz) {//构造函数
    assert(sz >= 0);//sz为数组大小（元素个数），应当非负
    size = sz;  // 将元素个数赋值给变量size
    list = new T[size];    //动态分配size个T类型的元素空间
}

template <class T> 
Array<T>::~Array() { //析构函数
    delete[] list;
}

template <class T>
Array<T>::Array(const Array<T>& a) {    //复制构造函数
    size = a.size;     //从对象x取得数组大小，并赋值给当前对象的成员
    list = new T[size]; // 动态分配n个T类型的元素空间
    for (int i = 0; i < size; i++)     //从对象X复制数组元素到本对象 
        list[i] = a.list[i];
}
//续上，重载"="运算符，将对象rhs赋值给本对象。实现对象之间的整体赋值
template <class T>
//重载=的意义在于避免析构时，动态指针多次删除，系统报错
Array<T>& Array<T>::operator = (const Array<T>& rhs) {
	//rhs是Array对象的常引用，如果本对象的指针不指向rhs，即本对象与rhs对象不同，才进行赋值操作
    if (&rhs != this) {
        //如果本对象中数组大小与rhs不同，则删除数组原有内存，然后重新分配
        if (size != rhs.size) {
            delete[] list; //删除数组原有内存
            size = rhs.size;    //设置本对象的数组大小
            list = new T[size];  //重新分配size个元素的内存
        }
        //从对象X复制数组元素到本对象  
        for (int i = 0; i < size; i++)
            list[i] = rhs.list[i];
    }
    return *this;   //返回当前对象的引用,必须返回左值，否则不能对其进行操作
}
//重载下标运算符，实现与普通数组一样通过下标访问元素，具有越界检查功能
template <class T>
T& Array<T>::operator[] (int n) {
// []为双目运算符，Array对象和n为两个参数
    assert(n >= 0 && n < size);  //检查下标是否越界
    return list[n];       //返回下标为n的数组元素
}

template <class T>
const T& Array<T>::operator[] (int n) const {
    assert(n >= 0 && n < size);  //检查下标是否越界
    return list[n];
}    //返回下标为n的数组元素，返回的是个引用，因为使用[]是希望可以既能读取这个内部数组元素，也能改变它

//重载指针转换运算符，将Array类的对象名转换为T类型的指针
template <class T>
Array<T>::operator T* () {
	return list;    //返回当前对象中私有数组的首地址
}

//取当前数组的大小
template <class T>
int Array<T>::getSize() const {
	return size;
}

// 将数组大小修改为sz
template <class T>
void Array<T>::resize(int sz) {
	assert(sz >= 0);    //检查sz是否非负
	if (sz == size) //如果指定的大小与原有大小一样，什么也不做
		return;
	T* newList = new T[sz];    //申请新的数组内存
    int n = (sz < size) ? sz : size;//将sz与size中较小的一个赋值给n
    //将原有数组中前n个元素复制到新数组中
    for (int i = 0; i < n; i++)
    	newList[i] = list[i];
    delete[] list;      //删除原数组
    list = newList; // 使list指向新数组
    size = sz;  //更新size
}
#endif  //ARRAY_H

①动态分配能够存放size个T元素的空间，首地址赋值给list

list = new T [size]; 

析构函数中释放空间

template <class T> 
Array<T>::~Array() { //析构函数
    delete[] list;
}

②++优先级最高，先处理自增

a[count++] //count++返回自增1之前的老值。

③为什么要写复制构造函数？
——存在指向动态分配内存空间的指针的时候，需要进行深层复制。避免浅层复制两个指针指向同一内存空间，释放空间时释放两次，程序报错。

④为什么要重载 “ = ”？
当一个类需要些深层复制构造函数时，往往需要重载“=”赋值运算符

Array<int> a(10);
Array<int> b(20);
b = a;

和写复制构造函数的原因相同，赋值运算符是浅层复制。
因为该类中存在指向动态数组的指针，不重载“=”，如果用一个对象对另一个对象赋值，b和a的指针指向同一地址，析构函数释放空间时会释放两次， 程序报错，下图的报错和不进行深层复制的报错相同。

⑤赋值和深层复制的区别
深层复制是在对象刚刚诞生时让它跟已有对象完全一致。
而“赋值”是一个对象已经存续一段时间了，再将另一个对象的值赋给它，所以相比深层复制应该增加判断：
第一步判断参数对象和当前对象是不是相同；

if (&rhs != this)

第二步判断两个对象的元素个数是否一样，如果是一样的，直接进行复制；如果不是一样的，先释放原有内存空间，再进行深层复制。

 if (size != rhs.size) {
            delete[] list; //删除数组原有内存
            size = rhs.size;    //设置本对象的数组大小
            list = new T[size];  //重新分配size个元素的内存
        }
//从对象X复制数组元素到本对象  
for (int i = 0; i < size; i++)
	list[i] = rhs.list[i];
    }

⑥重载下标运算符[ ]，是对象名a可以当数组名使用，[ ]是双目运算符，a[i]相当于a.operator [] (i)

⑦重载指针转换运算符，将a转换为int*类型，要求不要指定返回值类型。
int *p = a --> int * a --> 调用函数 return list

//重载指针转换运算符，将Array类的对象名转换为T类型的指针
template <class T>
Array<T>::operator T* () {
	return list;    //返回当前对象中私有数组的首地址
}

#include "Array.h"
#include <iostream>
using namespace std;
void read(int *p, int n) {
	for (int i = 0; i < n; i++)
		cin >> p[i];
}
int main() {
Array<int> a(10);
read(a, 10);//重载后a可以当做T类型指针
return 0;
} 

⑧动态数组的优点
运行时根据需要调整大小，注意动态数组的操作要验证合法性，注意要及时删除不用的动态空间。
但动态调整时间、空间开销比较大，不要频繁的调整。

3 数组类模板的使用

①return 不加任何后续 表示函数结束，但什么也不做
②#include <cassert>
assert（断言） 的作用是现计算表达式 expression ，如果其值为假（即为0），那么它先向 stderr 打印一条出错信息,然后通过调用 abort 来终止程序运行。
使用 assert 的缺点是，频繁的调用会极大的影响程序的性能，增加额外的开销。

③Array的功能类似 Vector，可以动态创建不同类型、不同长度的数组，并具有基本功能
下面主函数可以随心定义动态数组的类型、长度，且可以在运行时改变数组长度。

#include <iostream>
#include <iomanip>
#include "Array.h"
using namespace std;
int main() {
    // 用来存放质数的数组，初始状态有10个元素
    Array<int> a(10);

    int n, count = 0;
    cout << "Enter a value >= 2 as upper limit for prime numbers: ";
    cin >> n;

    for (int i = 2; i <= n; i++) { //检查i是否能被比它小的质数整除
        bool isPrime = true;
        for (int j = 0; j < count; j++)
            //若i被a[j]整除，说明i不是质数
            if (i % a[j] == 0) {
                isPrime = false; 
                break;
            }
        if (isPrime) {
            if (count == a.getSize())
                a.resize(count * 2); //动态的好处，可以根据需求扩展动态数组长度
            a[count++] = i;
        }
    }
    for (int i = 0; i < count; i++)
        cout << setw(8) << a[i];//setw（8）属于 <iomanip>，设置字段宽度为n位
    cout << endl;
    return 0;
}

函数运行流程：
①第一次循环把2作为指数，赋值给a[0]；
②后续依次把验证出来的质数赋值给a[1]、a[2]…a[n]
③验证的方式是，i是否能被比它小的质数整除。
（6除以3得2 那么6就能被3整除）

注意不用验证每个比i小的数，i如果不能被比它小的任何质数整除，那么它绝对不能被比它小的合数整除，所以这个数没有因子，是质数。
（若p则q==逆否命题：若非q则非p）

④如果输入的数较大，数组长度不够，则将数组的长度乘以2
⑤用< iomanip >中的setw（8）输出数组元素iomanip使用方法

4 “输入一个数，输出比它小的质数”普通写法

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
	int m, count = 0;
	cout << "输入一个数，输出比它小的所有质数：";
	cin >> m;
	bool isPrime;
	int* ptr = new int[m-1];//采用动态数组，避免数组长度不够
	for (int i = 2; i <= m; i++) {
		isPrime = true; //每个数检测前都要复位flag
		for (int j = 2; j <= sqrt(i); j++) {
			if (i % j == 0) {
				isPrime = false;
				break;
			}
		}
		if (isPrime)
			ptr[count++] = i;
	}
	for (int i = 0; i < count; i++)
		cout << ptr[i] << setw(6);
	delete [] ptr;//删除指向动态数组的指针
	return 0;
}