面向对象程序设计第三次实验课——Wuxing

于 2017-05-29 12:28:20 发布
阅读量571 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jlu_nnbs/article/details/72801589
版权
这篇博客详细介绍了使用面向对象程序设计方法实现五行（金木水火土）关系的模拟，包括类的设计、单例模式的应用、相生相克关系的表示以及所属关系的管理。博主分析了设计难点，如概念抽象、单例模式实现和关系打印，并讨论了代码的优点和不足。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这里写图片描述

请无视奇葩常量名……

// wuxing.h

#pragma once
#include <iostream>
#include <cstring>
#include <string>
using namespace std;

const int MAX = 100; // 每个元素所存储所属的最大个数 
const int XING = 6; // 记录元素总共的种类 
enum Element {KONG, WATER, WOOD, FIRE, EARTH, GOLD};// 定义常量元素类型 

class Wuxing {  
    friend ostream& operator<< (ostream& out, const Wuxing& rhs);   
    friend bool operator< (const Wuxing& lhs, const Wuxing& rhs); // 判断相生关系 
    friend bool operator> (const Wuxing& lhs, const Wuxing& rhs); // 判断相克关系 
    public:
        // 单例模式，新建对象 
        static Wuxing* newWuxing(void);
        static Wuxing* newWuxing(const string& s);
//      Wuxing* newWuxing(const char* s);

        ~Wuxing(void) {};
        void addBelong(const string& s);//向元素中添加关系 
        void delBelong(const string& s);//向元素中删除关系 
        void clear(void) {cnt_ = 0;} ; // 清除所有包含关系 

        static void findRelation(const Wuxing& obj);//查找五行间关系 
        static void showWuxing(const Wuxing& obj);  //打印五行 
        static Wuxing* findInXing(const string& s); //查找所属在哪一个元素中 
        static Wuxing* judge(const string& s);
    private:
        // 构造函数是private的，运用了单例模式 
        Wuxing(void);
        Wuxing(const char *s);
        Wuxing(const string& s);
//      Wuxing(const Wuxing& obj);
//      Wuxing& operator= (const Wuxing& rhs);
        int findBelong(const string& s) const;
        void formattedPrint(int state) const;
        Wuxing* findLive (void) const;
        Wuxing* findDie (void) const;
        Wuxing* findBeLived (void) const;
        Wuxing* findBeDead (void) const;

        Element tag_;  // 标记当前对象的属性（元素）是什么 
        string belong_[MAX]; // 保存所属 
        int cnt_;   // 记录当前元素所属的个数 
        static Wuxing* exist[XING]; // 存储单例模式下每个元素对应的对象指针 
};

ostream& operator<< (ostream& out, const Wuxing& rhs);  
bool operator< (const Wuxing& lhs, const Wuxing& rhs);
bool operator> (const Wuxing& lhs, const Wuxing& rhs);
//wuxing.cpp

#include "wuxing.h"

Wuxing* Wuxing::exist[XING] = {0};

Wuxing::Wuxing(void) : Wuxing("空") {}
Wuxing::Wuxing(const char *s) : cnt_(0)
{
    if (!strcmp(s, "金")) {
        tag_ = GOLD;
    } else if (!strcmp(s, "木")) {
        tag_ = WOOD;
    } else if (!strcmp(s, "水")) {
        tag_ = WATER;
    } else if (!strcmp(s, "火")) {
        tag_ = FIRE;
    } else if (!strcmp(s, "土")) {
        tag_ = EARTH;
    } else {
        tag_ = KONG;
    }
}
Wuxing::Wuxing(const string& s) 
{
    if (s == "金") {
        tag_ = GOLD; 
    } else if (s == "木") {
        tag_ = WOOD;
    } else if (s == "水") {
        tag_ = WATER;
    } else if (s == "火") {
        tag_ = FIRE;
    } else if (s == "土") {
        tag_ = EARTH;
    } else {
        tag_ = KONG;
    }
}
Wuxing* Wuxing::newWuxing(const string& s)
{
    int tag;
    Wuxing *p;
    if (s == "金") {
        tag = GOLD; 
    } else if (s == "木") {
        tag = WOOD;
    } else if (s == "水") {
        tag = WATER;
    } else if (s == "火") {
        tag = FIRE;
    } else if (s == "土") {
        tag = EARTH;
    } else {
        tag = KONG;
    }
    if (exist[tag] == NULL) {
        exist[tag] = new Wuxing(s);
    } 
    return exist[tag];
}
Wuxing* Wuxing::newWuxing(void)
{
    return newWuxing("空"); 
}
void Wuxing::addBelong(const string& s)
{
    belong_[cnt_ ++] = s;
    return ;
}
void Wuxing::delBelong(const string& s)
{
    int loc = findBelong(s);
    if (loc == -1) {
        cout << "该属性中并不包含" << s << endl;
        return ;
    }
    for (int i = loc + 1; i < cnt_; i ++) {
        belong_[i - 1] = belong_[i];
    }
    -- cnt_;
    return ;
}

