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;
}