C++学习笔记（Day16 第九章线性群体、数据类模板）

线性群体的概念

• 群体是指由多个数据元素组成的集合体。群体可以分为两个大类：线性群体和非线性群体。

• 线性群体中的元素按位置排列有序，可以区分为第一个元素、第二个元素等。

• 非线性群体不用位置顺序来标识元素。

• 线性群体中的元素次序与其逻辑位置关系是对应的。在线性群体中，又可按照访问元素的不同方法分为直接访问、顺序访问和索引访问。

• 在本章我们只介绍直接访问和顺序访问。

数组类模板

• 静态数组是具有固定元素个数的群体，其中的元素可以通过下标直接访问。

  • 缺点：大小在编译时就已经确定，在运行时无法修改。

• 动态数组由一系列位置连续的，任意数量相同类型的元素组成。

  • 优点：其元素个数可在程序运行时改变。

• vector就是用类模板实现的动态数组。 

为什么有的函数返回引用

• 如果一个函数的返回值是一个对象的值，就是右值，不能成为左值。

• 如果返回值为引用。由于引用是对象的别名，通过引用可以改变对象的值，因此是左值。

 重载指针转换运算符

例9-3 动态数组类模板程序看pdf 较为繁琐

//
// Created by BoBo on 2021/10/20.
//
#ifndef ARRAY_H
#define ARRAY_H
#include <cassert>
using namespace std;

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);
    size = sz;
    list = new T [size];
}
template <class T> Array<T>::~Array() {
    delete []list;//完全删除动态分配的内存空间
}//析构函数

template <class T>
Array<T>::Array(const Array<T> &a){
    size = a.size;
    list = new T[size];
    for (int i = 0;i<size;i++)
        list[i] = a.list[i];
}
//重载“=”运算符，将对象rhs赋值给本对象，实现对象之间的整体赋值
template <class T>
Array<T> &Array<T>::operator = (const Array<T>& rhs){
    if(&rhs != this){
        if(size != rhs.size){
            delete [] list;
            size = rhs.size;
            list = new T[size];
        }
        for(int i =0;i<size;i++)
            list[i]= rhs.list[i];
    }
    return *this;
}
//重载下标运算符，实现与欧通数组一样通过下标访问元素，具有越界检查功能
template <class T>
T &Array<T>::operator[](int n){
    assert(n >= 0 && n<size);
    return list[n];
}
template <class T>
const T &Array<T>::operator[](int n) const{
    assert(n >= 0 && n < size);
    return list[n];
}
template <class T>
Array<T>:: operator T *(){
    return list;
}
template<class T>
int Array<T>::getSize() const{
    return size;
}
template<class T>
void Array<T>::resize(int sz){
    assert(sz >= 0);
    if(sz == size)
        return;
    T* newList = new T [sz];
    int n= (sz <size)?sz:size;
    for(int i=0;i<n;i++)
        newList[i]=list[i];
    delete[] list;
    list = newList;
    size = sz;
}
#endif //ARRAY_H

例9-4数组类应用举例

 求范围2~N中的质数，N在程序运行时由键盘输入。

条件：重点在于检查是否能被比他小的质数整除

#include <iostream>
#include <iomanip>
#include "Array.h"
using namespace std;

int main() {
    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++){
        bool isPrime = true;
        for(int j = 0; j< count;j++)
            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];
    cout << endl;
    return 0;
}

运行结果：

Enter a value >= 2 as upper limit for prime numbers: 13
       2       3       5       7      11      13