int Wuxing::findBelong(const string& s) const
{
    int ret = -1;
    for (int i = 0; i < cnt_; i ++) {
        if (s == belong_[i]) {
            ret = i;
            break;
        }
    }
    return ret;
}
void Wuxing::formattedPrint(int state) const
{
    // 0:head 1:mid 2:tail
    const int SPACE = 6;
    if (state == 0) {
        cout << "-----> " ;
    } else if (state == 2 && cnt_ == 0){
        cout << "------ " ;
    } else {
        cout << "|" ;
        for (int i = 0; i < SPACE; i ++) {
            cout << " ";
        }
    }

    cout << "属性：" ; 
    switch (tag_) {
        case KONG:
            cout << "空" ;
            break;
        case GOLD:
            cout << "金" ;
            break;
        case WOOD:
            cout << "木" ;
            break;
        case WATER:
            cout << "水" ;
            break;
        case FIRE:
            cout << "火" ;
            break;
        case EARTH:
            cout << "土" ;
            break;
    }

    if (cnt_) {
        cout << endl << "|";
        for (int i = 0; i < SPACE; i ++) {
            cout << " ";
        }
        cout << "包含：" ;
//      cout << "|";
//      for (int i = 0; i < SPACE; i ++) {
//          cout << " " ;
//      }
//      cout << belong_[0];
    }
    for (int i = 0; i < cnt_ - 1; i ++) {
        cout << endl << "|";
        for (int j = 0; j < SPACE; j ++) {
            cout << " " ;
        } 
        cout << belong_[i];
    }
//  cout << "state: " << state << endl;
    if (cnt_ - 1 >= 0) {
        cout << endl;
        if (state == 2) {
            cout << "------ ";
        } else {
            cout << "|";
            for (int i = 0; i < SPACE; i ++) {
                cout << " ";
            }
        }
        cout << belong_[cnt_ - 1];
    }
    return ;
}
Wuxing* Wuxing::findLive(void) const
{
    int post = tag_ + 1;
    if (post >= XING) {
        post = post - XING + 1;
    }
    return exist[post];
}
Wuxing* Wuxing::findDie (void) const
{
    int post = tag_ + 2;
    if (post >= XING) {
        post = post - XING + 1;
    }
    return exist[post];
}
Wuxing* Wuxing::findBeLived (void) const
{
    int pre = tag_ - 1;
    if (pre <= 0) {
        pre += XING - 1;
    }
    return exist[pre];
}
Wuxing* Wuxing::findBeDead (void) const
{
    int pre = tag_ - 2;
    if (pre <= 0) {
        pre += XING - 1;
    }
    return exist[pre];
}

