Array类的实例与异常抛出

---

title: 类的实例与异常抛出
date: 2025-04-19 21:29:35
tags: [c++]
categories: c++

类的实例与异常抛出

源码

Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_

#include <iostream>

class Array{
private:
	enum {SIZE=1000};
	int data[SIZE]; 
	int size;       
	
public:
	Array();
	Array(const Array&rhs);
	Array(int const a[],int n);
	Array(int count,int value);
	
	void insert(int pos,int value);
	void remove(int pos);
	int at(int pos)const;
	void modify(int pos,int newValue);
	
	void disp()const;
    int getSize()const{return size;}
	
	Array& operator = (const Array&rhs);
	
	int& operator [] (int pos);
	const int& operator [] (int pos)const;
};

bool operator < (const Array&lhs,const Array&rhs);

bool operator == (const Array&lhs,const Array&rhs);

const Array operator + (const Array&lhs,const Array&rhs);

using std::ostream;
ostream& operator << (ostream&os,const Array&rhs);

#endif

Array.cpp

#include "Array.h"
#include <stdexcept>
#include <iostream>
using std::invalid_argument;
using std::overflow_error;
Array::Array(): size(0) {}
Array::Array(const Array& rhs): size(rhs.size) {
	for (int i = 0; i < size; ++i) {
		data[i] = rhs.data[i];
	}
}

Array::Array(int const a[], int n){
	if (n < 0 || n > SIZE) {
		throw invalid_argument(__func__);
	}
	size = n;
	for (int i = 0; i < size; ++i) {
		data[i] = a[i];
	}
}
Array::Array(int count, int value){
	if (count < 0 || count > SIZE) {
		throw invalid_argument(__func__);
	}
	size = count;
	for (int i = 0; i < size; ++i) {
		data[i] = value;
	}
}
void Array::insert(int pos, int value){
	if (pos < 0 || pos > size) {
		throw invalid_argument(__func__);
	}
	if (size >= SIZE) {
		throw overflow_error(__func__);
	}
	for (int i = size; i > pos; --i) {
		data[i] = data[i - 1];
	}
	data[pos] = value;
	++size;
}
void Array::remove(int pos){
	if (pos < 0 || pos >= size) {
		throw invalid_argument(__func__);
	}
	for (int i = pos; i < size - 1; ++i) {
		data[i] = data[i + 1];
	}
	--size;
}
int Array::at(int pos) const{
	if (pos < 0 || pos >= size) {
		throw invalid_argument(__func__);
	}
	return data[pos];
}
void Array::modify(int pos, int newValue) {
	if (pos < 0 || pos >= size) {
		throw invalid_argument(__func__);
	}
	data[pos] = newValue;
}
void Array::disp() const{
	for (int i = 0; i < size; ++i) {
		std::cout << data[i] << " ";
	}
}
Array& Array::operator = (const Array&rhs){
	size = rhs.size;
	for(int i = 0;i < size;i++){
		data[i] = rhs.data[i];
	}
	return *this;
}
int& Array::operator [] (int pos){
	return this -> data[pos];
}
const int& Array::operator [] (int pos)const{
	return this -> data[pos];
}
bool operator < (const Array&lhs,const Array&rhs){
	int minSize = std::min(lhs.getSize(), rhs.getSize());
	for (int i = 0; i < minSize; ++i) {
		if (lhs.at(i) < rhs.at(i)) {
			return true;
		}
		if (lhs.at(i) > rhs.at(i)) {
			return false;
		}
	}
	return lhs.getSize() < rhs.getSize();
}
bool operator == (const Array&lhs,const Array&rhs){
	bool flag = false;
	if(lhs.getSize() == rhs.getSize()){
		flag = true;
	}
	return flag;
}
const Array operator + (const Array&lhs,const Array&rhs){
	int tsize = lhs.getSize()+rhs.getSize();
	int tdata[tsize];
	for(int i = 0;i < lhs.getSize();i++){
		tdata[i] = lhs.at(i);
	}
	for(int i = 0; i < rhs.getSize(); ++i){
		tdata[lhs.getSize() + i] = rhs.at(i);
	}
	Array temp(tdata,tsize);
	return temp;
}
ostream& operator << (ostream&os,const Array&rhs){
	rhs.disp();
	return os;
}

main.cpp

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

int main(){
	int n,m;
	cin>>n>>m;
	Array a(n,0),b(m,0);
	for(int i=0;i<n;++i) cin>>a[i];
	for(int i=0;i<m;++i) cin>>b[i];
	cout<<a<<endl;
	cout<<b<<endl;
	cout<<(a==b)<<endl;
	cout<<(a<b)<<endl;
	Array c;
	c = a = a + b;
	cout<<c<<endl;
	return 0;
}

