C++/Array类的实例

69 阅读 0 评论 46 点赞

我是靠谱客的博主美丽小丸子，最近开发中收集的这篇文章主要介绍C++/Array类的实例，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

//头文件/Array.h

/*Array.h*/
#pragma once
#ifndef ARRAY_H
#define ARRAY_H
#include <iostream>
/**/
class Array
{
/*友元函数，重载流插入、流提取运算符*/
/*1、用户自定义的类型的数据，要使用流插入"<<"和流提取">>"必须进行重载
2、流插入，流提取只能重载为全局函数，不能重载为成员函数*/
/*1、重载为友元函数，参数的个数等于操作数个数；重载为成员函数时，参数个数等于操作数减1
2、返回值类型为引用，支持级联调用	3、第一个参数为ostream类的引用，第二个参数为
Array类的引用（如果不使用引用，改为传参则会调用拷贝构造函数，增加开销），加const是因为流提取，输出内容，不需要更改*/
friend std::ostream &operator<<(std::ostream &, const Array&);
/*重载流提取，第一个参数为istream类的引用，第二个参数为Array类的引用（避免调用拷贝构造函数），
流提取需要输入内容，所以不加const*/
friend std::istream &operator>>(std::istream &, Array &);
public:
/*1、默认构造函数，单参，使用explicit避免隐式的类型转换
2、使用了默认参数*/
explicit Array(int = 10);
/*转换构造函数：1、作用：实现类型的自动转换
2、判断：一般满足1.单参构造函数，
2.不是拷贝构造函数 即为转换构造函数
3、运行原理：当需要时，系统自动调用，并建立一个无名的临时对象（或变量）
3、使用引用参数，避免使用值传递，从而造成无限拷贝*/
Array(const Array &);
/*析构函数*/
~Array();
/*获取数组大小*/
size_t getSize() const;
/*1、重载赋值运算符
2、重载为成员函数，参数的个数等于操作数个数减一*/
const Array& operator=(const Array&);
/*重载判断是否相等的运算符*/
bool operator==(const Array&) const;
/*重载不等运算符*/
bool operator!=(const Array& right) const
{
return !(*this == right);
}
/*重载[]运算符*/
int &operator[](int);
/*重载[]运算符*/
int operator[](int) const;
private:
/*size_t是一种无符号的整型数，它的取值没有负数，取值范围是整型数的双倍*/
size_t size;
/*定义一个整型指针*/
int* ptr;
};
#endif // !1

源文件/Array.cpp