Wuxing* Wuxing::findInXing(const string& s)
{
    for (int i = 0; i < XING; i ++) {
        if (exist[i]) {
            if (exist[i]->findBelong(s) != -1) {
                return exist[i];
            }
        }
    }
    return NULL;
}
void Wuxing::findRelation(const Wuxing& obj)
{
    if (obj.tag_ == KONG) {
        cout << "空即是色，色即是空！" << endl << endl;
        return ;
    }

    Wuxing *p = obj.findLive();
    if (p) {
        cout << "当前属性所生的是：" << endl;
        cout << *p << endl << endl;
    }

    p = obj.findDie();
    if (p) {
        cout << "当前属性所克的是：" << endl;
        cout << *p << endl << endl;
    }

    p = obj.findBeLived();
    if (p) {
        cout << "生当前属性的是：" << endl;
        cout << *p << endl << endl;
    }

    p = obj.findBeDead();
    if (p) {
        cout << "克当前属性的是：" << endl;
        cout << *p << endl << endl;
    }
    return ;
}
void Wuxing::showWuxing(const Wuxing& obj)
{
    const Wuxing *p = &obj;
    int loc;
    for (int i = 0; i < XING; i ++) {
        if (exist[i] == p) {
            loc = i;
            break;
        }
    }
    if (loc == 0) {
        return ;
    }
    const int SPACE = 6;
    int cnt = 1;
    for (int i = loc; i < XING && exist[i] != NULL; i ++, cnt ++) {
//      cout << "cnt:" << cnt << endl;
//      cout << "XING:" << XING << endl;
        if (i == loc) {
            exist[i] -> formattedPrint(0);
            cout << endl << "|" << endl;
        } else if (cnt == XING - 1) {
            exist[i] -> formattedPrint(2);
            cout << endl << endl;
        } else {
            exist[i] -> formattedPrint(1);
            cout << endl << "|" << endl;
        } 
    }
    for (int i = 1; i < loc; i ++, cnt ++) {
        if (cnt == XING - 1) {
            exist[i] -> formattedPrint(2);
            cout << endl << endl;
        } else {
            exist[i] -> formattedPrint(1);
            cout << endl << "|" << endl;
        } 
    }
    return ;
}
Wuxing* Wuxing::judge(const string& s)
{
    int tag;
    if (s == "金") {
        tag = GOLD; 
    } else if (s == "木") {
        tag = WOOD;
    } else if (s == "水") {
        tag = WATER;
    } else if (s == "火") {
        tag = FIRE;
    } else if (s == "土") {
        tag = EARTH;
    } else {
        tag = KONG;
    }
    return exist[tag];
}

ostream& operator<< (ostream& out, const Wuxing& rhs)
{
    out << "属性：" ; 
    switch (rhs.tag_) {
        case KONG:
            out << "空";
            break;
        case GOLD:
            out << "金";
            break;
        case WOOD:
            out << "木";
            break;
        case WATER:
            out << "水";
            break;
        case FIRE:
            out << "火";
            break;
        case EARTH:
            out << "土";
            break;
        default:
            out << "ERROR" << endl;
    }

    if (rhs.cnt_) {
        out << endl << "包含：" << endl;
        out << rhs.belong_[0];
    }
    for (int i = 1; i < rhs.cnt_; i ++) {
        out << endl << rhs.belong_[i];
    }
    return out;
}
bool operator< (const Wuxing& lhs, const Wuxing& rhs) // lhs 生 rhs为真 
{
    if (lhs.tag_ == 0 || rhs.tag_ == 0) {
        return false;
    }
    int post = lhs.tag_ + 1;
    if (post == XING) {
        post = 1;
    } 
    if (post == rhs.tag_) {
        return true;
    } else {
        return false;
    }
}
bool operator> (const Wuxing& lhs, const Wuxing& rhs) // lhs 克 rhs为真 
{
    if (lhs.tag_ == 0 || rhs.tag_ == 0) {
        return false;
    }
    int post = lhs.tag_ + 2;
    if (post >= XING) {
        post = post - XING + 1;
    }
    if (post == rhs.tag_) {
        return true;
    } else {
        return false;
    }
}
// main.cpp

