#include <iostream>class MaxFinder {public: MaxFinder(int* array, int length) { m_array = array; m_length = length; } int FindMax() { int max = m_array[0]; for (int i = 1; i < m_length; i++) { if (m_array[i] > max) { max = m_array[i]; } } return max; }private: int* m_array; int m_length;};int main() { int array[] = {1, 2, 3, 4, 5}; MaxFinder maxFinder(array, 5); int max = maxFinder.FindMax(); std::cout << "The max value is: " << max << std::endl; return 0;}

这个程序使用了一个MaxFinder类，其中包含了一个成员函数FindMax，用于寻找整型数组中的最大值。这个类的实例需要通过构造函数传入一个整型数组和数组的长度，然后就可以调用FindMax函数来获取最大值。

在main函数中，首先定义了一个整型数组array，并初始化了其元素值。然后创建了一个MaxFinder类的实例maxFinder，将整型数组和数组长度作为参数传入构造函数。接着调用maxFinder的FindMax函数，获取整型数组的最大值，并将其打印出来。

总的来说，这个程序的面向对象特点主要体现在MaxFinder类的封装和成员函数的调用上。MaxFinder类将整型数组和数组长度封装在内部，对外只暴露了FindMax函数来获取最大值。而在main函数中，只需要创建一个MaxFinder类的实例，并调用其FindMax函数即可完成整型数组最大值的求解，代码更加简洁和易于理解。

相关问题

设计整型数组ARRAY类，用来存放若干整数。它包含两个私有成员数据（int *pARRAY，length），pARRAY用来表示数组的首地址，length表示数组长度。 程序功能：首先读入n个整型数据存入ARRAY类对象；然后按照升序排序；最后按顺序输出所有数据。 main函数已给定，提交时只需要提交main函数外的代码部分。 #include<iostream> using namespace std; //你提交的代码在这里 int main() { int n,i,j,t; cin>>n; ARRAY a(n); cout<<"Initial:"<<a<<endl; for(i=0;i<n;i++) cin>>a[i]; cout<<"Before sort:"<<a<<endl; for(i=0;i<n-1;i++) for(j=0;j<n-i-1;j++) if(a[j]>a[j+1]) { t=*(a+j); *(a+j)=*(a+j+1); *(a+j+1)=t; } cout<<"After sort:"<<a<<endl; return 0; } Input 第1行包含1个正整数n，表示元素个数； 第2行中包括n个整数。 Output 参照样例格式输出。 Sample Input 1 5 3 6 5 1 2 Sample Output 1 Initial:length=5,element={0,0,0,0,0} Before sort:length=5,element={3,6,5,1,2} After sort:length=5,element={1,2,3,5,6}

#include<iostream>
using namespace std;

class ARRAY {
private:
    int* pARRAY;  //指向数组首地址的指针
    int length;  //数组长度
public:
    ARRAY(int len) {  //构造函数，动态分配内存
        pARRAY = new int[len];
        length = len;
        for (int i = 0; i < length; i++) {
            pARRAY[i] = 0;  //初始化为0
        }
    }
    ARRAY(const ARRAY& a) {  //复制构造函数，实现深拷贝
        pARRAY = new int[a.length];
        length = a.length;
        for (int i = 0; i < length; i++) {
            pARRAY[i] = a.pARRAY[i];
        }
    }
    ~ARRAY() {  //析构函数，释放内存
        delete[] pARRAY;
    }
    int& operator[](int i) {  //下标运算符重载，返回对应下标的值的引用
        return pARRAY[i];
    }
    friend ostream& operator<<(ostream& out, const ARRAY& a) {  //输出运算符重载
        out << "length=" << a.length << ",element={";
        for (int i = 0; i < a.length; i++) {
            out << a.pARRAY[i];
            if (i != a.length - 1) {
                out << ',';
            }
        }
        out << '}';
        return out;
    }
};