/*Array.cpp*/
#include "Array.h"
#include <iostream>
#include <iomanip>
#include <stdexcept>
using namespace std;
Array::Array(int arraySize)
/*判断参数的有效性，满足条件则为私有成员size赋值，否则抛出异常提示*/
: size(arraySize > 0 ? arraySize :
throw invalid_argument("Array size must be greater than 0")),
/*使用new运算符动态创建长度为int的整型数组，并将数组的首地址赋值给Array类的私有
成员整型指针ptr*/
ptr(new int[size])
{/*使用for循环，将数组的所有元素初始化为0*/
for (size_t i = 0; i < size; ++i) {
ptr[i] = 0;
}
}
/*1、使用引用，避免值传递造成无限调用拷贝函数
2、加const，因为无需修改参数的值*/
Array::Array(const Array& arrayToCopy)
/*将引用对象的size值赋值给私有成员size*/
:size(arrayToCopy.size),
/*使用new运算符动态创建一个长为size的整型数组，并将数组的首地址赋值为私有成员
整型指针ptr*/
ptr(new int[size])
{	/*使用for循环对所有数据元素初始化为0*/
for (size_t i = 0; i < size; ++i) {
/*这里使用了数据赋值的方式*/
ptr[i] = arrayToCopy.ptr[i];
}
}
Array::~Array()
{	/*使用delete释放数组内存空间，一定要加下标运算符[]，否则只会释放数组的第一个元素*/
delete[] ptr;
}
/*获取数组长度大小*/
size_t Array::getSize() const
{
return size;
}
/*1、重载赋值运算符
2、参数为Array的引用（避免使用值传递，调用拷贝构造函数从而增加开销）
3、参数使用const，参数不需要修改，避免参数被修改	4、函数返回值为const Array引用
使用引用是为了支持级联调用，使用const是为了防止(a=b)=c即作为左值这种情况的发生*/
const Array& Array::operator=(const Array& right)
{	/*判断引用的参数是否为当前对象，避免自我复制*/
if (&right != this)
{	/*当前对象的size值不等于引用对象的size值时*/
if (size != right.size) {
/*释放ptr所指的全部内容*/
delete[] ptr;
/*将当前对象的size值赋值为引用对象的size值*/
size = right.size;
/*用运算符new动态创建一个长为size的整型数组，并由Array类的私有成员
整型指针ptr指向数组的首地址*/
ptr = new int[size];
}
/*使用for循环将数组的所有元素初始化为0*/
for (size_t i = 0; i < size; ++i) {
ptr[i] = right.ptr[i];
}
}
/*返回当前对象的const引用*/
return *this;
}
/*常量对象，常量成员函数，常引用：
1、常量对象：const Demo obj; //对象obj的值不能被修改
2、常量成员函数：在函数后面加const关键字，
不能修改其作用的对象（对象的数据成员不能被修改），也不能调用同类的非常量成员函数（因为同类的非常量成员函数可能会修改其作用的对象）
（静态成员变量和静态成员函数除外（静态的为所有对象所共有））
可以重载：int f() const;
int f();
3、常引用：使用对象的引用作为参数，避免值传递导致拷贝构造函数被调用，从而增加开销。加上const防止引用修改了实参，
这样既高效又安全*/
/*1、重载是否相等的运算符	2、*/
bool Array::operator==(const Array& right) const {
if (size != right.size) {
return false;
}
for (size_t i = 0; i < size; ++i) {
if (ptr[i] != right.ptr[i]) {
return false;
}
return true;
}
}
int & Array::operator[](int subscript) {
if (subscript < 0 || subscript >= size) {
throw out_of_range( "Subscript out of range");
}
return ptr[subscript];
}
int Array::operator[](int subscript) const {
if (subscript < 0 || subscript >= size) {
throw out_of_range("Subscript out of range ");
}
return ptr[subscript];
}
istream& operator>>(istream& input, Array& a) {
for (size_t i = 0; i < a.size; ++i) {
input >> a.ptr[i];
}
return input;
}
ostream& operator<<(ostream& output, const Array& a) {
for (size_t i = 0; i < a.size; ++i) {
output << setw(12) << a.ptr[i];
if ((i + 1) % 4 == 0) {
output << endl;
}
}
/*每次输出4个元素，然后进行换行*/
if (a.size % 4 != 0) {
output << endl;
}
return output;
}

测试程序/main.cpp

/*main.cpp*/
#include <iostream> 
#include <stdexcept>
#include "Array.h"
using namespace std;
int main() {
Array integers1(7);
Array integers2;
cout << "Size of Array integers1 is "
<< integers1.getSize()
<< "nArray after initialization:n"
<< integers1;
cout << "nSize of Array integers2 is "
<< integers2.getSize()
<< "nArray after initialization :n"
<< integers2;
cout << "nEnter 17 integers: "
<< endl;
cin >> integers1 >> integers2;
cout << "nAfter input , the Arrays contain :n"
<< "integers1:n" << integers1
<< "integers2:n" << integers2;
cout << "nEvaluating: integers1 != integers2 " << endl;
integers1 = integers2;
cout << "integers1:n" << integers1
<< "integers2:n" << integers2;
cout << "nEvaluating: integers1 == integers2" << endl;
if (integers1 == integers2) {
cout << "integers1 and integers2 are equal" << endl;
}
cout << "nintegers1[5] is " << integers1[5];
cout << "nnAssigning 1000 to integers1[5]" << endl;
integers1[5] = 1000;
cout << "integers1:n" << integers1;
try {
cout << "nAttemp to assign 1000 to integers1[15]" << endl;
integers1[15] = 1000;
}
catch (out_of_range& ex) {
cout << "An exception occurred: " << ex.what() << endl;
}
}