#include <iostream>
#include "wuxing.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv)
{
    Wuxing *pW0 = Wuxing::newWuxing();
    Wuxing *pW1 = Wuxing::newWuxing("金"); 
    Wuxing *pW2 = Wuxing::newWuxing("木");
    Wuxing *pW5 = Wuxing::newWuxing("火");
    Wuxing *pW4 = Wuxing::newWuxing("水");
    Wuxing *pW3 = Wuxing::newWuxing("土");
    cout << "五行：金木水火土，其他非法输入将被认为是元素“空”"  << endl; 
    cout << "1. 添加某元素所属" << endl;
    cout << "2. 删除某元素所属" << endl;
    cout << "3. 查询某元素与其他所有元素关系" << endl;
    cout << "4. 查询某物是否属于某一元素" << endl;
    cout << "5. 清除某元素所有的所属关系" << endl;
    cout << "6. 判断两个元素的关系" << endl;
    cout << "7. 打印单个元素" << endl;
    cout << "8. 打印所有元素" << endl;
    cout << "9. 退出" << endl;
    int i, val, k;
    string s1,s2;
    Wuxing* p = NULL, *p2 = NULL;
    while (cin >> i, i != 9) {  
        switch (i) {
            case 1:
                cout << "请输入要添加所属关系的元素：" << endl;
                cout << "(金木水火土)中选一个，否则将向“空”元素中添加所属" << endl;
                cin >> s1;
                cout << "请输入所属的内容" << endl;
                cin >> s2;
                p = Wuxing::judge(s1);
                if (p) {
                    p -> addBelong(s2);
                }   
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 2:
                cout << "请输入要删除所属关系的元素：" << endl;
                cout << "(金木水火土)中选一个，否则将向“空”元素中删除所属" << endl;
                cin >> s1;
                cout << "请输入所属的内容" << endl;
                cin >> s2;
                p = Wuxing::judge(s1);
                if (p) {
                    p -> delBelong(s2);
                }   
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 3:
                cout << "请输入要查询的元素" << endl;
                cin >> s1;
                Wuxing::findRelation(*Wuxing::judge(s1));
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 4:
                cout << "请输入要查询的所属" << endl;
                cin >> s1;
                p = Wuxing::findInXing(s1);
                if (p) {
                    cout << *p << endl;
                } else {
                    cout << "没有找到！" << endl;
                }
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 5:
                cout << "请输入要清空所属的元素" << endl;
                cin >> s1;
                p = Wuxing::judge(s1);
                if (p) {
                    p -> clear();
                }
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 6:
                cout << "请输入要查询的元素：" << endl;
                cout << "(金木水火土)中选两个个，否则将视为“空元素”" << endl;
                cin >> s1 >> s2;
                p = Wuxing::judge(s1);
                p2 = Wuxing::judge(s2);
                if (p && p2) {
                    if (*p > *p2) {
                        cout << *p << endl<<"克"<<endl << *p2 <<endl;
                    }
                    if (*p < *p2) {
                        cout << *p << endl<<"生"<<endl << *p2 <<endl;
                    }
                    if (*p2 > *p) {
                        cout << *p2 << endl<<"克"<<endl << *p <<endl;
                    }
                    if (*p2 < *p) {
                        cout << *p2 << endl<<"生"<<endl << *p <<endl;
                    }
                }   
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 7:
                cout << "请输入要查询的元素" << endl;
                cin >> s1;
                p = Wuxing::judge(s1);
                if (p) {
                    cout << *p << endl;
                }
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 8:
                cout << "请输入要从哪个元素开始输出" << endl;
                cin >> s1;
                p = Wuxing::judge(s1);
                if (p) {
                    Wuxing::showWuxing(*p); 
                }
                cout << "操作结束" << endl;
                cout << "--------------------------" << endl;
                break;
            case 9:
                return 0;
                break;
            default:
                cout << "请输入正确的序号" << endl;
                cout << "--------------------------" << endl;
        }
    }
//  pW1 -> addBelong("铁");
//  pW1 -> addBelong("铜");
//  pW1 -> addBelong("银");
//  pW2 -> addBelong("树");
//  pW3 -> addBelong("墙");
//  pW4 -> addBelong("雨");
//  pW5 -> addBelong("太阳"); 
//  cout << *pW0 << endl;
//  cout << *pW1 << endl;
//  pW1 -> delBelong("hello");
//  cout << *pW1 << endl;
//  pW1 -> delBelong("铁");
//  cout << *pW1 << endl;
//  auto p1 = Wuxing::findInXing("hello");
//  if (p1) {
//      cout << "在下面的元素中：" << endl;
//      cout << *p1 << endl;
//  } else {
//      cout << "没找到！"  << endl; 
//  }
//  p1 = Wuxing::findInXing("银");
//  if (p1) {
//      cout << "在下面的元素中：" << endl;
//      cout << *p1 << endl;
//  } else {
//      cout << "没找到！"  << endl; 
//  } 
//  cout << "金" << endl; 
//  Wuxing::findRelation(*pW1);
//  cout << "火" << endl;
//  Wuxing::findRelation(*pW5);
//  Wuxing::showWuxing(*pW4);
//  Wuxing *pW6 = Wuxing::newWuxing("土");
//  cout << *pW3 << endl;
//  cout << *pW6 << endl; 
    return 0;
}

实验报告