int main() {
    int n, i, j, t;
    cin >> n;
    ARRAY a(n);
    cout << "Initial:" << a << endl;
    for (i = 0; i < n; i++) {
        cin >> a[i];
    }
    cout << "Before sort:" << a << endl;
    for (i = 0; i < n - 1; i++) {  //冒泡排序
        for (j = 0; j < n - i - 1; j++) {
            if (a[j] > a[j + 1]) {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }
    cout << "After sort:" << a << endl;
    return 0;
}

编写一个集合类模板Set（可以参照教材中Array类模板），Set可以包含零个或多个无序的非重复元素。具体内容如下： （1）集合类模板Set template <class T> class Set { private: T* value; //T类型指针，用于存放集合的元素的动态数组，长度为length int size; //集合大小（元素个数） int length; //动态数组长度 public: Set(int len = 50); //构造函数 Set(Set<T>& A); //拷贝构造函数 （选做） ~Set( ); //析构函数 Set<T>& operator= (Set<T>& r); //重载"="使集合对象可以整体赋值 Set<T> operator+ (Set<T>& r); //重载"+"求两个集合对象的并集 void display( ); //输出集合中所有元素 Bool isExist(T v); //判断集合中是否包含元素v void add(T v); //向集合中添加一个元素 int getSize( ) ; // 返回集合的大小 int getLength( ); // 返回动态数组value的大小 void Resize(int len); // 修改动态数组value的大小 }; （2）设计并编写main函数，测试编写的类。

以下是Set类的实现：

#include <iostream>
#include <algorithm> //用于求并集

using namespace std;

template <class T>
class Set {
private:
    T* value; //T类型指针，用于存放集合的元素的动态数组，长度为length
    int size; //集合大小（元素个数）
    int length; //动态数组长度

public:
    Set(int len = 50); //构造函数
    Set(Set<T>& A); //拷贝构造函数（选做）
    ~Set(); //析构函数
    Set<T>& operator= (Set<T>& r); //重载"="使集合对象可以整体赋值
    Set<T> operator+ (Set<T>& r); //重载"+"求两个集合对象的并集
    void display(); //输出集合中所有元素
    bool isExist(T v); //判断集合中是否包含元素v
    void add(T v); //向集合中添加一个元素
    int getSize(); // 返回集合的大小
    int getLength(); // 返回动态数组value的大小
    void Resize(int len); // 修改动态数组value的大小
};

template <class T>
Set<T>::Set(int len) {
    size = 0;
    length = len;
    value = new T[length];
}

template <class T>
Set<T>::Set(Set<T>& A) {
    size = A.size;
    length = A.length;
    value = new T[length];
    for (int i = 0; i < size; i++) {
        value[i] = A.value[i];
    }
}

template <class T>
Set<T>::~Set() {
    delete[] value;
}

template <class T>
Set<T>& Set<T>::operator= (Set<T>& r) {
    if (this == &r) {
        return *this;
    }
    size = r.size;
    length = r.length;
    delete[] value;
    value = new T[length];
    for (int i = 0; i < size; i++) {
        value[i] = r.value[i];
    }
    return *this;
}

template <class T>
Set<T> Set<T>::operator+ (Set<T>& r) {
    Set<T> res(size + r.size);
    res.size = size + r.size;
    int i;
    for (i = 0; i < size; i++) {
        res.value[i] = value[i];
    }
    for (int j = 0; j < r.size; j++) {
        if (!isExist(r.value[j])) {
            res.value[i++] = r.value[j];
        }
    }
    return res;
}

template <class T>
void Set<T>::display() {
    for (int i = 0; i < size; i++) {
        cout << value[i] << " ";
    }
    cout << endl;
}

template <class T>
bool Set<T>::isExist(T v) {
    for (int i = 0; i < size; i++) {
        if (value[i] == v) {
            return true;
        }
    }
    return false;
}

template <class T>
void Set<T>::add(T v) {
    if (isExist(v)) {
        return;
    }
    if (size == length) {
        Resize(length * 2);
    }
    value[size++] = v;
}

template <class T>
int Set<T>::getSize() {
    return size;
}

template <class T>
int Set<T>::getLength() {
    return length;
}

template <class T>
void Set<T>::Resize(int len) {
    T* temp = new T[len];
    int n = min(len, length);
    for (int i = 0; i < n; i++) {
        temp[i] = value[i];
    }
    delete[] value;
    value = temp;
    length = len;
}

int main() {
    Set<int> s1(5);
    s1.add(1);
    s1.add(2);
    s1.add(3);
    s1.add(4);
    s1.display(); //1 2 3 4

    Set<int> s2(5);
    s2.add(3);
    s2.add(4);
    s2.add(5);
    s2.add(6);
    s2.display(); //3 4 5 6

    Set<int> s3 = s1 + s2;
    s3.display(); //1 2 3 4 5 6

    return 0;
}

在main函数中，我们创建了两个集合s1和s2，并向它们中添加元素。然后，我们调用重载运算符“+”求它们的并集s3，并输出s3中的元素。输出结果如下：

1 2 3 4 
3 4 5 6 
1 2 3 4 5 6