分析

主要对array.cpp进行分析

Array::Array(): size(0) {}

对Array进行初始化，初始元素为0个

Array::Array(const Array& rhs): size(rhs.size) {
	for (int i = 0; i < size; ++i) {
		data[i] = rhs.data[i];
	}
}

构造函数拷贝。用size(rhs.size)把元素个数先赋值，然后用循环把data数组成员变量复制

Array::Array(int const a[], int n){
	if (n < 0 || n > SIZE) {
		throw invalid_argument(__func__);
	}
	size = n;
	for (int i = 0; i < size; ++i) {
		data[i] = a[i];
	}
}

构造函数，要求前面是数组，后面是数组个数。前面的数组用来给data赋值，后面的n用来给size赋值

如果个数n不合法，那么就抛出异常throw invalid_argument(__func__);此处invalid_argument指的是异常类型，__func__是指带上该构造函数表示该函数异常。

Array::Array(int count, int value){
	if (count < 0 || count > SIZE) {
		throw invalid_argument(__func__);
	}
	size = count;
	for (int i = 0; i < size; ++i) {
		data[i] = value;
	}
}

构造函数，前面是数后面是该数字的个数，意思为把data数组中前count个元素赋值为value。

void Array::insert(int pos, int value){
	if (pos < 0 || pos > size) {
		throw invalid_argument(__func__);
	}
	if (size >= SIZE) {
		throw overflow_error(__func__);
	}
	for (int i = size; i > pos; i--) {
		data[i] = data[i - 1];
	}
	data[pos] = value;
	++size;
}

成员函数，用来在第pos个元素之后插入一个元素value，之后把size的值加一表示数组元素个数增加1。

void Array::remove(int pos){
	if (pos < 0 || pos >= size) {
		throw invalid_argument(__func__);
	}
	for (int i = pos; i < size - 1; i++) {
		data[i] = data[i + 1];
	}
	--size;
}

成员函数，用来在第pos个元素处删除一个元素，之后把size的值减一表示数组元素个数减少1。

int Array::at(int pos) const{
	if (pos < 0 || pos >= size) {
		throw invalid_argument(__func__);
	}
	return data[pos];
}

成员函数，用来返回第pos个元素的值。const表示不能修改成员变量，出于安全考虑。

void Array::modify(int pos, int newValue) {
	if (pos < 0 || pos >= size) {
		throw invalid_argument(__func__);
	}
	data[pos] = newValue;
}

成员函数，用于更新第pos个元素的值。

void Array::disp() const{
	for (int i = 0; i < size; ++i) {
		std::cout << data[i] << " ";
	}
}

display函数，用来输出Array中的数组。

Array& Array::operator = (const Array&rhs){
	size = rhs.size;
	for(int i = 0;i < size;i++){
		data[i] = rhs.data[i];
	}
	return *this;
}

成员函数运算符重载，等于号为赋值。把左边的Array类中的size和数组全复制过去。

int& Array::operator [] (int pos){
	return this -> data[pos];
}
const int& Array::operator [] (int pos)const{
	return this -> data[pos];
}

成员函数运算符重载，方括号运算符。对Array使用方括号运算符，里面的pos指data[pos]。

bool operator < (const Array&lhs,const Array&rhs){
	int minSize = std::min(lhs.getSize(), rhs.getSize());
	for (int i = 0; i < minSize; ++i) {
		if (lhs.at(i) < rhs.at(i)) {
			return true;
		}
		if (lhs.at(i) > rhs.at(i)) {
			return false;
		}
	}
	return lhs.getSize() < rhs.getSize();
}

运算符重载，这个<比较符号是一个比较复杂的比较。会先比较前几个元素，若前几个元素相同的话则比较大小。

bool operator == (const Array&lhs,const Array&rhs){
	bool flag = false;
	if(lhs.getSize() == rhs.getSize()){
		flag = true;
	}
	return flag;
}

运算符重载，等于号，判断元素个数是否相等。

const Array operator + (const Array&lhs,const Array&rhs){
	int tsize = lhs.getSize()+rhs.getSize();
	int tdata[tsize];
	for(int i = 0;i < lhs.getSize();i++){
		tdata[i] = lhs.at(i);
	}
	for(int i = 0; i < rhs.getSize(); ++i){
		tdata[lhs.getSize() + i] = rhs.at(i);
	}
	Array temp(tdata,tsize);
	return temp;
}

运算符重载，用于两个array类的相加。

ostream& operator << (ostream&os,const Array&rhs){
	rhs.disp();
	return os;
}

输出运算符重载，用于展示Array中的元素。

输入

3 3
1 2 3
1 2 3

输出

1 2 3
1 2 3
1
0
1 2 3 1 2 3