一、 题目分析

  1. 描述五行各自关系
    我决定使用一个类来描述五行，通过不同对象的实例化分别描述金木水火土，并且使用了单例模式，规定每一个元素只能对应各自的一个对象。
  2. 描述相生相克关系，保留扩展可能
    首先重载了大于和小于运算符，分别代表克与生，判断两个元素之间的生克关系，之后又通过另外四个函数分别寻找生克的元素。通过两个运算符和四个函数，保留了进一步表示其他关系的可能。同时尽量使用常量，提高可维护性。
  3. 保存归属关系
    在类中添加私有数据成员，记录所属的物品和一共的数量。
  4. 实现整体图形输出，可以指定起点
    按照相生的顺序输出即可。
  5. 查询任意指定五行元素关系和所属
    查询所属即遍历五行中的所属物，查询关系调用四个寻找生克的函数即
    可。

二、 流程分析

  1. 构造函数：
    共3个， 分别是：
    Wuxing(void);
    Wuxing(const char *s);
    Wuxing(const string& s);
    为了考虑到可能会有的隐式类型转换，这里使用了这三个构造函数，不过他们都是private的，因为使用了单例模式。

  2. 创建对象的接口
    共2个，分别是
    static Wuxing* newWuxing(void);
    static Wuxing* newWuxing(const string& s);
    单例模式的应用，如果对象没有创建，则调用相应的构造函数

  3. 添加，删除与清空所属
    void addBelong(const string& s);//向元素中添加关系
    void delBelong(const string& s);//向元素中删除关系
    void clear(void) {cnt_ = 0;} ; // 清除所有包含关系首先实现
    直接操纵数据成员，没用调用其他函数。

  4. 描述生克关系
    // 判断相生关系
    friend bool operator< (const Wuxing& lhs, const Wuxing& rhs);
    // 判断相克关系
    friend bool operator> (const Wuxing& lhs, const Wuxing& rhs);
    Wuxing* findLive (void) const;
    Wuxing* findDie (void) const;
    Wuxing* findBeLived (void) const;
    Wuxing* findBeDead (void) const;

        以上函数均是直接操纵数据成员，并没有调用其他函数。

  5. 查询所属与元素生克关系
    Private:
    int findBelong(const string& s) const;
    public:
    static void findRelation(const Wuxing& obj);//查找五行间关系
    static Wuxing* findInXing(const string& s); //查找所属在哪一个元素中
    private中的findBelong是非静态的，只能查找当前元素中是否有所属，
    而findInXing则是静态的，通过调用每一个对象的findBelong查找所属。
    findRelation则是通过调用findLive findDie findBelived findBeDead实现查找生克关系元素。

  6. 打印
    Private：
    void formattedPrint(int state) const;
    public：
    static void showWuxing(const Wuxing& obj);
    showWuxing 调用formmattedPrint，向formattedPrint传递参数，标记是第一个打印、最后一个打印还是中间打印的元素。

三、程序难点

1. 需求分析

对于一个十分抽象的概念和题目，很难找到程序设计中对应的模型，因此这一点是整个实验的重中之重。使用一个类对应五行（因为五行每一个元素内部要存储的数据和相应的操作是相同的），同一个类的不同实例代表不同元素，使用静态方法对整个类中的所有对象进行操作。
2. 单例模式
因为对于五行而言，其每个金木水火土应该是唯一的，不应该存在多个，而其所属是多样的，因此使用了单例模式，然而这个单例模式是应该允许存在5种单例，所以存储指针的结构使用了数组，而要求5种单例必须也是不同的，即使当前单例的个数不足5个，要新建了同一种元素的对象，也应该返回已存在的对象指针。因此对于不同的元素，对应不同的指针，而相同元素对应同一个指针。为了解决其他不属于五行情况，特别添加了“空”元素，所有不在五行之中的元素全部添加到空元素中。
3. 打印关系
这一条是比较考验细节的部分，我觉得我实现的并不是很好，我觉得我不应该在这里浪费太多的时间，一是在实际情况下不可能用命令行展示，实际情况下应该使用图形界面，而图形界面可以很好的解决打印的格式问题。二是打印并不是本次实验的重点，也不是面向对象程序设计的内容，本次实验的重点应该在于如何建模，而不是考虑这些细枝末节的内容。

四、 优点与缺点

优点：
a) 满足了基本要求
b) 使用了单例模式
c) 编码过程中在能力范围内尽可能地考虑了可维护性，如使用常量，重载运算符等等（也确实在发现错误修改的过程中起到了很大作用）
缺点：
a) 没有实现扩展要求
b) 没有美观的打印

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值